Reflect unique constraints when reflecting a Table object

Calls to reflect a table did not create any UniqueConstraint objects.
The reflection core made no calls to get_unique_constraints and as
a result, the sqlite dialect would never reflect any unique constraints.

MySQL transparently converts unique constraints into unique indexes, but
SQLAlchemy would reflect those as an Index object and as a
UniqueConstraint. The reflection core will now deduplicate the unique
constraints.

PostgreSQL would reflect unique constraints as an Index object and as
a UniqueConstraint object. The reflection core will now deduplicate
the unique indexes.

1 files changed, 35 insertions, 2 deletions

diff --git a/test/dialect/postgresql/test_reflection.py b/test/dialect/postgresql/test_reflection.py
index b8b9be3de..fc013c72a 100644
--- a/test/dialect/postgresql/test_reflection.py
+++ b/test/dialect/postgresql/test_reflection.py
@@ -7,7 +7,7 @@ from sqlalchemy.testing import fixtures
 from sqlalchemy import testing
 from sqlalchemy import inspect
 from sqlalchemy import Table, Column, MetaData, Integer, String, \
-    PrimaryKeyConstraint, ForeignKey, join, Sequence
+    PrimaryKeyConstraint, ForeignKey, join, Sequence, UniqueConstraint
 from sqlalchemy import exc
 import sqlalchemy as sa
 from sqlalchemy.dialects.postgresql import base as postgresql
@@ -656,7 +656,8 @@ class ReflectionTest(fixtures.TestBase):
         conn.execute("ALTER TABLE t RENAME COLUMN x to y")
 
         ind = testing.db.dialect.get_indexes(conn, "t", None)
-        eq_(ind, [{'unique': False, 'column_names': ['y'], 'name': 'idx1'}])
+        eq_(ind, [{'unique': False, 'duplicates_constraint': None,
+                   'column_names': ['y'], 'name': 'idx1'}])
         conn.close()
 
     @testing.provide_metadata
@@ -803,6 +804,38 @@ class ReflectionTest(fixtures.TestBase):
                 'labels': ['sad', 'ok', 'happy']
             }])
 
+    def test_reflection_with_unique_constraint(self):
+        insp = inspect(testing.db)
+
+        uc_table = Table('pgsql_uc', MetaData(testing.db),
+                         Column('a', String(10)),
+                         UniqueConstraint('a', name='uc_a'))
+
+        try:
+            uc_table.create()
+
+            # PostgreSQL will create an implicit index for a unique
+            # constraint. As a result, the 0.9 API returns it as both
+            # an index and a constraint
+            indexes = set(i['name'] for i in insp.get_indexes('pgsql_uc'))
+            constraints = set(i['name']
+                              for i in insp.get_unique_constraints('pgsql_uc'))
+
+            self.assert_('uc_a' in indexes)
+            self.assert_('uc_a' in constraints)
+
+            # However, upon creating a Table object via reflection, it should
+            # only appear as a unique constraint and not an index
+            reflected = Table('pgsql_uc', MetaData(testing.db), autoload=True)
+
+            indexes = set(i.name for i in reflected.indexes)
+            constraints = set(uc.name for uc in reflected.constraints)
+
+            self.assert_('uc_a' not in indexes)
+            self.assert_('uc_a' in constraints)
+        finally:
+            uc_table.drop()
+
 
 class CustomTypeReflectionTest(fixtures.TestBase):