Changeset 129

Timestamp:

06/15/07 10:27:31 (6 years ago)

Author:

ged

Message:

- initial commit of my autodelay functionality + test
- changed how entities find their target: if the class is not found in the

target module, it tries in the list of entities defined for that call frame.
In most case, it will be the module, but it also works for classes defined
inside a method.

Location:

elixir/branches/autodelay

Files:

• elixir/__init__.py (modified) (3 diffs)
• elixir/entity.py (modified) (10 diffs)
• elixir/relationships.py (modified) (19 diffs)
• tests/test_autodelay.py (added)

elixir/branches/autodelay/elixir/__init__.py

@@ -40 +40 @@
            'using_options', 'using_table_options', 'using_mapper_options',
            'options_defaults', 'metadata', 'objectstore',
-           'create_all', 'drop_all', 'setup_all', 'cleanup_all',
-           'delay_setup'] + \
+           'create_all', 'drop_all', 'setup_all', 'cleanup_all'] + \
           sqlalchemy.types.__all__
 
 __pudge_all__ = ['create_all', 'drop_all', 'setup_all', 'cleanup_all',
-                 'metadata', 'objectstore', 'delay_setup']
+                 'metadata', 'objectstore']
 
 # connect
@@ -80 +79 @@
         md.drop_all()
 
-delayed_entities = set()
-delay_setup = False
-
+_delayed_descriptors = list()
 
 def setup_all():
     '''Setup the table and mapper for all entities which have been delayed.
 
-    This should be used in conjunction with setting ``delay_setup`` to ``True``
-    before defining your entities.
+    This is called automatically when your entity is first accessed, or ...
+    [TODO: complete this]
     '''
-    for entity in delayed_entities:
-        entity.setup_table()
-    for entity in delayed_entities:
-        entity.setup_mapper()
+    if not _delayed_descriptors:
+        return
+
+#TODO: define all those operations as methods on the descriptor
+#    for method_name in ('setup_table', 'setup_mapper', 'setup_relkeys', ...):
+#        for desc in _delayed_descriptors:
+#            method = getattr(desc, method_name)
+#            method()
+
+    for desc in _delayed_descriptors:
+        #TODO: I need to restore the original table_iterator on the metadata
+        entity = desc.entity
+        entity._ready = False
+        del sqlalchemy.orm.mapper_registry[entity._class_key]
+        del desc.metadata.tables[entity._table_key]
+
+    for desc in _delayed_descriptors:
+        desc.setup_table()
 
     # setup all relationships
-    for entity in delayed_entities:
-        for rel in entity.relationships.itervalues():
-            rel.setup()
+    for desc in _delayed_descriptors:
+        for rel in desc.relationships.itervalues():
+            rel.create_keys()
 
-    delayed_entities.clear()
+    for desc in _delayed_descriptors:
+        for rel in desc.relationships.itervalues():
+            rel.create_tables()
+
+    for desc in _delayed_descriptors:
+        desc.setup_mapper()
+
+    for desc in _delayed_descriptors:
+        for rel in desc.relationships.itervalues():
+            rel.create_properties()
+
+    del _delayed_descriptors[:]
 
     # issue the "CREATE" SQL statements
-    create_all()
+#    create_all()
 
 
@@ -113 +135 @@
         md.clear()
     metadatas.clear()
-    EntityDescriptor.uninitialized_rels.clear()
 
     objectstore.clear()

elixir/branches/autodelay/elixir/entity.py

@@ -6 +6 @@
 from sqlalchemy.ext.assignmapper    import assign_mapper
 from sqlalchemy.util                import OrderedDict
+import sqlalchemy
 from elixir.statements              import Statement
 from elixir.fields                  import Field
@@ -55 +56 @@
         self.constraints = list()
 
-        #CHECKME: this is a workaround for the "current" descriptor/target
-        # property ugliness. The problem is that this workaround is ugly too.
-        # I'm not sure if this is a safe practice. It works but...?
-#        setattr(self.module, entity.__name__, entity)
-
         # set default value for options
         self.order_by = None
@@ -93 +89 @@
             self.tablename = self.tablename(entity)
     
-    def setup(self):
-        '''
-        Create tables, keys, columns that have been specified so far 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. It will try to initialize the entity's relationships (along 
-        with any delayed relationship) but some of them might be delayed.
-        '''
-        if elixir.delay_setup:
-            elixir.delayed_entities.add(self)
-            return
-
-        self.setup_table()
-        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())
-
-        # try to setup all uninitialized relationships
-        EntityDescriptor.setup_relationships()
-    
     def translate_order_by(self, order_by):
         if isinstance(order_by, basestring):
