Commits

Mike Bayer committed c33d037

- Liberalized the contract for :class:`.Index` a bit in that you can
specify a :func:`.text` expression as the target; the index no longer
needs to have a table-bound column present if the index is to be
manually added to the table, either via inline declaration or via
:meth:`.Table.append_constraint`. fixes #3028

  • Participants
  • Parent commits 1fb4ad7

Comments (0)

Files changed (8)

File doc/build/changelog/changelog_09.rst

     :version: 0.9.5
 
     .. change::
+        :tags: feature, sql
+        :tickets: 3028
+
+        Liberalized the contract for :class:`.Index` a bit in that you can
+        specify a :func:`.text` expression as the target; the index no longer
+        needs to have a table-bound column present if the index is to be
+        manually added to the table, either via inline declaration or via
+        :meth:`.Table.append_constraint`.
+
+    .. change::
         :tags: bug, mssql
         :tickets: 3025
 

File lib/sqlalchemy/sql/base.py

         for this dictionary.
 
         """
+        if not column.key:
+            raise exc.ArgumentError(
+                        "Can't add unnamed column to column collection")
         self[column.key] = column
 
     def __delitem__(self, key):

File lib/sqlalchemy/sql/naming.py

         metadata = table.metadata
         convention = _get_convention(metadata.naming_convention, type(const))
         if convention is not None:
-            newname = conv(
-                        convention % ConventionDict(const, table, metadata.naming_convention)
-                        )
-            if const.name is None:
-                const.name = newname
+            if const.name is None or "constraint_name" in convention:
+                newname = conv(
+                            convention % ConventionDict(const, table, metadata.naming_convention)
+                            )
+                if const.name is None:
+                    const.name = newname

File lib/sqlalchemy/sql/schema.py

 
         Index("some_index", sometable.c.name, sometable.c.address)
 
-    Functional indexes are supported as well, keeping in mind that at least
-    one :class:`.Column` must be present::
+    Functional indexes are supported as well, typically by using the
+    :data:`.func` construct in conjunction with table-bound
+    :class:`.Column` objects::
 
         Index("some_index", func.lower(sometable.c.name))
 
     .. versionadded:: 0.8 support for functional and expression-based indexes.
 
+    An :class:`.Index` can also be manually associated with a :class:`.Table`,
+    either through inline declaration or using :meth:`.Table.append_constraint`.
+    When this approach is used, the names of the indexed columns can be specified
+    as strings::
+
+        Table("sometable", metadata,
+                        Column("name", String(50)),
+                        Column("address", String(100)),
+                        Index("some_index", "name", "address")
+                )
+
+    To support functional or expression-based indexes in this form, the
+    :func:`.text` construct may be used::
+
+        from sqlalchemy import text
+
+        Table("sometable", metadata,
+                        Column("name", String(50)),
+                        Column("address", String(100)),
+                        Index("some_index", text("lower(name)"))
+                )
+
+    .. versionadded:: 0.9.5 the :func:`.text` construct may be used to
+       specify :class:`.Index` expressions, provided the :class:`.Index`
+       is explicitly associated with the :class:`.Table`.
+
+
     .. seealso::
 
         :ref:`schema_indexes` - General information on :class:`.Index`.
                 visitors.traverse(expr, {}, {'column': cols.append})
                 if cols:
                     columns.append(cols[0])
-                else:
-                    columns.append(expr)
 
         self.expressions = expressions
         self.name = quoted_name(name, kw.pop("quote", None))
         ColumnCollectionMixin.__init__(self, *columns)
 
 
-
     def _set_parent(self, table):
         ColumnCollectionMixin._set_parent(self, table)
 
         self.expressions = [
             expr if isinstance(expr, ClauseElement)
             else colexpr
-            for expr, colexpr in zip(self.expressions, self.columns)
+            for expr, colexpr in util.zip_longest(self.expressions, self.columns)
         ]
 
     @property
         return 'Index(%s)' % (
                     ", ".join(
                         [repr(self.name)] +
-                        [repr(c) for c in self.columns] +
+                        [repr(e) for e in self.expressions] +
                         (self.unique and ["unique=True"] or [])
                     ))
 

File lib/sqlalchemy/util/__init__.py

     raise_from_cause, text_type, string_types, int_types, binary_type, \
     quote_plus, with_metaclass, print_, itertools_filterfalse, u, ue, b,\
     unquote_plus, unquote, b64decode, b64encode, byte_buffer, itertools_filter,\
-    iterbytes, StringIO, inspect_getargspec
+    iterbytes, StringIO, inspect_getargspec, zip_longest
 
 from ._collections import KeyedTuple, ImmutableContainer, immutabledict, \
     Properties, OrderedProperties, ImmutableProperties, OrderedDict, \

File lib/sqlalchemy/util/compat.py

     itertools_filterfalse = itertools.filterfalse
     itertools_filter = filter
     itertools_imap = map
+    from itertools import zip_longest
+
 
     import base64
     def b64encode(x):
     itertools_filterfalse = itertools.ifilterfalse
     itertools_filter = itertools.ifilter
     itertools_imap = itertools.imap
+    from itertools import izip_longest as zip_longest
+
 
 
 import time

File test/sql/test_constraints.py

 from sqlalchemy.testing import assert_raises, assert_raises_message
 from sqlalchemy import Table, Integer, String, Column, PrimaryKeyConstraint,\
     ForeignKeyConstraint, ForeignKey, UniqueConstraint, Index, MetaData, \
-    CheckConstraint, func
+    CheckConstraint, func, text
 from sqlalchemy import exc, schema
 from sqlalchemy.testing import fixtures, AssertsExecutionResults, \
                     AssertsCompiledSQL
 class ConstraintCompilationTest(fixtures.TestBase, AssertsCompiledSQL):
     __dialect__ = 'default'
 
-    def test_create_plain(self):
+    def test_create_index_plain(self):
         t = Table('t', MetaData(), Column('x', Integer))
         i = Index("xyz", t.c.x)
         self.assert_compile(
             "CREATE INDEX xyz ON t (x)"
         )
 
-    def test_drop_plain_unattached(self):
+    def test_drop_index_plain_unattached(self):
         self.assert_compile(
             schema.DropIndex(Index(name="xyz")),
             "DROP INDEX xyz"
         )
 
-    def test_drop_plain(self):
+    def test_drop_index_plain(self):
         self.assert_compile(
             schema.DropIndex(Index(name="xyz")),
             "DROP INDEX xyz"
         )
 
-    def test_create_schema(self):
+    def test_create_index_schema(self):
         t = Table('t', MetaData(), Column('x', Integer), schema="foo")
         i = Index("xyz", t.c.x)
         self.assert_compile(
             "CREATE INDEX xyz ON foo.t (x)"
         )
 
-    def test_drop_schema(self):
+    def test_drop_index_schema(self):
         t = Table('t', MetaData(), Column('x', Integer), schema="foo")
         i = Index("xyz", t.c.x)
         self.assert_compile(
         )
 
 
-    def test_too_long_idx_name(self):
+    def test_too_long_index_name(self):
         dialect = testing.db.dialect.__class__()
 
         for max_ident, max_index in [(22, None), (256, 22)]:
             dialect=testing.db.dialect
         )
 
+    def test_index_against_text_separate(self):
+        metadata = MetaData()
+        idx = Index('y', text("some_function(q)"))
+        t = Table('x', metadata,
+                Column('q', String(50))
+            )
+        t.append_constraint(idx)
+        self.assert_compile(
+            schema.CreateIndex(idx),
+            "CREATE INDEX y ON x (some_function(q))"
+        )
+
+    def test_index_against_text_inline(self):
+        metadata = MetaData()
+        idx = Index('y', text("some_function(q)"))
+        x = Table('x', metadata,
+                Column('q', String(50)),
+                idx
+            )
+
+        self.assert_compile(
+            schema.CreateIndex(idx),
+            "CREATE INDEX y ON x (some_function(q))"
+        )
+
+
     def test_index_declaration_inline(self):
         metadata = MetaData()
 
 
 
     def test_no_warning_w_no_columns(self):
-        # I think the test here is, there is no warning.
-        # people want to create empty indexes for the purpose of
-        # a drop.
         idx = Index(name="foo")
 
         assert_raises_message(

File test/sql/test_metadata.py

     CheckConstraint, ForeignKey, MetaData, Sequence, \
     ForeignKeyConstraint, PrimaryKeyConstraint, ColumnDefault, Index, event,\
     events, Unicode, types as sqltypes, bindparam, \
-    Table, Column, Boolean, Enum
+    Table, Column, Boolean, Enum, func, text
 from sqlalchemy import schema, exc
 import sqlalchemy as tsa
 from sqlalchemy.testing import fixtures
                 "Column('x', String(), table=<bar>), schema=None)"),
             (schema.DefaultGenerator(for_update=True),
                 "DefaultGenerator(for_update=True)"),
-            (schema.Index("bar", "c"), "Index('bar')"),
+            (schema.Index("bar", "c"), "Index('bar', 'c')"),
             (i1, "Index('bar', Column('x', Integer(), table=<foo>))"),
             (schema.FetchedValue(), "FetchedValue()"),
             (ck,
                       extend_existing=True)
         assert "foo" in users.c
 
+class IndexTest(fixtures.TestBase):
+    def _assert(self, t, i, columns=True):
+        eq_(t.indexes, set([i]))
+        if columns:
+            eq_(list(i.columns), [t.c.x])
+        else:
+            eq_(list(i.columns), [])
+        assert i.table is t
+
+    def test_separate_decl_columns(self):
+        m = MetaData()
+        t = Table('t', m, Column('x', Integer))
+        i = Index('i', t.c.x)
+        self._assert(t, i)
+
+    def test_separate_decl_columns_functional(self):
+        m = MetaData()
+        t = Table('t', m, Column('x', Integer))
+        i = Index('i', func.foo(t.c.x))
+        self._assert(t, i)
+
+    def test_inline_decl_columns(self):
+        m = MetaData()
+        c = Column('x', Integer)
+        i = Index('i', c)
+        t = Table('t', m, c, i)
+        self._assert(t, i)
+
+    def test_inline_decl_columns_functional(self):
+        m = MetaData()
+        c = Column('x', Integer)
+        i = Index('i', func.foo(c))
+        t = Table('t', m, c, i)
+        self._assert(t, i)
+
+    def test_inline_decl_string(self):
+        m = MetaData()
+        i = Index('i', "x")
+        t = Table('t', m, Column('x', Integer), i)
+        self._assert(t, i)
+
+    def test_inline_decl_textonly(self):
+        m = MetaData()
+        i = Index('i', text("foobar(x)"))
+        t = Table('t', m, Column('x', Integer), i)
+        self._assert(t, i, columns=False)
+
+    def test_separate_decl_textonly(self):
+        m = MetaData()
+        i = Index('i', text("foobar(x)"))
+        t = Table('t', m, Column('x', Integer))
+        t.append_constraint(i)
+        self._assert(t, i, columns=False)
+
+    def test_unnamed_column_exception(self):
+        # this can occur in some declarative situations
+        c = Column(Integer)
+        idx = Index('q', c)
+        m = MetaData()
+        t = Table('t', m, Column('q'))
+        assert_raises_message(
+            exc.ArgumentError,
+            "Can't add unnamed column to column collection",
+            t.append_constraint, idx
+        )
+
+
 class ConstraintTest(fixtures.TestBase):
     def _single_fixture(self):
         m = MetaData()