sqlalchemy.Index

Here are the examples of the python api sqlalchemy.Index taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

246 Examples 7

3 Source : models.py
with GNU General Public License v3.0
from ailabstw

def init():
    """init database
    """
    create_db()
    metadata.create_all(engine)

    insert_genes(engine)
    insert_transcripts(engine)
    insert_rsid(engine)

    index = Index('idx_name', rsid.c.name)
    index.create(bind=engine)


if __name__ == '__main__':

3 Source : relations.py
with Apache License 2.0
from amakelov

    def make_table(self, name:str, db_meta:MetaData, schema:str) -> Table:
        extra_args = []
        for index_cols in self.indices:
            # note that index names must be unique DB-wide
            extra_args.append(Index(f'multicol_{name}', *index_cols, unique=True))
        table = Table(name, db_meta, *self.col_objs, *extra_args, 
                      extend_existing=self.extend_existing, schema=schema)
        return table


class RelStorage(ABC):

3 Source : batch.py
with MIT License
from bkerler

    def _gather_indexes_from_both_tables(self):
        idx = []
        idx.extend(self.indexes.values())
        for index in self.new_indexes.values():
            idx.append(
                Index(
                    index.name,
                    unique=index.unique,
                    *[self.new_table.c[col] for col in index.columns.keys()],
                    **index.kwargs)
            )
        return idx

    def _setup_referent(self, metadata, constraint):

3 Source : batch.py
with MIT License
from DiptoChakrabarty

    def _gather_indexes_from_both_tables(self):
        idx = []
        idx.extend(self.indexes.values())
        for index in self.new_indexes.values():
            idx.append(
                Index(
                    index.name,
                    unique=index.unique,
                    *[self.new_table.c[col] for col in index.columns.keys()],
                    **index.kwargs
                )
            )
        return idx

    def _setup_referent(self, metadata, constraint):

3 Source : test_compiler.py
with Apache License 2.0
from gethue

    def test_table_idx_explicit_nonclustered(self):
        metadata = MetaData()
        tbl = Table(
            "test",
            metadata,
            Column("x", Integer, autoincrement=False),
            Column("y", Integer, autoincrement=False),
        )

        idx = Index("myidx", tbl.c.x, tbl.c.y, mssql_clustered=False)
        self.assert_compile(
            schema.CreateIndex(idx),
            "CREATE NONCLUSTERED INDEX myidx ON test (x, y)",
        )

    def test_table_uc_explicit_nonclustered(self):

3 Source : test_compiler.py
with Apache License 2.0
from gethue

    def test_index_clustering(self):
        metadata = MetaData()
        tbl = Table("test", metadata, Column("id", Integer))
        idx = Index("foo", tbl.c.id, mssql_clustered=True)
        self.assert_compile(
            schema.CreateIndex(idx), "CREATE CLUSTERED INDEX foo ON test (id)"
        )

    def test_index_where(self):

3 Source : test_compiler.py
with Apache License 2.0
from gethue

    def test_index_where(self):
        metadata = MetaData()
        tbl = Table("test", metadata, Column("data", Integer))
        idx = Index("test_idx_data_1", tbl.c.data, mssql_where=tbl.c.data > 1)
        self.assert_compile(
            schema.CreateIndex(idx),
            "CREATE INDEX test_idx_data_1 ON test (data) WHERE data > 1",
        )

    def test_index_ordering(self):

3 Source : test_compiler.py
with Apache License 2.0
from gethue

    def test_index_ordering(self):
        metadata = MetaData()
        tbl = Table(
            "test",
            metadata,
            Column("x", Integer),
            Column("y", Integer),
            Column("z", Integer),
        )
        idx = Index("foo", tbl.c.x.desc(), "y")
        self.assert_compile(
            schema.CreateIndex(idx), "CREATE INDEX foo ON test (x DESC, y)"
        )

    def test_create_index_expr(self):

3 Source : test_compiler.py
with Apache License 2.0
from gethue

    def test_create_index_expr(self):
        m = MetaData()
        t1 = Table("foo", m, Column("x", Integer))
        self.assert_compile(
            schema.CreateIndex(Index("bar", t1.c.x > 5)),
            "CREATE INDEX bar ON foo (x > 5)",
        )

    def test_drop_index_w_schema(self):