@@ -161 +134 @@
                 properties[field.column.name] = deferred(field.column,
                                                          group=group)
-
         assign_mapper(session.context, self.entity, self.entity.table,
                       properties=properties, **kwargs)
@@ -191 +163 @@
 #            elif self.inheritance == 'concrete':
                 # do not reuse parent table, but copy all fields
-                # the problem is that, at this points, all "plain" fields
+                # the problem is that, at this point, all "plain" fields
                 # are known, but not those generated by relations
 #                for field in self.fields.itervalues():
@@ -217 +189 @@
         self.entity.table = Table(self.tablename, self.metadata, 
                                   *args, **kwargs)
-    
+
     def create_auto_primary_key(self):
         '''
@@ -285 +257 @@
     all_relationships = property(all_relationships)
 
-    def setup_relationships(cls):
-        for relationship in list(EntityDescriptor.uninitialized_rels):
-            if relationship.setup():
-                EntityDescriptor.uninitialized_rels.remove(relationship)
-    setup_relationships = classmethod(setup_relationships)
+
+class TriggerProxy(object):
+    def __init__(self, class_, attrname, setupfunc):
+        self.class_ = class_
+        self.attrname = attrname
+        self.setupfunc = setupfunc
+
+    def __getattr__(self, name):
+        self.setupfunc()
+        proxied_attr = getattr(self.class_, self.attrname)
+        return getattr(proxied_attr, name)
+
+    def __repr__(self):
+        proxied_attr = getattr(self.class_, self.attrname)
+        return "PROXY(%s)" % (self.class_.__name__)
 
 class EntityMeta(type):
@@ -297 +279 @@
     entities (ie you don't want to use the provided 'Entity' class).
     """
+    _ready = False
+    _entities = {}
 
     def __init__(cls, name, bases, dict_):
@@ -303 +287 @@
             return
 
+        cid = cls._caller = id(sys._getframe(1))
+        caller_entities = EntityMeta._entities.setdefault(cid, {})
+        caller_entities[name] = cls
+
         # create the entity descriptor
         desc = cls._descriptor = EntityDescriptor(cls)
-        EntityDescriptor.current = desc
-        
-        # process statements
+
+        # process statements. Needed before the proxy for metadata
         Statement.process(cls)
-        
+
         # setup misc options here (like tablename etc.)
         desc.setup_options()
-        
-        # create table & assign (empty) mapper
-        desc.setup()
-
-    def q(cls):
-        return cls.query()
-    q = property(q)
+
+        # create trigger proxies
+        # TODO: support entity_name... or maybe not. I'm not sure it makes 
+        # sense in Elixir.
+        cls.setup_proxy()
+
+    def setup_proxy(cls, entity_name=None):
+        #TODO: move as much as possible of those "_private" values to the
+        # descriptor, so that we don't mess the initial class.
+        cls._class_key = sqlalchemy.orm.ClassKey(cls, entity_name)
+
+        tablename = cls._descriptor.tablename
+        schema = cls._descriptor.table_options.get('schema', None)
+        cls._table_key = sqlalchemy.schema._get_table_key(tablename, schema)
+
+        elixir._delayed_descriptors.append(cls._descriptor)
+        
+        mapper_proxy = TriggerProxy(cls, 'mapper', elixir.setup_all)
+        table_proxy = TriggerProxy(cls, 'table', elixir.setup_all)
+
+        sqlalchemy.orm.mapper_registry[cls._class_key] = mapper_proxy
+        md = cls._descriptor.metadata
+        md.tables[cls._table_key] = table_proxy
+
+        # We need to monkeypatch the metadata's table iterator method because 
+        # otherwise it doesn't work if the setup is triggered by the 
+        # metadata.create_all().
+        # This is because ManyToMany relationships add tables AFTER the list 
+        # of tables that are going to be created is "computed" 
+        # (metadata.tables.values()).
+        # see:
+        # - table_iterator method in MetaData class in sqlalchemy/schema.py 
+        # - visit_metadata method in sqlalchemy/ansisql.py
+        original_table_iterator = md.table_iterator
+        if not hasattr(original_table_iterator, 
+                       '_elixir_setup_trigger'):
+            def table_iterator(reverse=True, tables=None):
+                elixir.setup_all()
+                return original_table_iterator(reverse, tables)
+            table_iterator._elixir_setup_trigger = True
+            table_iterator.__doc__ = original_table_iterator.__doc__
+            md.table_iterator = table_iterator
+
+        cls._ready = True
+
+    def __getattribute__(cls, name):
+        if type.__getattribute__(cls, "_ready"):
+            elixir.setup_all()
+        return type.__getattribute__(cls, name)
+
+    def __call__(cls, *args, **kwargs):
+        elixir.setup_all()
+        return type.__call__(cls, *args, **kwargs)
+        
+
 
 class Entity(object):
@@ -346 +381 @@
 
     def __init__(self, **kwargs):
-         for key, value in kwargs.items():
-             setattr(self, key, value)
-
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+

elixir/branches/autodelay/elixir/relationships.py

@@ -194 +194 @@
 from elixir.statements  import Statement
 from elixir.fields      import Field
-from elixir.entity      import EntityDescriptor
+from elixir.entity      import EntityDescriptor, EntityMeta
 
 import sys
@@ -219 +219 @@
         self.args = args
         self.kwargs = kwargs
-        
+#TODO: rename relationships to properties? or use add_property?
+# answer: NO. 
         self.entity._descriptor.relationships[self.name] = self
     
@@ -236 +237 @@
     def create_properties(self):
         '''
