Changeset 175

Timestamp:

08/06/07 14:16:45 (6 years ago)

Author:

ged

Message:

merged autodelay branch!

Location:

elixir/trunk

Files:

• elixir/__init__.py (modified) (3 diffs)
• elixir/entity.py (modified) (21 diffs)
• elixir/ext/versioned.py (modified) (1 diff)
• elixir/fields.py (modified) (1 diff)
• elixir/options.py (modified) (5 diffs)
• elixir/relationships.py (modified) (12 diffs)
• elixir/statements.py (modified) (2 diffs)
• tests/test_autoload.py (modified) (5 diffs)
• tests/test_autoload_mixed.py (modified) (3 diffs)
• tests/test_autoload_nopk.py (modified) (1 diff)
• tests/test_has_property.py (modified) (1 diff)
• tests/test_inherit.py (modified) (1 diff)
• tests/test_options.py (modified) (3 diffs)

elixir/trunk/elixir/__init__.py

@@ -29 +29 @@
                                  has_and_belongs_to_many
 from elixir.properties import has_property
+from elixir.statements import Statement
 
 try:
@@ -42 +43 @@
            '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
-metadata = sqlalchemy.DynamicMetaData(threadlocal=False)
+metadata = sqlalchemy.MetaData()
 
 try:
@@ -83 +83 @@
         md.drop_all()
 
-delayed_entities = set()
-delay_setup = False
+_delayed_descriptors = list()
+
+def setup_all(create_tables=False):
+    '''Setup the table and mapper for all entities which have been delayed.
+
+    This is called automatically when your entity is first accessed, or ...
+    [TODO: complete this]
+    '''
+
+    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()
+    try:
+        for desc in _delayed_descriptors:
+            entity = desc.entity
+            entity._ready = False
+            del sqlalchemy.orm.mapper_registry[entity._class_key]
+
+            md = desc.metadata
+            # the table could have already been removed (namely in a single 
+            # table inheritance scenario)
+            md.tables.pop(entity._table_key, None)
+
+            # restore original table iterator if not done already
+            if hasattr(md.table_iterator, '_non_elixir_patched_iterator'):
+                md.table_iterator = \
+                    md.table_iterator._non_elixir_patched_iterator
+
+        # Make sure autoloaded tables are available so that we can setup 
+        # foreign keys to their columns
+        for desc in _delayed_descriptors:
+            if desc.autoload:
+                desc.setup_table()
+
+        for desc in _delayed_descriptors:
+            desc.create_pk_cols()
+
+        # Create other columns from belongs_to relationships.
+        for desc in _delayed_descriptors:
+            for rel in desc.relationships.itervalues():
+                rel.create_keys(False)
+
+        for desc in _delayed_descriptors:
+            if not desc.autoload:
+                desc.setup_table()
+
+        for desc in _delayed_descriptors:
+            for rel in desc.relationships.itervalues():
+                rel.create_tables()
+
+        for desc in _delayed_descriptors:
+            desc.setup_events()
+        
+        for desc in _delayed_descriptors:
+            desc.setup_mapper()
+
+        for desc in _delayed_descriptors:
+            for rel in desc.relationships.itervalues():
+                rel.create_properties()
+
+        #TODO: merge this with the "when" feature of statements
+        for desc in _delayed_descriptors:
+            # allow the statements to do any "finalization"
+            Statement.finalize(desc.entity)
+
+    finally:
+        # make sure that even if we fail to initialize, we don't leave junk for
+        # others
+        del _delayed_descriptors[:]
+
+    # issue the "CREATE" SQL statements
+    if create_tables:
+        create_all()
 
 
-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.
-    '''
-    for entity in delayed_entities:
-        entity.setup_table()
-    for entity in delayed_entities:
-        entity.setup_mapper()
-
-    # setup all relationships
-    for entity in delayed_entities:
-        for rel in entity.relationships.itervalues():
-            rel.setup()
-
-    delayed_entities.clear()
-
-    # issue the "CREATE" SQL statements
-    create_all()
-
-
-def cleanup_all():
+def cleanup_all(drop_tables=False):
     '''Drop table and clear mapper for all entities, and clear all metadatas.
     '''
-    drop_all()
+    if drop_tables:
+        drop_all()
+        
     for md in metadatas:
         md.clear()
     metadatas.clear()
-    EntityDescriptor.uninitialized_rels.clear()
 
     objectstore.clear()
-    sqlalchemy.clear_mappers()
+    sqlalchemy.orm.clear_mappers()
 

elixir/trunk/elixir/entity.py

@@ -3 +3 @@
 '''
 
