Changeset 481

Timestamp:

09/30/09 20:25:04 (4 years ago)

Author:

ged

Message:

- added test for migration after M2M column format change through local_colname
- tablename, remote_colname, local_colname, schema and table_kwargs can now be

defined on either side of a ManyToMany relationship and will propagate to
the other side if that other side doesn't specify anything for that argument.
Also added an assertion to catch the case where the same/mirror
argument is specified on both sides but with different values.

- refactored slightly the code for the table rename migration_aid so that it is

more readable.

Location:

elixir/trunk

Files:

• elixir/relationships.py (modified) (5 diffs)
• tests/test_m2m.py (modified) (2 diffs)

elixir/trunk/elixir/relationships.py

@@ -906 +906 @@
                'secondaryjoin' not in self.kwargs:
                 self._build_join_clauses()
+            assert self.inverse is None or self.inverse.table is None or \
+                   self.inverse.table is self.table
             return
 
         if self.inverse:
-            if self.inverse.table is not None:
-                self.table = self.inverse.table
-                self.primaryjoin_clauses = self.inverse.secondaryjoin_clauses
-                self.secondaryjoin_clauses = self.inverse.primaryjoin_clauses
+            inverse = self.inverse
+            if inverse.table is not None:
+                self.table = inverse.table
+                self.primaryjoin_clauses = inverse.secondaryjoin_clauses
+                self.secondaryjoin_clauses = inverse.primaryjoin_clauses
                 return
+
+            assert not inverse.user_tablename or not self.user_tablename or \
+                   inverse.user_tablename == self.user_tablename
+            assert not inverse.remote_colname or not self.local_colname or \
+                   inverse.remote_colname == self.local_colname
+            assert not inverse.local_colname or not self.remote_colname or \
+                   inverse.local_colname == self.remote_colname
+            assert not inverse.schema or not self.schema or \
+                   inverse.schema == self.schema
+            assert not inverse.table_kwargs or not self.table_kwargs or \
+                   inverse.table_kwargs == self.table_kwargs
+
+            self.user_tablename = inverse.user_tablename or self.user_tablename
+            self.local_colname = inverse.remote_colname or self.local_colname
+            self.remote_colname = inverse.local_colname or self.remote_colname
+            self.schema = inverse.schema or self.schema
+            self.local_colname = inverse.remote_colname or self.local_colname
 
         # compute table_kwargs
@@ -961 +981 @@
                 #     table name twice)?
                 tablename = "%s__%s" % (target_part, source_part)
-                if options.MIGRATION_TO_07_AID and \
-                   e1_desc.tablename >= e2_desc.tablename:
-                    oldname = "%s__%s" % (source_part, target_part)
+            else:
+                tablename = "%s__%s" % (source_part, target_part)
+
+            if options.MIGRATION_TO_07_AID:
+                oldname = (self.inverse and
+                           e1_desc.tablename < e2_desc.tablename) and \
+                          "%s__%s" % (target_part, source_part) or \
+                          "%s__%s" % (source_part, target_part)
+                if oldname != tablename:
                     warnings.warn(
                         "The generated table name for the '%s' relationship "
@@ -973 +999 @@
                         % (self.name, self.entity.__name__, oldname,
                            tablename, oldname))
-            else:
-                tablename = "%s__%s" % (source_part, target_part)
 
         if e1_desc.autoload:
@@ -1014 +1038 @@
                 fk_colnames = []
                 fk_refcols = []
-
                 if colnames:
                     assert len(colnames) == len(desc.primary_keys)
@@ -1097 +1120 @@
         # In the case we have a self-reference, we need to build join clauses
         if self.entity is self.target:
-            #TODO: we should check if that information was defined on the
-            #inverse relationship. We have two options: either we force the
-            #definition on both sides, or we accept defining on one side only.
-            #In the later case, we still need to make the check as to not
-            #peusdo-randomly fail depending on initialization order.
             if not self.local_colname and not self.remote_colname:
                 raise Exception(

elixir/trunk/tests/test_m2m.py

@@ -139 +139 @@
         assert 'inverse_id' in m2m_cols
 
-    def test_upgrade(self):
+    def test_upgrade_rename_col(self):
         elixir.options.M2MCOL_NAMEFORMAT = elixir.options.OLD_M2MCOL_NAMEFORMAT
 
@@ -212 +212 @@
         assert a2.is_linked_from == [a1]
 
+    def test_upgrade_local_colname(self):
+        elixir.options.M2MCOL_NAMEFORMAT = elixir.options.OLD_M2MCOL_NAMEFORMAT
+
+        class A(Entity):
+            using_options(shortnames=True)
+            name = Field(String(20))
+            links_to = ManyToMany('A')
+            is_linked_from = ManyToMany('A')
+            bs_ = ManyToMany('B')
+
+        class B(Entity):
+            using_options(shortnames=True)
+            name = Field(String(20))
+            as_ = ManyToMany('A')
+
+        setup_all(True)
+
+        a = A(name='a1', links_to=[A(name='a2')])
+
+        session.commit()
+        session.clear()
+
+        del A
+        del B
+
+        # do not drop the tables, that's the whole point!
+        cleanup_all()
+
+        # ...
+        elixir.options.M2MCOL_NAMEFORMAT = elixir.options.NEW_M2MCOL_NAMEFORMAT
+#        elixir.options.MIGRATION_TO_07_AID = True
+
+        class A(Entity):
+            using_options(shortnames=True)
+            name = Field(String(20))
+            links_to = ManyToMany('A', local_colname='a_id1')
+            is_linked_from = ManyToMany('A', local_colname='a_id2')
+            bs_ = ManyToMany('B')
+
+        class B(Entity):
+            using_options(shortnames=True)
+            name = Field(String(20))
+            as_ = ManyToMany('A')
+
+        setup_all()
+
+        a1 = A.get_by(name='a1')
+        assert len(a1.links_to) == 1
+        assert not a1.is_linked_from
+
+        a2 = a1.links_to[0]
+        assert a2.name == 'a2'
+        assert not a2.links_to
+        assert a2.is_linked_from == [a1]
+
     def test_manual_column_format(self):
         class A(Entity):