-        Subclasses (ie. concrete relationships) may override this method to add 
-        properties to the involved entities.
+        Subclasses (ie. concrete relationships) may override this method to
+        add properties to the involved entities.
         '''
     
@@ -244 +245 @@
         Sets up the relationship, creates foreign keys and secondary tables.
         '''
+        print "Rel::setup", self.name
+
+        if self.property:
+            print " -> already done"
+            return False
 
         if not self.target:
+            print " -> not ready"
             return False
 
-        if self.property:
-            return True
+        #CHIOTTE, ca trigger le truc
+#        if not self.target._done:
+#            print " -> not ready (!!)"
+#            return False
 
         self.create_keys()
@@ -261 +270 @@
             path = self.of_kind.rsplit('.', 1)
             classname = path.pop()
+            module = None
 
             if path:
                 # do we have a fully qualified entity name?
                 module = sys.modules[path.pop()]
-            else: 
-                # if not, try the same module as the source
-                module = self.entity._descriptor.module
-
-            self._target = getattr(module, classname, None)
-            if not self._target:
-                # This is ugly but we need it because the class which is
-                # currently being defined (we have to keep in mind we are in 
-                # its metaclass code) is not yet available in the module
-                # namespace, so the getattr above fails. And unfortunately,
-                # this doesn't only happen for the owning entity of this
-                # relation since we might be setting up a deferred relation.
-                e = EntityDescriptor.current.entity
-                if classname == e.__name__ or \
-                        self.of_kind == e.__module__ +'.'+ e.__name__:
-                    self._target = e
-                else:
-                    return None
-        
+                self._target = getattr(module, classname, None)
+            else:
+                # If not, try the list of entities of the "caller" of the 
+                # source class. Most of the time, this will be the module the
+                # class is defined in. But it could also be a method (inner
+                # classes).
+                caller_entities = EntityMeta._entities[self.entity._caller]
+                self._target = caller_entities[classname]
         return self._target
     target = property(target)
@@ -310 +309 @@
     inverse = property(inverse)
     
+    #TODO: move this to each rel type
     def match_type_of(self, other):
         t1, t2 = type(self), type(other)