3 Source : test_compiler.py
with Apache License 2.0
from gethue

    def test_drop_index_w_schema(self):
        m = MetaData()
        t1 = Table("foo", m, Column("x", Integer), schema="bar")
        self.assert_compile(
            schema.DropIndex(Index("idx_foo", t1.c.x)),
            "DROP INDEX idx_foo ON bar.foo",
        )

    def test_index_extra_include_1(self):

3 Source : test_compiler.py
with Apache License 2.0
from gethue

    def test_index_extra_include_1(self):
        metadata = MetaData()
        tbl = Table(
            "test",
            metadata,
            Column("x", Integer),
            Column("y", Integer),
            Column("z", Integer),
        )
        idx = Index("foo", tbl.c.x, mssql_include=["y"])
        self.assert_compile(
            schema.CreateIndex(idx), "CREATE INDEX foo ON test (x) INCLUDE (y)"
        )

    def test_index_extra_include_2(self):

3 Source : test_compiler.py
with Apache License 2.0
from gethue

    def test_index_extra_include_2(self):
        metadata = MetaData()
        tbl = Table(
            "test",
            metadata,
            Column("x", Integer),
            Column("y", Integer),
            Column("z", Integer),
        )
        idx = Index("foo", tbl.c.x, mssql_include=[tbl.c.y])
        self.assert_compile(
            schema.CreateIndex(idx), "CREATE INDEX foo ON test (x) INCLUDE (y)"
        )

    def test_try_cast(self):

3 Source : test_reflection.py
with Apache License 2.0
from gethue

    def test_table_name_that_is_greater_than_16_chars(self):
        metadata = self.metadata
        Table(
            "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
            metadata,
            Column("id", Integer, primary_key=True),
            Column("foo", Integer),
            Index("foo_idx", "foo"),
        )
        metadata.create_all()

        t = Table(
            "ABCDEFGHIJKLMNOPQRSTUVWXYZ", MetaData(), autoload_with=testing.db
        )
        eq_(t.name, "ABCDEFGHIJKLMNOPQRSTUVWXYZ")

    @testing.provide_metadata

3 Source : test_reflection.py
with Apache License 2.0
from gethue

    def test_indexes_cols(self):
        metadata = self.metadata

        t1 = Table("t", metadata, Column("x", Integer), Column("y", Integer))
        Index("foo", t1.c.x, t1.c.y)
        metadata.create_all()

        m2 = MetaData()
        t2 = Table("t", m2, autoload=True, autoload_with=testing.db)

        eq_(set(list(t2.indexes)[0].columns), set([t2.c["x"], t2.c.y]))

    @testing.provide_metadata

3 Source : test_reflection.py
with Apache License 2.0
from gethue

    def test_indexes_cols_with_commas(self):
        metadata = self.metadata

        t1 = Table(
            "t",
            metadata,
            Column("x, col", Integer, key="x"),
            Column("y", Integer),
        )
        Index("foo", t1.c.x, t1.c.y)
        metadata.create_all()

        m2 = MetaData()
        t2 = Table("t", m2, autoload=True, autoload_with=testing.db)

        eq_(set(list(t2.indexes)[0].columns), set([t2.c["x, col"], t2.c.y]))

    @testing.provide_metadata

3 Source : test_reflection.py
with Apache License 2.0
from gethue

    def test_indexes_cols_with_spaces(self):
        metadata = self.metadata

        t1 = Table(
            "t",
            metadata,
            Column("x col", Integer, key="x"),
            Column("y", Integer),
        )
        Index("foo", t1.c.x, t1.c.y)
        metadata.create_all()

        m2 = MetaData()
        t2 = Table("t", m2, autoload=True, autoload_with=testing.db)

        eq_(set(list(t2.indexes)[0].columns), set([t2.c["x col"], t2.c.y]))

    @testing.provide_metadata

3 Source : test_compiler.py
with Apache License 2.0
from gethue

    def test_create_index_simple(self):
        m = MetaData()
        tbl = Table("testtbl", m, Column("data", String(255)))
        idx = Index("test_idx1", tbl.c.data)

        self.assert_compile(
            schema.CreateIndex(idx), "CREATE INDEX test_idx1 ON testtbl (data)"
        )

    def test_create_index_with_prefix(self):

3 Source : test_compiler.py
with Apache License 2.0
from gethue

    def test_create_index_with_prefix(self):
        m = MetaData()
        tbl = Table("testtbl", m, Column("data", String(255)))
        idx = Index(
            "test_idx1", tbl.c.data, mysql_length=10, mysql_prefix="FULLTEXT"
        )

        self.assert_compile(
            schema.CreateIndex(idx),
            "CREATE FULLTEXT INDEX test_idx1 " "ON testtbl (data(10))",
        )

    def test_create_index_with_parser(self):