-from sqlalchemy                     import Table, Integer, desc
+from sqlalchemy                     import Table, Integer, String, desc,\
+                                           ForeignKey
 from sqlalchemy.orm                 import deferred, Query, MapperExtension
 from sqlalchemy.ext.assignmapper    import assign_mapper
 from sqlalchemy.util                import OrderedDict
+import sqlalchemy
 from elixir.statements              import Statement
 from elixir.fields                  import Field
@@ -17 +19 @@
 
 import sys
+import warnings
+
 import elixir
 import inspect
@@ -25 +29 @@
 DEFAULT_AUTO_PRIMARYKEY_TYPE = Integer
 DEFAULT_VERSION_ID_COL = "row_version"
+DEFAULT_POLYMORPHIC_COL_NAME = "row_type"
+DEFAULT_POLYMORPHIC_COL_SIZE = 20
+DEFAULT_POLYMORPHIC_COL_TYPE = String(DEFAULT_POLYMORPHIC_COL_SIZE)
 
 class EntityDescriptor(object):
@@ -44 +51 @@
 
         self.parent = None
+        self.children = []
+
         for base in entity.__bases__:
             if issubclass(base, Entity) and base is not Entity:
@@ -52 +61 @@
                 else:
                     self.parent = base
+                    self.parent._descriptor.children.append(entity)
 
         self.fields = OrderedDict()
+        #TODO Ordered
         self.relationships = dict()
         self.delayed_properties = dict()
         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
@@ -68 +74 @@
         self.metadata = getattr(self.module, 'metadata', elixir.metadata)
 
-        for option in ('inheritance', 
+        for option in ('inheritance', 'polymorphic',
                        'autoload', 'tablename', 'shortnames', 
                        'auto_primarykey',
@@ -85 +91 @@
 
         entity = self.entity
+        if self.inheritance == 'concrete' and self.polymorphic:
+            raise NotImplementedError("Polymorphic concrete inheritance is "
+                                      "not yet implemented.")
+
+        if self.parent:
+            if self.inheritance == 'single':
+                self.tablename = self.parent._descriptor.tablename
 
         if not self.tablename:
@@ -96 +109 @@
             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_events()
-        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()
-        
-        # finally, allow the statement to do any "finalization"
-        Statement.finalize(self.entity)
-    
     def setup_events(self):
         # create a list of callbacks for each event
@@ -179 +165 @@
             kwargs['version_id_col'] = self.fields[self.version_id_col].column
 
-        if self.parent:
-            if self.inheritance == 'single':
-                # at this point, we don't know whether the parent relationships
-                # have already been processed or not. Some of them might be, 
-                # some other might not.
-                if not self.parent.mapper:
-                    self.parent._descriptor.setup_mapper()
+        if self.inheritance in ('single', 'concrete', 'multi'):
+            if self.parent and \
+               not (self.inheritance == 'concrete' and not self.polymorphic):
                 kwargs['inherits'] = self.parent.mapper
+
+            if self.polymorphic:
+                if self.children and not self.parent:
+                    kwargs['polymorphic_on'] = \
+                        self.fields[self.polymorphic].column
+                    if self.inheritance == 'multi':
+                        children = self._get_children()
+                        join = self.entity.table
+                        for child in children:
+                            join = join.outerjoin(child.table)
+                        kwargs['select_table'] = join
+                    
+                if self.children or self.parent:
+                    #TODO: make this customizable (both callable and string)
+                    #TODO: include module name
+                    kwargs['polymorphic_identity'] = \
+                        self.entity.__name__.lower()
+
+                if self.inheritance == 'concrete':
+                    kwargs['concrete'] = True
 
         properties = dict()
@@ -197 +199 @@
                                                          group=group)
 
-        #TODO: make this happen after the rel columns have been added.
         for name, prop in self.delayed_properties.iteritems():
             properties[name] = self.evaluate_property(prop)
@@ -207 +208 @@
                 colname in kwargs['primary_key']]
 