@@ -361 +361 @@
         source accordingly.
         '''
+        print "BT::create_keys", self.name, self.entity.__name__
+        if self.foreign_key:
+            print " -> already done"
+            return
 
         source_desc = self.entity._descriptor
+        #TODO: make this work if target is a pure SA-mapped class
+        # for that, I need: 
+        # - the list of primary key columns of the target table
+        # - the name of the target table
         target_desc = self.target._descriptor
 
@@ -369 +377 @@
             if self.colname:
                 self.primaryjoin_clauses = \
-                    _build_join_clauses(self.entity.table, 
-                                        self.colname, None, 
-                                        self.target.table)[0]
+                    _get_join_clauses(self.entity.table, 
+                                      self.colname, None, 
+                                      self.target.table)[0]
                 if not self.primaryjoin_clauses:
                     raise Exception(
@@ -413 +421 @@
 
                 # build the list of columns the foreign key will point to
-                if target_desc.entity.table.schema:
-                    fk_refcols.append("%s.%s.%s" % (
-                        target_desc.entity.table.schema,
-                        target_desc.entity.table.name,
-                        pk_col.name))
-                else:
-                    fk_refcols.append("%s.%s" % (target_desc.entity.table.name,
-                                                 pk_col.name))
+                fk_refcols.append("%s.%s" % (target_desc.entity.table.name,
+                                             pk_col.name))
 
                 # build up the primary join. This is needed when you have 
@@ -436 +438 @@
     
     def create_properties(self):
+        if self.property:
+            print " -> already done"
+            return
+
+        print "BT::create_properties", self.name, self.entity.__name__
         kwargs = self.kwargs
         
@@ -457 +464 @@
 
     def create_keys(self):
+        print "HO::create_keys", self.name, self.entity.__name__
+
         # make sure an inverse relationship exists
         if self.inverse is None:
@@ -469 +478 @@
                          self.entity.__name__))
         # make sure it is set up because it creates the foreign key we'll need
-        self.inverse.setup()
+        self.inverse.create_keys()
     
     def create_properties(self):
+        print "HO::create_properties", self.name, self.entity.__name__
+        if self.property:
+            print " -> already done"
+            return
+
         kwargs = self.kwargs
         
@@ -497 +511 @@
 
     def create_properties(self):
+        print "HM::create_properties", self.name, self.entity.__name__
+        if self.property:
+            print " -> already done"
+            return
+
         if 'order_by' in self.kwargs:
             self.kwargs['order_by'] = \
@@ -522 +541 @@
 
     def create_tables(self):
+        print "HABTM::create_table", self.name
+        if self.secondary_table:
+            print " -> already done"
+            return
+
         if self.inverse:
             if self.inverse.secondary_table:
@@ -527 +551 @@
                 self.primaryjoin_clauses = self.inverse.secondaryjoin_clauses
                 self.secondaryjoin_clauses = self.inverse.primaryjoin_clauses
-
-        if not self.secondary_table:
-            e1_desc = self.entity._descriptor
-            e2_desc = self.target._descriptor
-           
-            # First, we compute the name of the table. Note that some of the 
-            # intermediary variables are reused later for the constraint 
-            # names.
+                return
+
+        e1_desc = self.entity._descriptor
+        e2_desc = self.target._descriptor
+       
+        # First, we compute the name of the table. Note that some of the 
+        # intermediary variables are reused later for the constraint 
+        # names.
+        
+        # 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 only the name of the table of the second entity
+        # when there is no inverse, so that a many-to-many relation 
+        # can be defined without an inverse.
+        if self.inverse:
+            target_part = "%s_%s" % (e2_desc.tablename, self.inverse.name)
+        else:
+            target_part = e2_desc.tablename
+        
+        if self.user_tablename:
+            tablename = self.user_tablename
+        else:
+            # 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)
+
+        if e1_desc.autoload:
+            self._reflect_table(tablename)
+        else:
+            # We pre-compute the names of the foreign key constraints 
+            # pointing to the source (local) entity's table and to the 
+            # target's table
+
+            # In some databases (at lease MySQL) the constraint names need 
+            # to be unique for the whole database, instead of per table.
+            source_fk_name = "%s_fk" % source_part
+            if self.inverse:
+                target_fk_name = "%s_fk" % target_part
+            else:
+                target_fk_name = "%s_inverse_fk" % source_part
+
+            columns = list()
+            constraints = list()
+
+            joins = (self.primaryjoin_clauses, self.secondaryjoin_clauses)
+            for num, desc, fk_name in ((0, e1_desc, source_fk_name), 
+                                       (1, e2_desc, target_fk_name)):
+                fk_colnames = list()
+                fk_refcols = list()
             
-            # 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 only the name of the table of the second entity
-            # when there is no inverse, so that a many-to-many relation 
-            # can be defined without an inverse.
-            if self.inverse:
-                target_part = "%s_%s" % (e2_desc.tablename, self.inverse.name)
-            else:
-                target_part = e2_desc.tablename
+                for key in desc.primary_keys:
+                    pk_col = key.column
+                    
+                    colname = '%s_%s' % (desc.tablename, pk_col.name)
+
+                    # In case we have a many-to-many self-reference, we 
+                    # need to tweak the names of the columns so that we 
+                    # don't end up with twice the same column name.
+                    if self.entity is self.target:
+                        colname += str(num + 1)
+
+                    col = Column(colname, pk_col.type)
+                    columns.append(col)
+
+                    # Build the list of local columns which will be part 
+                    # of the foreign key.
+                    fk_colnames.append(colname)
+
+                    # Build the list of columns the foreign key will point
+                    # to.
+                    fk_refcols.append(desc.tablename + '.' + pk_col.name)
+
+                    # Build join clauses (in case we have a self-ref)
+                    if self.entity is self.target:
+                        joins[num].append(col == pk_col)
+                
+                constraints.append(
+                    ForeignKeyConstraint(fk_colnames, fk_refcols,
+                                         name=fk_name))
+
+            args = columns + constraints
             
-            if self.user_tablename:
-                tablename = self.user_tablename
-            else:
-                # 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)
-
-            if e1_desc.autoload:
-                self._reflect_table(tablename)
-            else:
-                # We pre-compute the names of the foreign key constraints 
-                # pointing to the source (local) entity's table and to the 
-                # target's table
-
-                # In some databases (at lease MySQL) the constraint names need 
-                # to be unique for the whole database, instead of per table.
-                source_fk_name = "%s_fk" % source_part
-                if self.inverse:
-                    target_fk_name = "%s_fk" % target_part
-                else:
-                    target_fk_name = "%s_inverse_fk" % source_part
-
-                columns = list()
-                constraints = list()
-
-                joins = (self.primaryjoin_clauses, self.secondaryjoin_clauses)
-                for num, desc, fk_name in ((0, e1_desc, source_fk_name), 
-                                           (1, e2_desc, target_fk_name)):
-                    fk_colnames = list()
-                    fk_refcols = list()
-                
-                    for key in desc.primary_keys:
-                        pk_col = key.column
-                        
-                        colname = '%s_%s' % (desc.tablename, pk_col.name)
-
-                        # In case we have a many-to-many self-reference, we 
-                        # need to tweak the names of the columns so that we 
-                        # don't end up with twice the same column name.
-                        if self.entity is self.target:
-                            colname += str(num + 1)
-
-                        col = Column(colname, pk_col.type)
-                        columns.append(col)
-
-                        # Build the list of local columns which will be part 
-                        # of the foreign key.
-                        fk_colnames.append(colname)
-
-                        # Build the list of columns the foreign key will point
-                        # to.
-                        fk_refcols.append(desc.tablename + '.' + pk_col.name)
-
-                        # Build join clauses (in case we have a self-ref)
-                        if self.entity is self.target:
-                            joins[num].append(col == pk_col)
-                    
-                    constraints.append(
-                        ForeignKeyConstraint(fk_colnames, fk_refcols,
-                                             name=fk_name))
-
-                args = columns + constraints
-                
-                self.secondary_table = Table(tablename, e1_desc.metadata, 
-                                             *args)
+            self.secondary_table = Table(tablename, e1_desc.metadata, 
+                                         *args)
+            print " -> created", tablename, e1_desc.metadata
 
     def _reflect_table(self, tablename):
@@ -646 +671 @@
 
             self.primaryjoin_clauses, self.secondaryjoin_clauses = \
-                _build_join_clauses(self.secondary_table, 
-                                    self.local_side, self.remote_side, 
-                                    self.entity.table)
+                _get_join_clauses(self.secondary_table, 
+                                  self.local_side, self.remote_side, 
+                                  self.entity.table)
 
     def create_properties(self):
+        print "HABTM::create_properties", self.name, self.entity.__name__
+        if self.property:
+            print " -> already done"
+            return
         kwargs = self.kwargs
 
@@ -671 +700 @@
 
 
-def _build_join_clauses(local_table, local_cols1, local_cols2, target_table):
+def _get_join_clauses(local_table, local_cols1, local_cols2, target_table):
     primary_join, secondary_join = [], []
     cols1 = local_cols1[:]
@@ -685 +714 @@
     constraint_map = {}
     for constraint in local_table.constraints:
+        print "constraint", constraint
         if isinstance(constraint, ForeignKeyConstraint):
             use_constraint = False
@@ -719 +749 @@
 has_many = Statement(HasMany)
 has_and_belongs_to_many = Statement(HasAndBelongsToMany)
+