Changeset 6

Timestamp:

01/26/07 18:19:10 (6 years ago)

Author:

ged

Message:

- implemented the generation and use of primaryjoins for

belongs_to/has_one/has_many relationships. This is needed to allow
more than one belongs_to relation between two entities

- fixed a small bug to allow the same for has_and_belongs_to_many relations.
- added unit tests to test for those situations

Location:

supermodel/trunk/supermodel

Files:

• relationships.py (modified) (8 diffs)
• tests/test_multi.py (added)

supermodel/trunk/supermodel/relationships.py

@@ -159 +159 @@
         
         self.foreign_key = []
+        self.primaryjoin_clauses = list()
+
         for key in target_desc.primary_keys:
-            keycol = key.column
-            refcol = target_desc.tablename + '.' + keycol.name
+            pk_col = key.column
+            refcol = target_desc.tablename + '.' + pk_col.name
             #CHECKME: why do we use a Field here instead of directly using a 
             # Column
-            field = Field(keycol.type, colname=self.name + '_' + keycol.name,
+            field = Field(pk_col.type, colname=self.name + '_' + pk_col.name,
                           index=True)
             
@@ -171 +173 @@
             columns.append(field.column.name)
             source_desc.add_field(field)
+
+            # build up the primary join. This is needed when you have several
+            # belongs_to relations between two objects
+            self.primaryjoin_clauses.append(field.column == pk_col)
         
         # TODO: better constraint-naming?
@@ -184 +190 @@
             cols = [k.column for k in self.target._descriptor.primary_keys]
             kwargs['remote_side'] = cols
+
+        kwargs['primaryjoin'] = and_(*self.primaryjoin_clauses)
         
         #CHECKME: is this of any use?
@@ -211 +219 @@
                                         for f in self.inverse.foreign_key]
         
+        kwargs['primaryjoin'] = and_(*self.inverse.primaryjoin_clauses)
         #CHECKME: is this of any use?
 #        kwargs['backref'] = self.inverse.name
@@ -230 +239 @@
             if self.inverse.secondary:
                 self.secondary = self.inverse.secondary
+                self.primaryjoin_clauses = self.inverse.secondaryjoin_clauses
+                self.secondaryjoin_clauses = self.inverse.primaryjoin_clauses
 
         if not self.secondary:
@@ -242 +253 @@
             # case. I think it's also usefull when you have several many-to-many
             # relations between the same objects. I'll have to test that...
+            # no it's not since the tables are different. It would only if the
+            # tables where the same, but I'm not sure if it has some sense to be
+            # in that situation.
 #            if self.entity is self.target:
 #                print "many2many self ref detected"
-            self.primary_clauses = list()
-            self.secondary_clauses = list()
+            self.primaryjoin_clauses = list()
+            self.secondaryjoin_clauses = list()
 
             for desc, join_name in ((e1_desc, 'primary'), 
@@ -279 +293 @@
 
                     # build join clauses
-                    getattr(self, join_name+'_clauses').append(col == pk_col)
+                    join_list = getattr(self, join_name+'join_clauses')
+                    join_list.append(col == pk_col)
                 
                 # TODO: better constraint-naming?
@@ -306 +321 @@
         kwargs = self.kwargs
 
-        if self.entity is self.target:
-            kwargs['primaryjoin'] = and_(*self.primary_clauses)
-            kwargs['secondaryjoin'] = and_(*self.secondary_clauses)
+        if self.target is self.entity:
+            kwargs['primaryjoin'] = and_(*self.primaryjoin_clauses)
+            kwargs['secondaryjoin'] = and_(*self.secondaryjoin_clauses)
 
         m = self.entity.mapper