3 Source : test_compiler.py
with Apache License 2.0
from gethue

    def test_create_index_with_parser(self):
        m = MetaData()
        tbl = Table("testtbl", m, Column("data", String(255)))
        idx = Index(
            "test_idx1",
            tbl.c.data,
            mysql_length=10,
            mysql_prefix="FULLTEXT",
            mysql_with_parser="ngram",
        )

        self.assert_compile(
            schema.CreateIndex(idx),
            "CREATE FULLTEXT INDEX test_idx1 "
            "ON testtbl (data(10)) WITH PARSER ngram",
        )

    def test_create_index_with_length(self):

3 Source : test_compiler.py
with Apache License 2.0
from gethue

    def test_create_index_with_length(self):
        m = MetaData()
        tbl = Table("testtbl", m, Column("data", String(255)))
        idx1 = Index("test_idx1", tbl.c.data, mysql_length=10)
        idx2 = Index("test_idx2", tbl.c.data, mysql_length=5)

        self.assert_compile(
            schema.CreateIndex(idx1),
            "CREATE INDEX test_idx1 ON testtbl (data(10))",
        )
        self.assert_compile(
            schema.CreateIndex(idx2),
            "CREATE INDEX test_idx2 ON testtbl (data(5))",
        )

    def test_drop_constraint_mysql(self):

3 Source : test_compiler.py
with Apache License 2.0
from gethue

    def test_create_index_with_length_quoted(self):
        m = MetaData()
        tbl = Table(
            "testtbl", m, Column("some quoted data", String(255), key="s")
        )
        idx1 = Index("test_idx1", tbl.c.s, mysql_length=10)

        self.assert_compile(
            schema.CreateIndex(idx1),
            "CREATE INDEX test_idx1 ON testtbl (`some quoted data`(10))",
        )

    def test_create_composite_index_with_length_quoted(self):

3 Source : test_compiler.py
with Apache License 2.0
from gethue

    def test_create_index_with_using(self):
        m = MetaData()
        tbl = Table("testtbl", m, Column("data", String(255)))
        idx1 = Index("test_idx1", tbl.c.data, mysql_using="btree")
        idx2 = Index("test_idx2", tbl.c.data, mysql_using="hash")

        self.assert_compile(
            schema.CreateIndex(idx1),
            "CREATE INDEX test_idx1 ON testtbl (data) USING btree",
        )
        self.assert_compile(
            schema.CreateIndex(idx2),
            "CREATE INDEX test_idx2 ON testtbl (data) USING hash",
        )

    def test_create_pk_plain(self):

3 Source : test_compiler.py
with Apache License 2.0
from gethue

    def test_create_index_expr(self):
        m = MetaData()
        t1 = Table("foo", m, Column("x", Integer))
        self.assert_compile(
            schema.CreateIndex(Index("bar", t1.c.x > 5)),
            "CREATE INDEX bar ON foo (x > 5)",
        )

    def test_deferrable_initially_kw_not_ignored(self):

3 Source : test_reflection.py
with Apache License 2.0
from gethue

    def test_non_column_index(self):
        m1 = self.metadata
        t1 = Table(
            "add_ix", m1, Column("x", String(50)), mysql_engine="InnoDB"
        )
        Index("foo_idx", t1.c.x.desc())
        m1.create_all()

        insp = inspect(testing.db)
        eq_(
            insp.get_indexes("add_ix"),
            [{"name": "foo_idx", "column_names": ["x"], "unique": False}],
        )

    def _bug_88718_96365_casing_0(self):

3 Source : test_compiler.py
with Apache License 2.0
from gethue

    def test_create_index_alt_schema(self):
        m = MetaData()
        t1 = Table("foo", m, Column("x", Integer), schema="alt_schema")
        self.assert_compile(
            schema.CreateIndex(Index("bar", t1.c.x)),
            "CREATE INDEX alt_schema.bar ON alt_schema.foo (x)",
        )

    def test_create_index_expr(self):

3 Source : test_compiler.py
with Apache License 2.0
from gethue

    def test_create_index_expr(self):
        m = MetaData()
        t1 = Table("foo", m, Column("x", Integer))
        self.assert_compile(
            schema.CreateIndex(Index("bar", t1.c.x > 5)),
            "CREATE INDEX bar ON foo (x > 5)",
        )

    def test_table_options(self):

