- [feature] The "deferred declarative

reflection" system has been moved into the
declarative extension itself, using the
new DeferredReflection class.  This
class is now tested with both single
and joined table inheritance use cases.
[ticket:2485]
- [bug] The autoload_replace flag on Table,
when False, will cause any reflected foreign key
constraints which refer to already-declared
columns to be skipped, assuming that the
in-Python declared column will take over
the task of specifying in-Python ForeignKey
or ForeignKeyConstraint declarations.

2 files changed, 219 insertions, 1 deletions

diff --git a/test/engine/test_reflection.py b/test/engine/test_reflection.py
index 6bfc3246a..be2acb1f3 100644
--- a/test/engine/test_reflection.py
+++ b/test/engine/test_reflection.py
@@ -201,7 +201,11 @@ class ReflectionTest(fixtures.TestBase, ComparesTables):
         assert len(t2.indexes) == 2
 
     @testing.provide_metadata
-    def test_autoload_replace_foreign_key(self):
+    def test_autoload_replace_foreign_key_nonpresent(self):
+        """test autoload_replace=False with col plus FK 
+        establishes the FK not present in the DB.
+        
+        """
         a = Table('a', self.metadata, Column('id', Integer, primary_key=True))
         b = Table('b', self.metadata, Column('id', Integer, primary_key=True),
                                     Column('a_id', Integer))
@@ -219,6 +223,51 @@ class ReflectionTest(fixtures.TestBase, ComparesTables):
         eq_(len(b2.constraints), 2)
 
     @testing.provide_metadata
+    def test_autoload_replace_foreign_key_ispresent(self):
+        """test autoload_replace=False with col plus FK mirroring
+        DB-reflected FK skips the reflected FK and installs 
+        the in-python one only.
+        
+        """
+        a = Table('a', self.metadata, Column('id', Integer, primary_key=True))
+        b = Table('b', self.metadata, Column('id', Integer, primary_key=True),
+                                    Column('a_id', Integer, sa.ForeignKey('a.id')))
+        self.metadata.create_all()
+
+        m2 = MetaData()
+        b2 = Table('b', m2, Column('a_id', Integer, sa.ForeignKey('a.id')))
+        a2 = Table('a', m2, autoload=True, autoload_with=testing.db)
+        b2 = Table('b', m2, extend_existing=True, autoload=True, 
+                                autoload_with=testing.db, 
+                                autoload_replace=False)
+
+        assert b2.c.id is not None
+        assert b2.c.a_id.references(a2.c.id)
+        eq_(len(b2.constraints), 2)
+
+    @testing.provide_metadata
+    def test_autoload_replace_foreign_key_removed(self):
+        """test autoload_replace=False with col minus FK that's in the
+        DB means the FK is skipped and doesn't get installed at all.
+
+        """
+        a = Table('a', self.metadata, Column('id', Integer, primary_key=True))
+        b = Table('b', self.metadata, Column('id', Integer, primary_key=True),
+                                    Column('a_id', Integer, sa.ForeignKey('a.id')))
+        self.metadata.create_all()
+
+        m2 = MetaData()
+        b2 = Table('b', m2, Column('a_id', Integer))
+        a2 = Table('a', m2, autoload=True, autoload_with=testing.db)
+        b2 = Table('b', m2, extend_existing=True, autoload=True, 
+                                autoload_with=testing.db, 
+                                autoload_replace=False)
+
+        assert b2.c.id is not None
+        assert not b2.c.a_id.references(a2.c.id)
+        eq_(len(b2.constraints), 1)
+
+    @testing.provide_metadata
     def test_autoload_replace_primary_key(self):
         a = Table('a', self.metadata, Column('id', Integer))
         self.metadata.create_all()
diff --git a/test/ext/test_declarative_reflection.py b/test/ext/test_declarative_reflection.py
index 28aa47c92..b0aa148a9 100644
--- a/test/ext/test_declarative_reflection.py
+++ b/test/ext/test_declarative_reflection.py
@@ -13,6 +13,10 @@ class DeclarativeReflectionBase(fixtures.TablesTest):
         global Base
         Base = decl.declarative_base(testing.db)
 
+    def teardown(self):
+        super(DeclarativeReflectionBase, self).teardown()
+        clear_mappers()
+
 class DeclarativeReflectionTest(DeclarativeReflectionBase):
 
     @classmethod
@@ -216,3 +220,168 @@ class DeferredReflectionTest(DeferredReflectBase):
 
         DefBase.prepare(testing.db)
         self._roundtrip()
