From: Mike Bayer Date: Mon, 14 Dec 2020 15:36:57 +0000 (-0500) Subject: Emit deprecation warning for general DDLElement.bind argument X-Git-Tag: rel_1_4_0b2~100 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=6eaa1bea221fdcb5943a037c31951d8ef103e092;p=thirdparty%2Fsqlalchemy%2Fsqlalchemy.git Emit deprecation warning for general DDLElement.bind argument Change-Id: I8ab1fd98340cb30aa43075508b3a0b9feffa290c --- diff --git a/lib/sqlalchemy/sql/ddl.py b/lib/sqlalchemy/sql/ddl.py index a592419f41..d471f29d55 100644 --- a/lib/sqlalchemy/sql/ddl.py +++ b/lib/sqlalchemy/sql/ddl.py @@ -79,7 +79,7 @@ class DDLElement(roles.DDLRole, Executable, _DDLCompiles): ) @util.deprecated_20( - ":meth:`.DDL.execute`", + ":meth:`.DDLElement.execute`", alternative="All statement execution in SQLAlchemy 2.0 is performed " "by the :meth:`_engine.Connection.execute` method of " ":class:`_engine.Connection`, " @@ -369,11 +369,27 @@ class _CreateDropBase(DDLElement): """ + @util.deprecated_params( + bind=( + "2.0", + "The :paramref:`_ddl.DDLElement.bind` argument is " + "deprecated and " + "will be removed in SQLAlchemy 2.0.", + ), + ) def __init__( - self, element, bind=None, if_exists=False, if_not_exists=False + self, + element, + bind=None, + if_exists=False, + if_not_exists=False, + _legacy_bind=None, ): self.element = element - self.bind = bind + if bind: + self.bind = bind + elif _legacy_bind: + self.bind = _legacy_bind self.if_exists = if_exists self.if_not_exists = if_not_exists @@ -430,6 +446,13 @@ class CreateTable(_CreateDropBase): __visit_name__ = "create_table" + @util.deprecated_params( + bind=( + "2.0", + "The :paramref:`_ddl.CreateTable.bind` argument is deprecated and " + "will be removed in SQLAlchemy 2.0.", + ), + ) def __init__( self, element, @@ -457,7 +480,7 @@ class CreateTable(_CreateDropBase): """ super(CreateTable, self).__init__( - element, bind=bind, if_not_exists=if_not_exists + element, _legacy_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 @@ -588,6 +611,14 @@ class DropTable(_CreateDropBase): __visit_name__ = "drop_table" + @util.deprecated_params( + bind=( + "2.0", + "The :paramref:`_ddl.DropTable.bind` argument is " + "deprecated and " + "will be removed in SQLAlchemy 2.0.", + ), + ) def __init__(self, element, bind=None, if_exists=False): """Create a :class:`.DropTable` construct. @@ -602,7 +633,7 @@ class DropTable(_CreateDropBase): """ super(DropTable, self).__init__( - element, bind=bind, if_exists=if_exists + element, _legacy_bind=bind, if_exists=if_exists ) @@ -623,6 +654,14 @@ class CreateIndex(_CreateDropBase): __visit_name__ = "create_index" + @util.deprecated_params( + bind=( + "2.0", + "The :paramref:`_ddl.CreateIndex.bind` argument is " + "deprecated and " + "will be removed in SQLAlchemy 2.0.", + ), + ) def __init__(self, element, bind=None, if_not_exists=False): """Create a :class:`.Createindex` construct. @@ -637,7 +676,7 @@ class CreateIndex(_CreateDropBase): """ super(CreateIndex, self).__init__( - element, bind=bind, if_not_exists=if_not_exists + element, _legacy_bind=bind, if_not_exists=if_not_exists ) @@ -646,6 +685,14 @@ class DropIndex(_CreateDropBase): __visit_name__ = "drop_index" + @util.deprecated_params( + bind=( + "2.0", + "The :paramref:`_ddl.DropIndex.bind` argument is " + "deprecated and " + "will be removed in SQLAlchemy 2.0.", + ), + ) def __init__(self, element, bind=None, if_exists=False): """Create a :class:`.DropIndex` construct. @@ -660,7 +707,7 @@ class DropIndex(_CreateDropBase): """ super(DropIndex, self).__init__( - element, bind=bind, if_exists=if_exists + element, _legacy_bind=bind, if_exists=if_exists ) diff --git a/test/engine/test_deprecations.py b/test/engine/test_deprecations.py index 6acc2967d8..4ca081be2e 100644 --- a/test/engine/test_deprecations.py +++ b/test/engine/test_deprecations.py @@ -1648,7 +1648,7 @@ class DDLExecutionTest(fixtures.TestBase): ddl = DDL("SELECT 1") eng_msg = r"The Engine.execute\(\) method is considered legacy" - ddl_msg = r"The DDL.execute\(\) method is considered legacy" + ddl_msg = r"The DDLElement.execute\(\) method is considered legacy" for spec in ( (engine.execute, ddl, eng_msg), (engine.execute, ddl, table, eng_msg), diff --git a/test/sql/test_deprecations.py b/test/sql/test_deprecations.py index e082cf55d0..acc12a5feb 100644 --- a/test/sql/test_deprecations.py +++ b/test/sql/test_deprecations.py @@ -22,6 +22,7 @@ from sqlalchemy import literal_column from sqlalchemy import MetaData from sqlalchemy import null from sqlalchemy import or_ +from sqlalchemy import schema from sqlalchemy import select from sqlalchemy import Sequence from sqlalchemy import sql @@ -49,6 +50,7 @@ from sqlalchemy.testing import eq_ from sqlalchemy.testing import fixtures from sqlalchemy.testing import in_ from sqlalchemy.testing import is_ +from sqlalchemy.testing import is_false from sqlalchemy.testing import is_true from sqlalchemy.testing import mock from sqlalchemy.testing import not_in @@ -2569,3 +2571,121 @@ class LegacySequenceExecTest(fixtures.TestBase): r"The Engine.scalar\(\) method is considered legacy" ): self._assert_seq_result(testing.db.scalar(select(s.next_value()))) + + +class DDLDeprecatedBindTest(fixtures.TestBase): + def teardown(self): + with testing.db.begin() as conn: + if inspect(conn).has_table("foo"): + conn.execute(schema.DropTable(table("foo"))) + + def test_bind_ddl_deprecated(self, connection): + with testing.expect_deprecated_20( + "The DDL.bind argument is deprecated" + ): + ddl = schema.DDL("create table foo(id integer)", bind=connection) + + with testing.expect_deprecated_20( + r"The DDLElement.execute\(\) method is considered legacy" + ): + ddl.execute() + + def test_bind_create_table_deprecated(self, connection): + t1 = Table("foo", MetaData(), Column("id", Integer)) + + with testing.expect_deprecated_20( + "The CreateTable.bind argument is deprecated" + ): + ddl = schema.CreateTable(t1, bind=connection) + + with testing.expect_deprecated_20( + r"The DDLElement.execute\(\) method is considered legacy" + ): + ddl.execute() + + is_true(inspect(connection).has_table("foo")) + + def test_bind_create_index_deprecated(self, connection): + t1 = Table("foo", MetaData(), Column("id", Integer)) + t1.create(connection) + + idx = schema.Index("foo_idx", t1.c.id) + + with testing.expect_deprecated_20( + "The CreateIndex.bind argument is deprecated" + ): + ddl = schema.CreateIndex(idx, bind=connection) + + with testing.expect_deprecated_20( + r"The DDLElement.execute\(\) method is considered legacy" + ): + ddl.execute() + + is_true( + "foo_idx" + in [ix["name"] for ix in inspect(connection).get_indexes("foo")] + ) + + def test_bind_drop_table_deprecated(self, connection): + t1 = Table("foo", MetaData(), Column("id", Integer)) + + t1.create(connection) + + with testing.expect_deprecated_20( + "The DropTable.bind argument is deprecated" + ): + ddl = schema.DropTable(t1, bind=connection) + + with testing.expect_deprecated_20( + r"The DDLElement.execute\(\) method is considered legacy" + ): + ddl.execute() + + is_false(inspect(connection).has_table("foo")) + + def test_bind_drop_index_deprecated(self, connection): + t1 = Table("foo", MetaData(), Column("id", Integer)) + idx = schema.Index("foo_idx", t1.c.id) + t1.create(connection) + + is_true( + "foo_idx" + in [ix["name"] for ix in inspect(connection).get_indexes("foo")] + ) + + with testing.expect_deprecated_20( + "The DropIndex.bind argument is deprecated" + ): + ddl = schema.DropIndex(idx, bind=connection) + + with testing.expect_deprecated_20( + r"The DDLElement.execute\(\) method is considered legacy" + ): + ddl.execute() + + is_false( + "foo_idx" + in [ix["name"] for ix in inspect(connection).get_indexes("foo")] + ) + + @testing.combinations( + (schema.AddConstraint,), + (schema.DropConstraint,), + (schema.CreateSequence,), + (schema.DropSequence,), + (schema.CreateSchema,), + (schema.DropSchema,), + (schema.SetTableComment,), + (schema.DropTableComment,), + (schema.SetColumnComment,), + (schema.DropColumnComment,), + ) + def test_bind_other_constructs(self, const): + m1 = mock.Mock() + + with testing.expect_deprecated_20( + "The DDLElement.bind argument is deprecated" + ): + c1 = const(m1, bind=testing.db) + + is_(c1.bind, testing.db)