-        assign_mapper(session.context, self.entity, self.entity.table,
-                      properties=properties, **kwargs)
+        if self.parent and self.inheritance == 'single':
+            args = []
+        else:
+            args = [self.entity.table]
+
+        assign_mapper(session.context, self.entity, properties=properties, 
+                      *args, **kwargs)
+
+    def _get_children(self):
+        children = self.children[:]
+        for child in self.children:
+            children.extend(child._descriptor._get_children())
+        return children
 
     def evaluate_property(self, prop):
@@ -240 +252 @@
         if self.parent:
             if self.inheritance == 'single':
-                # reuse the parent's table
-                if not self.parent.table:
-                    self.parent._descriptor.setup_table()
-                    
+                # we know the parent is setup before the child
                 self.entity.table = self.parent.table 
 
@@ -253 +262 @@
 
                 return
-#            elif self.inheritance == 'concrete':
-                # do not reuse parent table, but copy all 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():
-#                    self.add_field(field)
+            elif self.inheritance == 'concrete':
+               # copy all fields from parent table
+               for field in self.parent._descriptor.fields.itervalues():
+                    self.add_field(field.copy())
+
+        if self.polymorphic and self.inheritance in ('single', 'multi') and \
+           self.children and not self.parent:
+            if not isinstance(self.polymorphic, basestring):
+                self.polymorphic = DEFAULT_POLYMORPHIC_COL_NAME
+                
+            self.add_field(Field(DEFAULT_POLYMORPHIC_COL_TYPE, 
+                                 colname=self.polymorphic))
 
         if self.version_id_col:
@@ -264 +279 @@
                 self.version_id_col = DEFAULT_VERSION_ID_COL
             self.add_field(Field(Integer, colname=self.version_id_col))
-
-        if not self.autoload:
-            if not self.has_pk and self.auto_primarykey:
-                self.create_auto_primary_key()
 
         # create list of columns and constraints
@@ -283 +294 @@
 
 
+    def create_pk_cols(self):
+        """
+        Create primary_key columns. That is, add columns from belongs_to
+        relationships marked as being a primary_key and then adds a primary 
+        key to the table if it hasn't already got one and needs one. 
+        
+        This method is "semi-recursive" in that it calls the create_keys 
+        method on BelongsTo relationships and those in turn call create_pk_cols
+        on their target. It shouldn't be possible to have an infinite loop 
+        since a loop of primary_keys is not a valid situation.
+        """
+        for rel in self.relationships.itervalues():
+            rel.create_keys(True)
+
+        if not self.autoload:
+            if self.parent and self.inheritance == 'multi':
+                # add foreign keys to the parent's primary key columns 
+                parent_desc = self.parent._descriptor
+                for pk_col in parent_desc.primary_keys:
+                    colname = "%s_%s" % (self.parent.__name__.lower(),
+                                         pk_col.name)
+                    field = Field(pk_col.type, ForeignKey(pk_col), 
+                                  colname=colname, primary_key=True)
+                    self.add_field(field)
+            if not self.has_pk and self.auto_primarykey:
+                self.create_auto_primary_key()
+
+
     def create_auto_primary_key(self):
         '''
         Creates a primary key
         '''
-        
-        assert not self.has_pk and self.auto_primarykey
         
         if isinstance(self.auto_primarykey, basestring):
@@ -304 +341 @@
             self.has_pk = True
 
-        table = self.entity.table
+        # we don't want to trigger setup_all too early
+        table = type.__getattribute__(self.entity, 'table')
         if table:
             table.append_column(field.column)