3 Source : test_compiler.py
with Apache License 2.0
from gethue

    def test_create_index_expr_gets_parens(self):
        m = MetaData()
        tbl = Table("testtbl", m, Column("x", Integer), Column("y", Integer))

        idx1 = Index("test_idx1", 5 / (tbl.c.x + tbl.c.y))
        self.assert_compile(
            schema.CreateIndex(idx1),
            "CREATE INDEX test_idx1 ON testtbl ((5 / (x + y)))",
        )

    def test_create_index_literals(self):

3 Source : test_compiler.py
with Apache License 2.0
from gethue

    def test_create_index_literals(self):
        m = MetaData()
        tbl = Table("testtbl", m, Column("data", Integer))

        idx1 = Index("test_idx1", tbl.c.data + 5)
        self.assert_compile(
            schema.CreateIndex(idx1),
            "CREATE INDEX test_idx1 ON testtbl ((data + 5))",
        )

    def test_create_index_concurrently(self):

3 Source : test_compiler.py
with Apache License 2.0
from gethue

    def test_create_index_concurrently(self):
        m = MetaData()
        tbl = Table("testtbl", m, Column("data", Integer))

        idx1 = Index("test_idx1", tbl.c.data, postgresql_concurrently=True)
        self.assert_compile(
            schema.CreateIndex(idx1),
            "CREATE INDEX CONCURRENTLY test_idx1 ON testtbl (data)",
        )

        dialect_8_1 = postgresql.dialect()
        dialect_8_1._supports_create_index_concurrently = False
        self.assert_compile(
            schema.CreateIndex(idx1),
            "CREATE INDEX test_idx1 ON testtbl (data)",
            dialect=dialect_8_1,
        )

    def test_drop_index_concurrently(self):

3 Source : test_compiler.py
with Apache License 2.0
from gethue

    def test_drop_index_concurrently(self):
        m = MetaData()
        tbl = Table("testtbl", m, Column("data", Integer))

        idx1 = Index("test_idx1", tbl.c.data, postgresql_concurrently=True)
        self.assert_compile(
            schema.DropIndex(idx1), "DROP INDEX CONCURRENTLY test_idx1"
        )

        dialect_9_1 = postgresql.dialect()
        dialect_9_1._supports_drop_index_concurrently = False
        self.assert_compile(
            schema.DropIndex(idx1), "DROP INDEX test_idx1", dialect=dialect_9_1
        )

    def test_exclude_constraint_min(self):

3 Source : test_compiler.py
with Apache License 2.0
from gethue

    def test_do_update_unnamed_index_target(self):
        i = insert(self.table1, values=dict(name="foo"))

        unnamed_goofy = Index(
            None, self.table1.c.name, postgresql_where=self.table1.c.name > "m"
        )

        i = i.on_conflict_do_update(
            constraint=unnamed_goofy, set_=dict(name=i.excluded.name)
        )
        self.assert_compile(
            i,
            "INSERT INTO mytable (name) VALUES "
            "(%(name)s) ON CONFLICT (name) "
            "WHERE name > %(name_1)s "
            "DO UPDATE SET name = excluded.name",
        )

    def test_do_update_unnamed_exclude_constraint_target(self):

3 Source : test_constraints.py
with Apache License 2.0
from gethue

    def test_create_index_plain(self):
        t = Table("t", MetaData(), Column("x", Integer))
        i = Index("xyz", t.c.x)
        self.assert_compile(schema.CreateIndex(i), "CREATE INDEX xyz ON t (x)")

    def test_drop_index_plain_unattached(self):

3 Source : test_constraints.py
with Apache License 2.0
from gethue

    def test_drop_index_plain_unattached(self):
        self.assert_compile(
            schema.DropIndex(Index(name="xyz")), "DROP INDEX xyz"
        )

    def test_drop_index_plain(self):

3 Source : test_constraints.py
with Apache License 2.0
from gethue

    def test_drop_index_plain(self):
        self.assert_compile(
            schema.DropIndex(Index(name="xyz")), "DROP INDEX xyz"
        )

    def test_create_index_schema(self):

3 Source : test_constraints.py
with Apache License 2.0
from gethue

    def test_create_index_schema(self):
        t = Table("t", MetaData(), Column("x", Integer), schema="foo")
        i = Index("xyz", t.c.x)
        self.assert_compile(
            schema.CreateIndex(i), "CREATE INDEX xyz ON foo.t (x)"
        )

    def test_drop_index_schema(self):