+
+    def test_redefine_fk_double(self):
+        class User(decl.DeferredReflection, fixtures.ComparableEntity, 
+                            Base):
+            __tablename__ = 'users'
+            addresses = relationship("Address", backref="user")
+
+        class Address(decl.DeferredReflection, fixtures.ComparableEntity, 
+                            Base):
+            __tablename__ = 'addresses'
+            user_id = Column(Integer, ForeignKey('users.id'))
+
+        decl.DeferredReflection.prepare(testing.db)
+        self._roundtrip()
+
+
+class DeferredInhReflectBase(DeferredReflectBase):
+    def _roundtrip(self):
+        Foo = Base._decl_class_registry['Foo']
+        Bar = Base._decl_class_registry['Bar']
+
+        s = Session(testing.db)
+ 
+        s.add_all([
+            Bar(data='d1', bar_data='b1'),
+            Bar(data='d2', bar_data='b2'),
+            Bar(data='d3', bar_data='b3'),
+            Foo(data='d4')
+        ])
+        s.commit()
+
+        eq_(
+            s.query(Foo).order_by(Foo.id).all(),
+            [
+                Bar(data='d1', bar_data='b1'),
+                Bar(data='d2', bar_data='b2'),
+                Bar(data='d3', bar_data='b3'),
+                Foo(data='d4')
+            ]
+        )
+
+class DeferredSingleInhReflectionTest(DeferredInhReflectBase):
+    @classmethod
+    def define_tables(cls, metadata):
+        Table("foo", metadata,
+            Column('id', Integer, primary_key=True, 
+                        test_needs_autoincrement=True),
+            Column('type', String(32)),
+            Column('data', String(30)),
+            Column('bar_data', String(30))
+        )
+
+    def test_basic(self):
+        class Foo(decl.DeferredReflection, fixtures.ComparableEntity, 
+                    Base):
+            __tablename__ = 'foo'
+            __mapper_args__ = {"polymorphic_on":"type", 
+                        "polymorphic_identity":"foo"}
+
+        class Bar(Foo):
+            __mapper_args__ = {"polymorphic_identity":"bar"}
+
+        decl.DeferredReflection.prepare(testing.db)
+        self._roundtrip()
+
+    def test_add_subclass_column(self):
+        class Foo(decl.DeferredReflection, fixtures.ComparableEntity, 
+                    Base):
+            __tablename__ = 'foo'
+            __mapper_args__ = {"polymorphic_on":"type", 
+                        "polymorphic_identity":"foo"}
+
+        class Bar(Foo):
+            __mapper_args__ = {"polymorphic_identity":"bar"}
+            bar_data = Column(String(30))
+
+        decl.DeferredReflection.prepare(testing.db)
+        self._roundtrip()
+
+    def test_add_pk_column(self):
+        class Foo(decl.DeferredReflection, fixtures.ComparableEntity, 
+                    Base):
+            __tablename__ = 'foo'
+            __mapper_args__ = {"polymorphic_on":"type", 
+                        "polymorphic_identity":"foo"}
+            id = Column(Integer, primary_key=True)
+
+        class Bar(Foo):
+            __mapper_args__ = {"polymorphic_identity":"bar"}
+
+        decl.DeferredReflection.prepare(testing.db)
+        self._roundtrip()
+
+class DeferredJoinedInhReflectionTest(DeferredInhReflectBase):
+    @classmethod
+    def define_tables(cls, metadata):
+        Table("foo", metadata,
+            Column('id', Integer, primary_key=True, 
+                        test_needs_autoincrement=True),
+            Column('type', String(32)),
+            Column('data', String(30)),
+        )
+        Table('bar', metadata,
+            Column('id', Integer, ForeignKey('foo.id'), primary_key=True),
+            Column('bar_data', String(30))
+        )
+
+    def test_basic(self):
+        class Foo(decl.DeferredReflection, fixtures.ComparableEntity, 
+                    Base):
+            __tablename__ = 'foo'
+            __mapper_args__ = {"polymorphic_on":"type", 
+                        "polymorphic_identity":"foo"}
+
+        class Bar(Foo):
+            __tablename__ = 'bar'
+            __mapper_args__ = {"polymorphic_identity":"bar"}
+
+        decl.DeferredReflection.prepare(testing.db)
+        self._roundtrip()
+
+    def test_add_subclass_column(self):
+        class Foo(decl.DeferredReflection, fixtures.ComparableEntity, 
+                    Base):
+            __tablename__ = 'foo'
+            __mapper_args__ = {"polymorphic_on":"type", 
+                        "polymorphic_identity":"foo"}
+
+        class Bar(Foo):
+            __tablename__ = 'bar'
+            __mapper_args__ = {"polymorphic_identity":"bar"}
+            bar_data = Column(String(30))
+
+        decl.DeferredReflection.prepare(testing.db)
+        self._roundtrip()
+
+    def test_add_pk_column(self):
+        class Foo(decl.DeferredReflection, fixtures.ComparableEntity, 
+                    Base):
+            __tablename__ = 'foo'
+            __mapper_args__ = {"polymorphic_on":"type", 
+                        "polymorphic_identity":"foo"}
+            id = Column(Integer, primary_key=True)
+
+        class Bar(Foo):
+            __tablename__ = 'bar'
+            __mapper_args__ = {"polymorphic_identity":"bar"}
+
+        decl.DeferredReflection.prepare(testing.db)
+        self._roundtrip()
+
+    def test_add_fk_pk_column(self):
+        class Foo(decl.DeferredReflection, fixtures.ComparableEntity, 
+                    Base):
+            __tablename__ = 'foo'
+            __mapper_args__ = {"polymorphic_on":"type", 
+                        "polymorphic_identity":"foo"}
+
+        class Bar(Foo):
+            __tablename__ = 'bar'
+            __mapper_args__ = {"polymorphic_identity":"bar"}
+            id = Column(Integer, ForeignKey('foo.id'), primary_key=True)
+
+        decl.DeferredReflection.prepare(testing.db)
+        self._roundtrip()