@@ -342 +380 @@
 
     def primary_keys(self):
-        return [col for col in self.entity.table.primary_key.columns]
+        if self.autoload:
+            return [col for col in self.entity.table.primary_key.columns]
+        else:
+            return [field.column for field in self.fields.itervalues() if
+                    field.primary_key]
     primary_keys = property(primary_keys)
 
@@ -354 +396 @@
     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 "<TriggerProxy (%s)>" % (self.class_.__name__)
 
 class EntityMeta(type):
@@ -366 +418 @@
     entities (ie you don't want to use the provided 'Entity' class).
     """
+    _ready = False
+    _entities = {}
 
     def __init__(cls, name, bases, dict_):
@@ -372 +426 @@
             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
-        Statement.process(cls)
+
+        # process statements. Needed before the proxy for metadata
+        Statement.process(cls, 'init')
 
         # setup misc options here (like tablename etc.)
         desc.setup_options()
 
-        # create table & assign (empty) mapper
-        desc.setup()
+        # 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.mapperlib.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, 
+                       '_non_elixir_patched_iterator'):
+            def table_iterator(*args, **kwargs):
+                elixir.setup_all()
+                return original_table_iterator(*args, **kwargs)
+            table_iterator.__doc__ = original_table_iterator.__doc__
+            table_iterator._non_elixir_patched_iterator = \
+                original_table_iterator
+            md.table_iterator = table_iterator
+
+        cls._ready = True
+
+    def __getattribute__(cls, name):
+        if type.__getattribute__(cls, "_ready"):
+            #TODO: we need to add all assign_mapper methods
+            if name in ('c', 'table', 'mapper'):
+                elixir.setup_all()
+        return type.__getattribute__(cls, name)
+
+    def __call__(cls, *args, **kwargs):
+        elixir.setup_all()
+        return type.__call__(cls, *args, **kwargs)
 
     def q(cls):
@@ -419 +529 @@
             setattr(self, key, value)
 
+    def get_by(cls, *args, **kwargs):
+#        warnings.warn("The get_by method on the class is deprecated."
+#                      "You should use cls.query.get_by", DeprecationWarning,
+#                      stacklevel=2)
+        return cls.q.get_by(*args, **kwargs)
+    get_by = classmethod(get_by)
+
+    def select(cls, *args, **kwargs):
+#        warnings.warn("The select method on the class is deprecated."
+#                      "You should use cls.query.select", DeprecationWarning,
+#                      stacklevel=2)
+        return cls.q.select(*args, **kwargs)
+    select = classmethod(select)
+
+

elixir/trunk/elixir/ext/versioned.py

@@ -43 +43 @@
 from elixir.statements     import Statement
 from elixir.fields         import Field
+from sqlalchemy            import Table, Column, and_, desc
+from sqlalchemy.orm        import mapper
 from sqlalchemy.orm.mapper import MapperExtension, EXT_PASS
-from sqlalchemy            import Table, Column, mapper, and_, desc
 from datetime              import datetime
 

elixir/trunk/elixir/fields.py

@@ -99 +99 @@
         self.args = args
         self.kwargs = kwargs
-    
+
+    def copy(self):
+        '''
+        Returns a copy of the field
+        '''
+
+        kwargs = self.kwargs
+        kwargs.update({'colname': self.colname, 'deferred': self.deferred})
+        if 'nullable' in self.kwargs:
+            kwargs['required'] = not self.kwargs['nullable']
+        return Field(self.type, *self.args, **kwargs)
+            
     def column(self):
         '''

elixir/trunk/elixir/options.py

@@ -34 +34 @@
 | ``inheritance``     | Specify the type of inheritance this entity must use. |
 |                     | It can be one of ``single``, ``concrete`` or          |
-|                     | ``multi``.                                            |
-|                     | **For now, only the single type is implemented.**     |
+|                     | ``multi``. Defaults to ``single``.                    |
 +---------------------+-------------------------------------------------------+
-| ``metadata``        | Specify a custom MetaData                             |
+| ``polymorphic``     | Whether the inheritance should be polymorphic or not. |
+|                     | Defaults to ``False``. Note that polymorphic concrete |
+|                     | inheritance is currently not implemented.             |
++---------------------+-------------------------------------------------------+
+| ``metadata``        | Specify a custom MetaData.                            |
 +---------------------+-------------------------------------------------------+
 | ``autoload``        | Automatically load column definitions from the        |
 |                     | existing database table.                              |
-|                     | Using autoloaded tables implies setting               |
-|                     | ``delay_setup`` to ``True`` before defining your      |
-|                     | entities.                                             |
 +---------------------+-------------------------------------------------------+
 | ``tablename``       | Specify a custom tablename. You can either provide a  |
@@ -55 +55 @@
 |                     | underscores ("_"), eg.: "project1_model_myentity"     |
 |                     | for an entity named "MyEntity" in the module          |
-|                     | "project1.model".  If shortnames is True, the         |
+|                     | "project1.model".  If shortnames is ``True``, the     |
 |                     | tablename will just be the entity's classname         |
 |                     | lower-cased, ie. "myentity".                          |
@@ -116 +116 @@
 options_defaults = dict(
     inheritance='single',
+    polymorphic=False,
     autoload=None,
     shortnames=False,
@@ -128 +129 @@
     valid_options = (
         'inheritance',
-        'metadata',
+        'polymorphic',
         'autoload',
         'tablename',
@@ -134 +135 @@
         'auto_primarykey',
         'version_id_col',
+        'metadata',
         'order_by',
     )

elixir/trunk/elixir/relationships.py

@@ -199 +199 @@
 from elixir.statements  import Statement
 from elixir.fields      import Field
-from elixir.entity      import EntityDescriptor
+from elixir.entity      import EntityDescriptor, EntityMeta
 
 import sys
@@ -228 +228 @@
         self.entity._descriptor.relationships[self.name] = self
     
-    def create_keys(self):
+    def create_keys(self, pk):
         '''
         Subclasses (ie. concrete relationships) may override this method to 
@@ -250 +250 @@
         kwargs = {}
         if self.inverse:
-            # check if the inverse was already processed (and this has already defined
-            # a backref)
+            # check if the inverse was already processed (and thus has already
+            # defined a backref we can use)
             if self.inverse.backref:
                 kwargs['backref'] = self.inverse.backref
@@ -269 +269 @@
         self.entity.mapper.add_property(self.name, self.property)
     
-    def setup(self):
-        '''
-        Sets up the relationship, creates foreign keys and secondary tables.
-        '''
-
-        if not self.target:
-            return False
-
-        if self.property or self.backref:
-            return True
-
-        self.create_keys()
-        self.create_tables()
-        self.create_properties()
-        
-        return True
-    
     def target(self):
         if not self._target:
@@ -293 +276 @@
             if path:
                 # do we have a fully qualified entity name?
-                module = sys.modules.get(path.pop(), None)
-                if module is None:
-                    # the module is probably not yet defined
-                    #TODO: in a delay_setup scenario, we should raise an
-                    #exception
-                    return None
+                module = sys.modules[path.pop()]
+                self._target = getattr(module, classname, None)
             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
-        
+                # 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)
@@ -386 +353 @@
         return isinstance(other, (HasMany, HasOne))
 
-    def create_keys(self):
+    def create_keys(self, pk):
         '''
         Find all primary keys on the target and create foreign keys on the 
@@ -394 +361 @@
             return
 
+        if self.column_kwargs.get('primary_key', False) != pk:
+            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
+        #make sure the target has all its pk setup up
+        target_desc.create_pk_cols()
 
         if source_desc.autoload:
@@ -431 +407 @@
 
                 # we use a Field here instead of using a Column directly 
-                # because of add_field 
+                # because add_field can be used before the table is created
                 field = Field(pk_col.type, colname=colname, index=True, 
                               **self.column_kwargs)
@@ -443 +419 @@
                 fk_colnames.append(colname)
 
-                # 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))
+                # build the list of column "paths" the foreign key will 
+                # point to
+                target_path = "%s.%s" % (target_desc.tablename, pk_col.name)
+                schema = target_desc.table_options.get('schema', None)
+                if schema is not None:
+                    target_path = "%s.%s" % (schema, target_path)
+                fk_refcols.append(target_path)
 
                 # build up the primary join. This is needed when you have 
@@ -459 +433 @@
             # In some databases (at lease MySQL) the constraint name needs to 
             # be unique for the whole database, instead of per table.
-            fk_name = "%s_%s_fk" % (self.entity.table.name, 
+            fk_name = "%s_%s_fk" % (source_desc.tablename, 
                                     '_'.join(fk_colnames))
             source_desc.add_constraint(ForeignKeyConstraint(
@@ -487 +461 @@
         return isinstance(other, BelongsTo)
 
-    def create_keys(self):
+    def create_keys(self, pk):
         # make sure an inverse relationship exists
         if self.inverse is None:
@@ -500 +474 @@
                          self.entity.__name__))
         # make sure it is set up because it creates the foreign key we'll need
-        self.inverse.create_keys()
+        self.inverse.create_keys(pk)
     
     def get_prop_kwargs(self):

elixir/trunk/elixir/statements.py

@@ -12 +12 @@
     '''
     
-    def __init__(self, target):
+    def __init__(self, target, when='init'):
         '''
         target is the class which will handle this statement. For example, the
@@ -18 +18 @@
         '''
         self.target = target
+        self.when = when
     
     def __call__(self, *args, **kwargs):
-        # jam this statement into the class's statement list
+        # jam this statement into one of the class's statement lists
         class_locals = sys._getframe(1).f_locals
-        statements = class_locals.setdefault(STATEMENTS, [])
+        statement_map = class_locals.setdefault(STATEMENTS, {})
+        statements = statement_map.setdefault(self.when, [])
         statements.append((self, args, kwargs))
     
     @classmethod
-    def finalize(cls, entity):
-        for statement, args, kwargs in getattr(entity, STATEMENTS, []):
+    def finalize(cls, entity, when='init'):
+        statement_map = getattr(entity, STATEMENTS, {})
+        statements = statement_map.get(when, [])
+        for statement, args, kwargs in statements:
             getattr(statement.target, 'finalize', lambda x: None)(entity)
     
     @classmethod
-    def process(cls, entity):
+    def process(cls, entity, when):
         '''
         Apply all statements to the given entity.
         '''
-        # loop over all statements in the class's statement list 
+        # loop over all statements in the class's statement list named "when"
         # and apply them, i.e. instanciate the corresponding classes
-        for statement, args, kwargs in getattr(entity, STATEMENTS, []):
+        statement_map = getattr(entity, STATEMENTS, {})
+        statements = statement_map.get(when, [])
+        for statement, args, kwargs in statements:
             statement.target(entity, *args, **kwargs)

elixir/trunk/tests/test_autoload.py

@@ -3 +3 @@
 """
 
-from sqlalchemy import Table, Column, ForeignKey, BoundMetaData, create_engine
+from sqlalchemy import Table, Column, ForeignKey, MetaData
 from elixir import *
 import elixir
@@ -9 +9 @@
 def setup():
     # First create the tables (it would be better to use an external db)
-    engine = create_engine('sqlite:///')
-    meta = BoundMetaData(engine)
+    meta = MetaData('sqlite:///')
 
     person_table = Table('person', meta,
@@ -37 +36 @@
     meta.create_all()
 
-    elixir.delay_setup = True
     elixir.options_defaults.update(dict(autoload=True, shortnames=True))
 
@@ -68 +66 @@
                                 tablename='person_category')
 
-    elixir.delay_setup = False
     elixir.options_defaults.update(dict(autoload=False, shortnames=False))
 
-    metadata.connect(engine)
+    metadata.connect(meta.bind)
     setup_all()
 
@@ -118 +115 @@
         objectstore.clear()
         
-        p = Person.get_by(name="Homer")
-        
-        print "%s is %s's child." % (p.name, p.father.name)
-        print "His children are: %s." % (
-                " and ".join(c.name for c in p.children))
+        p = Person.q.filter_by(name="Homer").one()
         
         assert p in p.father.children
+        assert p.father.name == "Abe"
         assert p.father is Person.get_by(name="Abe")
         assert p is Person.get_by(name="Lisa").father

elixir/trunk/tests/test_autoload_mixed.py

@@ -5 +5 @@
 
 def teardown():
-    cleanup_all()
+    cleanup_all(True)
 
 class TestAutoloadMixed(object):
     def setup(self):
-        conn = metadata.engine.connect()
+        conn = metadata.bind.connect()
         conn.execute("""CREATE TABLE user
         (user_id INTEGER PRIMARY KEY AUTOINCREMENT)""")
@@ -15 +15 @@
         
     def test_belongs_to(self):
-        global User, Item
-
         class User(Entity):
             using_options(tablename='user', autoload=True)
@@ -23 +21 @@
             belongs_to('owner', of_kind='User')
 
-        create_all()
+        setup_all(True)
 
         assert Item.table.c['owner_user_id'].foreign_key.column.name == 'user_id'

elixir/trunk/tests/test_autoload_nopk.py

@@ -16 +16 @@
 class TestAutoload(object):
     def test_pk(self):
-        local_meta = MetaData(metadata.engine)
+        local_meta = MetaData(metadata.bind)
 
         person_table = Table('person', local_meta,

elixir/trunk/tests/test_has_property.py

@@ -3 +3 @@
 """
 
-from sqlalchemy import column_property
+from sqlalchemy.orm import column_property
 from elixir import *
 

elixir/trunk/tests/test_inherit.py

@@ -6 +6 @@
 
 def setup():
-    global Person, PersonExtended
-
-    class Person(Entity):
-        has_field('firstname', Unicode(30))
-        has_field('surname', Unicode(30))
-        belongs_to('sister', of_kind='Person')
-
-        @property
-        def name(self):
-            return "%s %s" % (self.firstname, self.surname)
-
-        def __str__(self):
-            sister = self.sister and self.sister.name or "unknown"
-            return "%s [%s]" % (self.name, sister)
-    
-    class PersonExtended(Person):
-        has_field('age', Integer)
-        belongs_to('parent', of_kind='PersonExtended')
-
-        using_options(inheritance='single')
-
-        def __str__(self):
-            parent = self.parent and self.parent.name or "unknown"
-            return "%s (%s) {%s}" % (super(PersonExtended, self).__str__(), 
-                                     self.age, parent)
-
     metadata.connect('sqlite:///')
 
+def do_tst(inheritance, polymorphic, expected_res):
+    class A(Entity):
+        has_field('data1', String(20))
+        using_options(inheritance=inheritance, polymorphic=polymorphic)
 
-def teardown():
-    cleanup_all()
+    class B(A):
+        has_field('data2', String(20))
+        using_options(inheritance=inheritance, polymorphic=polymorphic)
+
+    class C(B):
+        has_field('data3', String(20))
+        using_options(inheritance=inheritance, polymorphic=polymorphic)
+
+    class D(A):
+        has_field('data4', String(20))
+        using_options(inheritance=inheritance, polymorphic=polymorphic)
+
+    setup_all(True)
+
+    A(data1='a1')
+    B(data1='b1', data2='b2')
+    C(data1='c1', data2='c2', data3='c3')
+    D(data1='d1', data4='d4')
+
+    objectstore.flush()
+    objectstore.clear()
+
+    res = {}
+    for class_ in (A, B, C, D):
+        res[class_.__name__] = class_.q.all()
+        res[class_.__name__].sort(key=lambda o: o.__class__.__name__) 
+
+    for query_class in ('A', 'B', 'C', 'D'):
+        assert len(res[query_class]) == len(expected_res[query_class])
+        for real, expected in zip(res[query_class], expected_res[query_class]):
+            assert real.__class__.__name__ == expected
 
 
 class TestInheritance(object):
-    def setup(self):
-        create_all()
-    
     def teardown(self):
-        drop_all()
-        objectstore.clear()
+        cleanup_all(True)
 
     def test_singletable_inheritance(self):
-        homer = PersonExtended(firstname="Homer", surname="Simpson", age=36)
-        # lisa needs to be a Person object, not a PersonExtended object because
-        # the sister relationship points to a Person, not a PersonExtended, so
-        # bart's sister must be a Person. This is to comply with SQLAlchemy's
-        # policy to prevent loading relationships with unintended types, unless 
-        # explicitly enabled (enable_typechecks=False).
-        lisa = Person(firstname="Lisa", surname="Simpson")
-        bart = PersonExtended(firstname="Bart", surname="Simpson", 
-                              parent=homer, sister=lisa)
+        do_tst('single', False, {
+            'A': ('A', 'A', 'A', 'A'),
+            'B': ('B', 'B', 'B', 'B'),
+            'C': ('C', 'C', 'C', 'C'),
+            'D': ('D', 'D', 'D', 'D'),
+        })
 
-        objectstore.flush()
-        objectstore.clear()
+    def test_polymorphic_singletable_inheritance(self):
+        do_tst('single', True, {
+            'A': ('A', 'B', 'C', 'D'),
+            'B': ('B', 'C'),
+            'C': ('C',),
+            'D': ('D',),
+        })
 
-        p = PersonExtended.get_by(firstname="Bart")
+    def test_concrete_inheritance(self):
+        do_tst('concrete', False, {
+            'A': ('A',),
+            'B': ('B',),
+            'C': ('C',),
+            'D': ('D',),
+        })
 
-        assert p.sister.name == 'Lisa Simpson'
-        assert p.parent.age == 36
+    def test_multitable_inheritance(self):
+        do_tst('multi', False, {
+            'A': ('A', 'A', 'A', 'A'),
+            'B': ('B', 'B'),
+            'C': ('C',),
+            'D': ('D',),
+        })
 
-        for p in Person.select():
-            print p
+    def test_polymorphic_multitable_inheritance(self):
+        do_tst('multi', True, {
+            'A': ('A', 'B', 'C', 'D'),
+            'B': ('B', 'C'),
+            'C': ('C',),
+            'D': ('D',),
+        })
 
-        for p in PersonExtended.select():
-            print p
-
-if __name__ == '__main__':
-    setup()
-    test = TestInheritance()
-    test.setup()
-    test.test_singletable_inheritance()
-    test.teardown()
-    teardown()

elixir/trunk/tests/test_options.py

@@ -3 +3 @@
 """
 
-from sqlalchemy import create_session, UniqueConstraint 
+from sqlalchemy import UniqueConstraint 
+from sqlalchemy.orm import create_session
 from sqlalchemy.exceptions import SQLError, ConcurrentModificationError 
 from elixir import *
@@ -84 +85 @@
         cleanup_all()
 
-    def test_table_options(self):
+    def test_unique_constraint(self):
+        
         class Person(Entity):
             has_field('firstname', Unicode(30))
@@ -108 +110 @@
         assert raised
 
+    def test_unique_constraint_belongs_to(self):
+        class Author(Entity):
+            has_field("name", Unicode)
+
+        class Book(Entity):
+            has_field("title", Unicode, required=True)
+            belongs_to("author", of_kind="Author")
+
+            using_table_options(UniqueConstraint("title", "author_id"))
+
+        setup_all(True)
+
+        tolkien = Author(name="J. R. R. Tolkien")
+        lotr = Book(title="The Lord of the Rings", author=tolkien)
+        hobbit = Book(title="The Hobbit", author=tolkien)
+
+        objectstore.flush()
+
+        tolkien2 = Author(name="Tolkien")
+        hobbit2 = Book(title="The Hobbit", author=tolkien2)
+
+        objectstore.flush()
+
+        hobbit3 = Book(title="The Hobbit", author=tolkien)
+
+        raised = False
+        try:
+            objectstore.flush()
+        except SQLError:
+            raised = True
+
+        assert raised
+