3 Source : test_constraints.py
with Apache License 2.0
from gethue

    def test_drop_index_schema(self):
        t = Table("t", MetaData(), Column("x", Integer), schema="foo")
        i = Index("xyz", t.c.x)
        self.assert_compile(schema.DropIndex(i), "DROP INDEX foo.xyz")

    def test_too_long_index_name(self):

3 Source : test_constraints.py
with Apache License 2.0
from gethue

    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):

3 Source : test_constraints.py
with Apache License 2.0
from gethue

    def test_index_against_text_inline(self):
        metadata = MetaData()
        idx = Index("y", text("some_function(q)"))
        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):

3 Source : test_constraints.py
with Apache License 2.0
from gethue

    def test_index_declaration_inline(self):
        metadata = MetaData()

        t1 = Table(
            "t1",
            metadata,
            Column("x", Integer),
            Column("y", Integer),
            Index("foo", "x", "y"),
        )
        self.assert_compile(
            schema.CreateIndex(list(t1.indexes)[0]),
            "CREATE INDEX foo ON t1 (x, y)",
        )

    def _test_deferrable(self, constraint_factory):

3 Source : test_constraints.py
with Apache License 2.0
from gethue

    def test_render_index_sql_literal(self):
        t, t2 = self._constraint_create_fixture()

        constraint = Index("name", t.c.a + 5)

        self.assert_compile(
            schema.CreateIndex(constraint), "CREATE INDEX name ON tbl (a + 5)"
        )

3 Source : test_metadata.py
with Apache License 2.0
from gethue

    def test_index_info(self):
        ix = Index("x", "a")
        eq_(ix.info, {})

        ix = Index("x", "a", info={"foo": "bar"})
        eq_(ix.info, {"foo": "bar"})

    def test_column_info(self):

3 Source : test_metadata.py
with Apache License 2.0
from gethue

    def test_separate_decl_columns(self):
        m = MetaData()
        t = Table("t", m, Column("x", Integer))
        i = Index("i", t.c.x)
        self._assert_index_col_x(t, i)

    def test_separate_decl_columns_functional(self):

3 Source : test_metadata.py
with Apache License 2.0
from gethue

    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_index_col_x(t, i)

    def test_index_no_cols_private_table_arg(self):

3 Source : test_metadata.py
with Apache License 2.0
from gethue

    def test_index_no_cols_private_table_arg(self):
        m = MetaData()
        t = Table("t", m, Column("x", Integer))
        i = Index("i", _table=t)
        is_(i.table, t)
        eq_(list(i.columns), [])

    def test_index_w_cols_private_table_arg(self):

3 Source : test_metadata.py
with Apache License 2.0
from gethue

    def test_index_w_cols_private_table_arg(self):
        m = MetaData()
        t = Table("t", m, Column("x", Integer))
        i = Index("i", t.c.x, _table=t)
        is_(i.table, t)

        eq_(i.columns, [t.c.x])

    def test_inline_decl_columns(self):

3 Source : test_metadata.py
with Apache License 2.0
from gethue

    def test_inline_decl_columns(self):
        m = MetaData()
        c = Column("x", Integer)
        i = Index("i", c)
        t = Table("t", m, c, i)
        self._assert_index_col_x(t, i)

    def test_inline_decl_columns_functional(self):

3 Source : test_metadata.py
with Apache License 2.0
from gethue

    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_index_col_x(t, i)

    def test_inline_decl_string(self):

3 Source : test_metadata.py
with Apache License 2.0
from gethue

    def test_inline_decl_string(self):
        m = MetaData()
        i = Index("i", "x")
        t = Table("t", m, Column("x", Integer), i)
        self._assert_index_col_x(t, i)

    def test_inline_decl_textonly(self):

3 Source : test_metadata.py
with Apache License 2.0
from gethue

    def test_inline_decl_textonly(self):
        m = MetaData()
        i = Index("i", text("foobar(x)"))
        t = Table("t", m, Column("x", Integer), i)
        self._assert_index_col_x(t, i, columns=False)

    def test_separate_decl_textonly(self):

3 Source : test_metadata.py
with Apache License 2.0
from gethue

    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_index_col_x(t, i, columns=False)

    def test_unnamed_column_exception(self):

See More Examples