--- /dev/null
+.. change::
+ :tags: schema, usecase
+ :tickets: 2843
+
+ Added parameters :paramref:`_ddl.CreateTable.if_not_exists`,
+ :paramref:`_ddl.CreateIndex.if_not_exists`,
+ :paramref:`_ddl.DropTable.if_exists` and
+ :paramref:`_ddl.DropIndex.if_exists` to the :class:`_ddl.CreateTable`,
+ :class:`_ddl.DropTable`, :class:`_ddl.CreateIndex` and
+ :class:`_ddl.DropIndex` constructs which result in "IF NOT EXISTS" / "IF
+ EXISTS" DDL being added to the CREATE/DROP. These phrases are not accepted
+ by all databases and the operation will fail on a database that does not
+ support it as there is no similarly compatible fallback within the scope of
+ a single DDL statement. Pull request courtesy Ramon Williams.
\ No newline at end of file
if index_prefix:
text += index_prefix + " "
- text += "INDEX %s ON %s " % (name, table)
+ text += "INDEX "
+ if create.if_not_exists:
+ text += "IF NOT EXISTS "
+ text += "%s ON %s " % (name, table)
length = index.dialect_options[self.dialect.name]["length"]
if length is not None:
def visit_drop_index(self, drop):
index = drop.element
+ text = "\nDROP INDEX "
+ if drop.if_exists:
+ text += "IF EXISTS "
- return "\nDROP INDEX %s ON %s" % (
+ return text + "%s ON %s" % (
self._prepared_index_name(index, include_schema=False),
self.preparer.format_table(index.table),
)
if concurrently:
text += "CONCURRENTLY "
+ if create.if_not_exists:
+ text += "IF NOT EXISTS "
+
text += "%s ON %s " % (
self._prepared_index_name(index, include_schema=False),
preparer.format_table(index.table),
if concurrently:
text += "CONCURRENTLY "
+ if drop.if_exists:
+ text += "IF EXISTS "
+
text += self._prepared_index_name(index, include_schema=True)
return text
text = "CREATE "
if index.unique:
text += "UNIQUE "
- text += "INDEX %s ON %s (%s)" % (
+
+ text += "INDEX "
+
+ if create.if_not_exists:
+ text += "IF NOT EXISTS "
+
+ text += "%s ON %s (%s)" % (
self._prepared_index_name(index, include_schema=True),
preparer.format_table(index.table, use_schema=False),
", ".join(
text = "\nCREATE "
if table._prefixes:
text += " ".join(table._prefixes) + " "
- text += "TABLE " + preparer.format_table(table) + " "
+
+ text += "TABLE "
+ if create.if_not_exists:
+ text += "IF NOT EXISTS "
+
+ text += preparer.format_table(table) + " "
create_table_suffix = self.create_table_suffix(table)
if create_table_suffix:
)
def visit_drop_table(self, drop, **kw):
- return "\nDROP TABLE " + self.preparer.format_table(drop.element)
+ text = "\nDROP TABLE "
+ if drop.if_exists:
+ text += "IF EXISTS "
+ return text + self.preparer.format_table(drop.element)
def visit_drop_view(self, drop, **kw):
return "\nDROP VIEW " + self.preparer.format_table(drop.element)
raise exc.CompileError(
"CREATE INDEX requires that the index have a name"
)
- text += "INDEX %s ON %s (%s)" % (
+
+ text += "INDEX "
+ if create.if_not_exists:
+ text += "IF NOT EXISTS "
+
+ text += "%s ON %s (%s)" % (
self._prepared_index_name(index, include_schema=include_schema),
preparer.format_table(
index.table, use_schema=include_table_schema
raise exc.CompileError(
"DROP INDEX requires that the index have a name"
)
- return "\nDROP INDEX " + self._prepared_index_name(
- index, include_schema=True
- )
+ text = "\nDROP INDEX "
+ if drop.if_exists:
+ text += "IF EXISTS "
+
+ return text + self._prepared_index_name(index, include_schema=True)
def _prepared_index_name(self, index, include_schema=False):
if index.table is not None:
"""
- def __init__(self, element, bind=None):
+ def __init__(
+ self, element, bind=None, if_exists=False, if_not_exists=False
+ ):
self.element = element
self.bind = bind
+ self.if_exists = if_exists
+ self.if_not_exists = if_not_exists
@property
def stringify_dialect(self):
__visit_name__ = "create_table"
def __init__(
- self, element, bind=None, include_foreign_key_constraints=None
+ self,
+ element,
+ bind=None,
+ include_foreign_key_constraints=None,
+ if_not_exists=False,
):
"""Create a :class:`.CreateTable` construct.
.. versionadded:: 1.0.0
+ :param if_not_exists: if True, an IF NOT EXISTS operator will be
+ applied to the construct.
+
+ .. versionadded:: 1.4.0b2
+
"""
- super(CreateTable, self).__init__(element, bind=bind)
+ super(CreateTable, self).__init__(
+ element, bind=bind, if_not_exists=if_not_exists
+ )
self.columns = [CreateColumn(column) for column in element.columns]
self.include_foreign_key_constraints = include_foreign_key_constraints
__visit_name__ = "drop_table"
+ def __init__(self, element, bind=None, if_exists=False):
+ """Create a :class:`.DropTable` construct.
+
+ :param element: a :class:`_schema.Table` that's the subject
+ of the DROP.
+ :param on: See the description for 'on' in :class:`.DDL`.
+ :param bind: See the description for 'bind' in :class:`.DDL`.
+ :param if_exists: if True, an IF EXISTS operator will be applied to the
+ construct.
+
+ .. versionadded:: 1.4.0b2
+
+ """
+ super(DropTable, self).__init__(
+ element, bind=bind, if_exists=if_exists
+ )
+
class CreateSequence(_CreateDropBase):
"""Represent a CREATE SEQUENCE statement."""
__visit_name__ = "create_index"
+ def __init__(self, element, bind=None, if_not_exists=False):
+ """Create a :class:`.Createindex` construct.
+
+ :param element: a :class:`_schema.Index` that's the subject
+ of the CREATE.
+ :param on: See the description for 'on' in :class:`.DDL`.
+ :param bind: See the description for 'bind' in :class:`.DDL`.
+ :param if_not_exists: if True, an IF NOT EXISTS operator will be
+ applied to the construct.
+
+ .. versionadded:: 1.4.0b2
+
+ """
+ super(CreateIndex, self).__init__(
+ element, bind=bind, if_not_exists=if_not_exists
+ )
+
class DropIndex(_CreateDropBase):
"""Represent a DROP INDEX statement."""
__visit_name__ = "drop_index"
+ def __init__(self, element, bind=None, if_exists=False):
+ """Create a :class:`.DropIndex` construct.
+
+ :param element: a :class:`_schema.Index` that's the subject
+ of the DROP.
+ :param on: See the description for 'on' in :class:`.DDL`.
+ :param bind: See the description for 'bind' in :class:`.DDL`.
+ :param if_exists: if True, an IF EXISTS operator will be applied to the
+ construct.
+
+ .. versionadded:: 1.4.0b2
+
+ """
+ super(DropIndex, self).__init__(
+ element, bind=bind, if_exists=if_exists
+ )
+
class AddConstraint(_CreateDropBase):
"""Represent an ALTER TABLE ADD CONSTRAINT statement."""
return exclusions.open()
+ @property
+ def table_ddl_if_exists(self):
+ """target platform supports IF NOT EXISTS / IF EXISTS for tables."""
+
+ return exclusions.closed()
+
+ @property
+ def index_ddl_if_exists(self):
+ """target platform supports IF NOT EXISTS / IF EXISTS for indexes."""
+
+ return exclusions.closed()
+
@property
def foreign_keys(self):
"""Target database must support foreign keys."""
from .. import fixtures
from .. import util
from ..assertions import eq_
+from ..assertions import is_false
+from ..assertions import is_true
from ..config import requirements
from ... import Column
+from ... import Index
from ... import inspect
from ... import Integer
from ... import schema
Column("_data", String(50)),
)
+ def _table_index_fixture(self, schema=None):
+ table = self._simple_fixture(schema=schema)
+ idx = Index("test_index", table.c.data)
+ return table, idx
+
def _simple_roundtrip(self, table):
with config.db.begin() as conn:
conn.execute(table.insert().values((1, "some data")))
inspect(connection).get_table_comment("test_table"), {"text": None}
)
+ @requirements.table_ddl_if_exists
+ @util.provide_metadata
+ def test_create_table_if_not_exists(self, connection):
+ table = self._simple_fixture()
+
+ connection.execute(schema.CreateTable(table, if_not_exists=True))
+
+ is_true(inspect(connection).has_table("test_table"))
+ connection.execute(schema.CreateTable(table, if_not_exists=True))
+
+ @requirements.index_ddl_if_exists
+ @util.provide_metadata
+ def test_create_index_if_not_exists(self, connection):
+ table, idx = self._table_index_fixture()
+
+ connection.execute(schema.CreateTable(table, if_not_exists=True))
+ is_true(inspect(connection).has_table("test_table"))
+ is_false(
+ "test_index"
+ in [
+ ix["name"]
+ for ix in inspect(connection).get_indexes("test_table")
+ ]
+ )
+
+ connection.execute(schema.CreateIndex(idx, if_not_exists=True))
+
+ is_true(
+ "test_index"
+ in [
+ ix["name"]
+ for ix in inspect(connection).get_indexes("test_table")
+ ]
+ )
+
+ connection.execute(schema.CreateIndex(idx, if_not_exists=True))
+
+ @requirements.table_ddl_if_exists
+ @util.provide_metadata
+ def test_drop_table_if_exists(self, connection):
+ table = self._simple_fixture()
+
+ table.create(connection)
+
+ is_true(inspect(connection).has_table("test_table"))
+
+ connection.execute(schema.DropTable(table, if_exists=True))
+
+ is_false(inspect(connection).has_table("test_table"))
+
+ connection.execute(schema.DropTable(table, if_exists=True))
+
+ @requirements.index_ddl_if_exists
+ @util.provide_metadata
+ def test_drop_index_if_exists(self, connection):
+ table, idx = self._table_index_fixture()
+
+ table.create(connection)
+
+ is_true(
+ "test_index"
+ in [
+ ix["name"]
+ for ix in inspect(connection).get_indexes("test_table")
+ ]
+ )
+
+ connection.execute(schema.DropIndex(idx, if_exists=True))
+
+ is_false(
+ "test_index"
+ in [
+ ix["name"]
+ for ix in inspect(connection).get_indexes("test_table")
+ ]
+ )
+
+ connection.execute(schema.DropIndex(idx, if_exists=True))
+
class FutureTableDDLTest(fixtures.FutureEngineMixin, TableDDLTest):
pass
return skip_if(no_support("sqlite", "not supported by database"))
+ @property
+ def table_ddl_if_exists(self):
+ """target platform supports IF NOT EXISTS / IF EXISTS for tables."""
+
+ return only_on(["postgresql", "mysql", "mariadb", "sqlite"])
+
+ @property
+ def index_ddl_if_exists(self):
+ """target platform supports IF NOT EXISTS / IF EXISTS for indexes."""
+
+ # mariadb but not mysql, tested up to mysql 8
+ return only_on(["postgresql", "mariadb", "sqlite"])
+
@property
def on_update_cascade(self):
"""target database must support ON UPDATE..CASCADE behavior in
from sqlalchemy import Float
from sqlalchemy import ForeignKey
from sqlalchemy import func
+from sqlalchemy import Index
from sqlalchemy import Integer
from sqlalchemy import intersect
from sqlalchemy import join
"PRIMARY KEY (a, b))",
)
+ def test_create_table_exists(self):
+ m = MetaData()
+ t1 = Table("t1", m, Column("q", Integer))
+ self.assert_compile(
+ schema.CreateTable(t1, if_not_exists=True),
+ "CREATE TABLE IF NOT EXISTS t1 (q INTEGER)",
+ )
+
+ def test_drop_table_exists(self):
+ m = MetaData()
+ t1 = Table("t1", m, Column("q", Integer))
+ self.assert_compile(
+ schema.DropTable(t1, if_exists=True),
+ "DROP TABLE IF EXISTS t1",
+ )
+
+ def test_create_index_exists(self):
+ m = MetaData()
+ t1 = Table("t1", m, Column("q", Integer))
+ idx = Index("my_idx", t1.c.q)
+ self.assert_compile(
+ schema.CreateIndex(idx, if_not_exists=True),
+ "CREATE INDEX IF NOT EXISTS my_idx ON t1 (q)",
+ )
+
+ def test_drop_index_exists(self):
+ m = MetaData()
+ t1 = Table("t1", m, Column("q", Integer))
+ idx = Index("my_idx", t1.c.q)
+ self.assert_compile(
+ schema.DropIndex(idx, if_exists=True),
+ "DROP INDEX IF EXISTS my_idx",
+ )
+
def test_create_table_suffix(self):
class MyDialect(default.DefaultDialect):
class MyCompiler(compiler.DDLCompiler):
projects / thirdparty / sqlalchemy / sqlalchemy.git / commitdiff
