- fixed use_alter flag on ForeignKeyConstraint [ticket:503]

diff --git a/CHANGES b/CHANGES
index f263bcdd195815d4b4227442defb4754d48d8c5d..5501d4cefc0a49ba477754f58f99768799feb3ed 100644 (file)
--- a/CHANGES
+++ b/CHANGES
@@ -22,7 +22,8 @@
     'duplicate' columns from the resulting column clause that are known to be 
     equivalent based on the join condition.  this is of great usage when 
     constructing subqueries of joins which Postgres complains about if 
-    duplicate column names are present.    
+    duplicate column names are present.
+    - fixed use_alter flag on ForeignKeyConstraint [ticket:503]
 - orm:
     - a full select() construct can be passed to query.select() (which
       worked anyway), but also query.selectfirst(), query.selectone() which

diff --git a/lib/sqlalchemy/exceptions.py b/lib/sqlalchemy/exceptions.py
index 08908cdb6043a814ab1f0c35d21502d3b4ac965a..55c345bd72d264b2b7b2bab895999c5ff8935533 100644 (file)
--- a/lib/sqlalchemy/exceptions.py
+++ b/lib/sqlalchemy/exceptions.py
@@ -49,6 +49,10 @@ class ConcurrentModificationError(SQLAlchemyError):
 
     pass
 
+class CircularDependencyError(SQLAlchemyError):
+    """Raised by topological sorts when a circular dependency is detected"""
+    pass
+    
 class FlushError(SQLAlchemyError):
     """Raised when an invalid condition is detected upon a ``flush()``."""
     pass

diff --git a/lib/sqlalchemy/schema.py b/lib/sqlalchemy/schema.py
index ae4a0b1626f841ca9eda7cb0b287bfe9462258b5..52324e63eed53d484e4fe41e24fe7bd6b11ad2dd 100644 (file)
--- a/lib/sqlalchemy/schema.py
+++ b/lib/sqlalchemy/schema.py
@@ -908,7 +908,7 @@ class ForeignKeyConstraint(Constraint):
         visitor.visit_foreign_key_constraint(self)
 
     def append_element(self, col, refcol):
-        fk = ForeignKey(refcol, constraint=self)
+        fk = ForeignKey(refcol, constraint=self, name=self.name, onupdate=self.onupdate, ondelete=self.ondelete, use_alter=self.use_alter)
         fk._set_parent(self.table.c[col])
         self._append_fk(fk)
 
@@ -917,7 +917,7 @@ class ForeignKeyConstraint(Constraint):
         self.elements.add(fk)
 
     def copy(self):
-        return ForeignKeyConstraint([x.parent.name for x in self.elements], [x._get_colspec() for x in self.elements], name=self.name, onupdate=self.onupdate, ondelete=self.ondelete)
+        return ForeignKeyConstraint([x.parent.name for x in self.elements], [x._get_colspec() for x in self.elements], name=self.name, onupdate=self.onupdate, ondelete=self.ondelete, use_alter=self.use_alter)
 
 class PrimaryKeyConstraint(Constraint):
     def __init__(self, *columns, **kwargs):

diff --git a/lib/sqlalchemy/topological.py b/lib/sqlalchemy/topological.py
index d9f68ac011a824898daa89d634d67aaea6638848..41fa9d9b2db35f12d8b92672e5fd210e2d09d6d1 100644 (file)
--- a/lib/sqlalchemy/topological.py
+++ b/lib/sqlalchemy/topological.py
@@ -44,7 +44,7 @@ I realized this characteristic of the algorithm.
 
 import string, StringIO
 from sqlalchemy import util
-from sqlalchemy.exceptions import *
+from sqlalchemy.exceptions import CircularDependencyError
 
 class _Node(object):
     """Represent each item in the sort.
@@ -188,7 +188,7 @@ class QueueDependencySorter(object):
                     n.cycles = util.Set([n])
                     continue
                 else:
-                    raise FlushError("Self-referential dependency detected " + repr(t))
+                    raise CircularDependencyError("Self-referential dependency detected " + repr(t))
             childnode = nodes[t[1]]
             parentnode = nodes[t[0]]
             edges.add((parentnode, childnode))
@@ -222,7 +222,7 @@ class QueueDependencySorter(object):
                     continue
                 else:
                     # long cycles not allowed
-                    raise FlushError("Circular dependency detected " + repr(edges) + repr(queue))
+                    raise CircularDependencyError("Circular dependency detected " + repr(edges) + repr(queue))
             node = queue.pop()
             if not hasattr(node, '_cyclical'):
                 output.append(node)

diff --git a/test/sql/constraints.py b/test/sql/constraints.py
index 926022c82d1c81d4ba8442a93d54761f4ed351e9..79ccee4da2be5671b09a59302d7c766ae2a12e22 100644 (file)
--- a/test/sql/constraints.py
+++ b/test/sql/constraints.py
@@ -28,6 +28,30 @@ class ConstraintTest(testbase.AssertMixin):
             )
         metadata.create_all()
 
+    def test_circular_constraint(self):
+        a = Table("a", metadata, 
+            Column('id', Integer, primary_key=True),
+            Column('bid', Integer),
+            ForeignKeyConstraint(["bid"], ["b.id"], name="afk")
+            )
+        b = Table("b", metadata,
+            Column('id', Integer, primary_key=True),
+            Column("aid", Integer),
+            ForeignKeyConstraint(["aid"], ["a.id"], use_alter=True, name="bfk")
+            )
+        metadata.create_all()
+
+    def test_circular_constraint_2(self):
+        a = Table("a", metadata, 
+            Column('id', Integer, primary_key=True),
+            Column('bid', Integer, ForeignKey("b.id")),
+            )
+        b = Table("b", metadata,
+            Column('id', Integer, primary_key=True),
+            Column("aid", Integer, ForeignKey("a.id", use_alter=True, name="bfk")),
+            )
+        metadata.create_all()
+        
     @testbase.unsupported('mysql')
     def test_check_constraint(self):
         foo = Table('foo', metadata,