Changeset 14

Timestamp:

02/01/07 20:56:24 (6 years ago)

Author:

ged

Message:

- updated/added comments.
- removed some unused code
- when an inverse of a relation is found, also check that it has not several

inverses. Since the inverse of a relation is not processed, it was possible
to have a relation with several inverse not raise an exception.

- first step in making autoload tables work: do not create a pk for

autoloaded tables

- save the genereated SQLAlchemy relation in the "property" variable for

many-to-many relationships (as for the other types of relations).
By the way: I wonder if this is useful.

- made m-to-m table names consistent (independant of

whether the relation or its inverse is setup first)

- m-to-m relations do not match as inverse of each other if the name of their

table is different

Location:

supermodel/trunk/supermodel

Files:

• entity.py (modified) (7 diffs)
• options.py (modified) (1 diff)
• relationships.py (modified) (4 diffs)

supermodel/trunk/supermodel/entity.py

@@ -40 +40 @@
             desc.setup_options()
             
-            # create table & assign mapper
+            # create table & assign (empty) mapper
             desc.setup()
             
@@ -71 +71 @@
 #        setattr(self.module, entity.__name__, entity)
         self.metadata = getattr(self.module, 'metadata', supermodel.metadata)
-        self.initialized = False
         self.autoload = None
         self.auto_primarykey = True
@@ -101 +100 @@
             and assign a mapper. Will be called when an instance of the
             entity is created or a mapper is needed to access one or many
-            instances of the entity.
-        """
-        
-        if not self.primary_keys and self.auto_primarykey:
-            self.create_auto_primary_key()
-        
-        if not self.entity.mapper:
-            self.setup_mapper()
-        
+            instances of the entity. This *doesn't* initialize relations.
+        """
+        
+        self.setup_mapper()
+       
+        # This marks all relations of the entity (or, at least those which 
+        # have been added so far by statements) as being uninitialized
         EntityDescriptor.uninitialized_rels.update(
             self.relationships.values())
@@ -115 +112 @@
     def setup_mapper(self):
         """
-            Initializes and assign a mapper to the given entity,
+            Initializes and assign an (empty!) mapper to the given entity,
             which needs a table defined, so it calls setup_table.
         """
@@ -152 +149 @@
             return
         
+        if not self.autoload:
+            if not self.primary_keys and self.auto_primarykey:
+                self.create_auto_primary_key()
+
         # create list of columns and constraints
         args = [field.column for field in self.fields.values()] \
@@ -198 +199 @@
             table.append_constraint(constraint)
         
-    def get_inverse_relation(self, rel):
+    def get_inverse_relation(self, rel, reverse=False):
         """Return the inverse relation of rel, if any, None otherwise."""
 
@@ -214 +215 @@
                             % (rel.name, rel.entity.__name__) 
                           )
+        # When a matching inverse is found, we check that it has only
+        # one relation matching as its own inverse. We don't need the result
+        # of the method though. But we do need to be careful not to start an
+        # infinite recursive loop.
+        if matching_rel and not reverse:
+            rel.entity._descriptor.get_inverse_relation(matching_rel, True)
+            
         return matching_rel
+
 
     @classmethod

supermodel/trunk/supermodel/options.py

@@ -25 +25 @@
             tablename:          Specify a custom tablename
             shortnames:         Usually tablenames include the full
-                                module-path to the entity, but separated
-                                by underscores ("_"), eg.:
-                                "project1_model_MyEntity", for an entity named
+                                module-path to the entity, but lower-cased and
+                                separated by underscores ("_"), eg.:
+                                "project1_model_myentity", for an entity named
                                 "MyEntity" in the module "project1.model".
-                                If shortnames is true, the tablename will just
-                                be the entity's classname, ie. "MyEntity".
+                                If shortnames is True, the tablename will just
+                                be the entity's classname lower-cased, 
+                                ie. "myentity".
             auto_primarykey:    If given as string, it will represent the
                                 auto-primary-key's column name

supermodel/trunk/supermodel/relationships.py

@@ -21 +21 @@
         self._target = None
         
-        self.initialized = False
-        self.secondary = None
         self._inverse = None
-        self.foreign_key = None
-        
         self.foreign_key = kwargs.pop('foreign_key', None)
         if self.foreign_key and not isinstance(self.foreign_key, list):
             self.foreign_key = [self.foreign_key]
         
+        #CHECKME: is it of any use to store it somewhere?
         self.property = None # sqlalchemy property
         
@@ -236 +233 @@
 
 class HasAndBelongsToMany(Relationship):
-    
     def __init__(self, entity, name, *args, **kwargs):
-        self.tablename = kwargs.pop('tablename', None)
+        self.user_tablename = kwargs.pop('tablename', None)
+        self.secondary = None
         super(HasAndBelongsToMany, self).__init__(entity, name, *args, **kwargs)
     
@@ -294 +291 @@
                                          name=desc.tablename + '_fk', 
                                          use_alter=True))
-        
-            # In the table name code below, we use the name of the relation
-            # for the first entity (instead of the name of its primary key), 
-            # so that we can have two many-to-many relations between the same
-            # objects without having a table name collision. On the other hand,
-            # we use the name of the primary key for the second entity 
-            # (instead of the inverse relation's name) so that a many-to-many
-            # relation can be defined without inverse.
-            if not self.tablename:
-                e2_pk_name = '_'.join([key.column.name for key in
-                                       e2_desc.primary_keys])
-                tablename = "%s_%s__%s_%s" % (e1_desc.tablename, self.name,
-                                              e2_desc.tablename, e2_pk_name)
+
+            if self.user_tablename:
+                tablename = self.user_tablename
             else:
-                tablename = self.tablename
+                # We use the name of the relation for the first entity 
+                # (instead of the name of its primary key), so that we can 
+                # have two many-to-many relations between the same objects 
+                # without having a table name collision. 
+                source_part = "%s_%s" % (e1_desc.tablename, self.name)
+
+                # And we use the name of the primary key for the second entity
+                # when there is no inverse, so that a many-to-many relation 
+                # can be defined without an inverse.
+                if self.inverse:
+                    e2_name = self.inverse.name
+                else:
+                    e2_name = '_'.join([key.column.name for key in
+                                        e2_desc.primary_keys])
+                target_part = "%s_%s" % (e2_desc.tablename, e2_name)
+
+                # we need to keep the table name consistent (independant of 
+                # whether this relation or its inverse is setup first)
+                if self.inverse and e1_desc.tablename < e2_desc.tablename:
+                    tablename = "%s__%s" % (target_part, source_part)
+                else:
+                    tablename = "%s__%s" % (source_part, target_part)
 
             args = columns + constraints
@@ -320 +328 @@
             kwargs['secondaryjoin'] = and_(*self.secondaryjoin_clauses)
 
-        m = self.entity.mapper
-        #FIXME: using post_update systematically is *really* not good
-        m.add_property(self.name,
-                       relation(self.target, secondary=self.secondary,
-                                uselist=True, **kwargs))
-
+        self.property = relation(self.target, secondary=self.secondary,
+                                 uselist=True, **kwargs)
+        self.entity.mapper.add_property(self.name, self.property)
+
+    def is_inverse(self, other):
+        return super(HasAndBelongsToMany, self).is_inverse(other) and \
+               (self.user_tablename == other.user_tablename or 
+                (not self.user_tablename and not other.user_tablename))
 
 belongs_to = Statement(BelongsTo)