Refactoring/618 resolve remaining deprecation warnings (#619)

* Activate all warnings again (except for ignores)

* Resolve failing tests where DML used and needs engine.begin()

* Modify documentation for related changes

Author: ArBridgeman

README.rst

@@ -95,8 +95,8 @@ Using SQLAlchemy with EXASOL DB
 
 .. code-block:: python
 
-	from sqlalchemy import create_engine
-	url = "exa+websocket://A_USER:[email protected]:1234/my_schema?CONNECTIONLCALL=en_US.UTF-8"
+    from sqlalchemy import create_engine
+    url = "exa+websocket://A_USER:[email protected]:1234/my_schema?CONNECTIONLCALL=en_US.UTF-8"
     e = create_engine(url)
     query = "select 42 from dual"
     with engine.connect() as con:
@@ -109,6 +109,12 @@ Examples:
     from sqlalchemy import create_engine
 
     engine = create_engine("exa+websocket://sys:[email protected]:8888")
+
+    # don't rely on autocommit for DML and DDL
+    with engine.begin() as con:
+        ...
+
+    # for non-DML or non-DDL queries
     with engine.connect() as con:
         ...
 
@@ -132,8 +138,8 @@ Examples:
 
 .. code-block:: python
 
-	from sqlalchemy import create_engine
-	url = "exa+pyodbc://A_USER:[email protected]:1234/my_schema?CONNECTIONLCALL=en_US.UTF-8&driver=EXAODBC"
+    from sqlalchemy import create_engine
+    url = "exa+pyodbc://A_USER:[email protected]:1234/my_schema?CONNECTIONLCALL=en_US.UTF-8&driver=EXAODBC"
     e = create_engine(url)
     query = "select 42 from dual"
     with engine.connect() as con:
@@ -143,8 +149,8 @@ Examples:
 
 .. code-block:: python
 
-	from sqlalchemy import create_engine
-	url = "exa+turbodbc://A_USER:[email protected]:1234/my_schema?CONNECTIONLCALL=en_US.UTF-8&driver=EXAODBC"
+    from sqlalchemy import create_engine
+    url = "exa+turbodbc://A_USER:[email protected]:1234/my_schema?CONNECTIONLCALL=en_US.UTF-8&driver=EXAODBC"
     e = create_engine(url)
     query = "select 42 from dual"
     with engine.connect() as con:
@@ -166,7 +172,7 @@ General Notes
 
 .. _developer guide: https://github.com/exasol/sqlalchemy-exasol/blob/master/doc/developer_guide/developer_guide.rst
 .. _odbc_driver: https://docs.exasol.com/db/latest/connect_exasol/drivers/odbc/odbc_linux.htm
-.. _test_drive: https://cloud.exasol.com/signup 
+.. _test_drive: https://cloud.exasol.com/signup
 .. _test_docker_image: https://github.com/exasol/docker-db
 
 Known Issues
@@ -177,5 +183,3 @@ Known Issues
 Development & Testing
 ---------------------
 See `developer guide`_
-
-

doc/changes/unreleased.md

@@ -13,6 +13,7 @@ This allows us to use the latest dependencies, which do not have open vulnerabil
 - #614: Altered params input into `Connection.execute()` to be handled properly with `dict`
 - #616: Altered usage of MetaData which was binding to a connection to instead bind in the needed object or function
 - #617: Enacted warning for the deprecation of the `autoload` parameter and requirement of `bind`
+- #618: Switched DML & DDL executions from `engine.connect()` to `engine.begin()` usage
 
 ## Internal
 

pyproject.toml

@@ -92,12 +92,8 @@ exasol-toolbox = "^1.9.0"
 [tool.pytest.ini_options]
 addopts = "--tb native -v -r fxX"
 filterwarnings = [
-# before end of #413, switch this from a text specific issue to a general error on a warning to ensure known deprecation issues have been resolved
-"error:.*Passing a string.*",
-"error:.* a single dictionary.*",
-"error:.*The MetaData.bind argument.*",
-"error:.*The autoload parameter.*",
-"error:.*schema methods that invoke SQL against.*",
+"error",
+"ignore::pytest.PytestUnraisableExceptionWarning",
 # this is used for turbodbc and pyodbc as historically we'd like to remove them.
 # thus far, it seems like this is not a strict requirement for the migration,
 # so we will ignore them.

test/integration/exasol/test_exasol.py

@@ -47,21 +47,27 @@ def define_tables(cls, metadata):
     def test_insert_with_default_value(self):
         t = self.tables.t
 
-        config.db.execute(t.insert(), [{"name": "Henrik"}])
-        (_, _, active_from) = config.db.execute(t.select()).fetchone()
+        with config.db.begin() as conn:
+            conn.execute(t.insert(), [{"name": "Henrik"}])
+
+        with config.db.connect() as conn:
+            (_, _, active_from) = conn.execute(t.select()).fetchone()
+
         assert active_from == datetime.date(1900, 1, 1)
 
 
 class KeywordTest(fixtures.TablesTest):
     __backend__ = True
 
     def test_keywords(self):
-        keywords = config.db.execute(
-            sql.text(
-                "select distinct(lower(keyword)) as keyword "
-                + "from SYS.EXA_SQL_KEYWORDS where reserved = True order by keyword"
-            )
-        ).fetchall()
+        with config.db.connect() as conn:
+            keywords = conn.execute(
+                sql.text(
+                    "select distinct(lower(keyword)) as keyword "
+                    + "from SYS.EXA_SQL_KEYWORDS where reserved = True order by keyword"
+                )
+            ).fetchall()
+
         db_keywords = {k[0] for k in keywords}
 
         assert db_keywords >= RESERVED_WORDS
@@ -108,13 +114,15 @@ def test_alter_table_distribute_by(self):
         dbc = DistributeByConstraint("a", "b")
         self.tables.t.append_constraint(dbc)
 
-        config.db.execute(DropConstraint(dbc))
+        with config.db.begin() as conn:
+            conn.execute(DropConstraint(dbc))
 
         insp = inspect(testing.db)
         for c in insp.get_columns("t"):
             assert c["is_distribution_key"] == False
 
-        config.db.execute(AddConstraint(dbc))
+        with config.db.begin() as conn:
+            conn.execute(AddConstraint(dbc))
 
         insp = inspect(testing.db)
         for c in insp.get_columns("t"):

test/integration/exasol/test_regression.py

@@ -31,8 +31,7 @@ class TranslateMap(fixtures.TestBase):
     def setup_class(cls):
         cls.table_name = "my_table"
         cls.tenant_schema_name = "tenant_schema"
-        engine = config.db
-        with config.db.connect() as conn:
+        with config.db.begin() as conn:
             conn.execute(CreateSchema(cls.tenant_schema_name))
             metadata = MetaData()
             Table(
@@ -42,11 +41,11 @@ def setup_class(cls):
                 Column("name", String(1000), nullable=False),
                 schema=cls.tenant_schema_name,
             )
-            metadata.create_all(engine)
+            metadata.create_all(conn)
 
     @classmethod
     def teardown_class(cls):
-        with config.db.connect() as conn:
+        with config.db.begin() as conn:
             conn.execute(DropSchema(cls.tenant_schema_name, cascade=True))
 
     def test_use_schema_translate_map_in_get_last_row_id(self):
@@ -62,7 +61,7 @@ def test_use_schema_translate_map_in_get_last_row_id(self):
             schema=schema_name,
         )
         engine = create_engine(config.db.url, execution_options=options)
-        with engine.connect() as conn:
+        with engine.begin() as conn:
             conn.execute(my_table.insert().values(name="John Doe"))
 
 
@@ -80,8 +79,7 @@ class Introspection(fixtures.TestBase):
     @classmethod
     def setup_class(cls):
         def _create_tables(schema, tables):
-            engine = config.db
-            with engine.connect():
+            with config.db.begin() as conn:
                 metadata = MetaData()
                 for name in tables:
                     Table(
@@ -91,11 +89,10 @@ def _create_tables(schema, tables):
                         Column("random_field", String(1000)),
                         schema=schema,
                     )
-                metadata.create_all(engine)
+                metadata.create_all(conn)
 
         def _create_views(schema, views):
-            engine = config.db
-            with engine.connect() as conn:
+            with config.db.begin() as conn:
                 for name in views:
                     conn.execute(
                         sql.text(
@@ -112,17 +109,15 @@ def _create_views(schema, views):
 
     @classmethod
     def teardown_class(cls):
-        engine = config.db
-
         def _drop_tables(schema):
             metadata = MetaData(schema=schema)
-            with engine.connect() as conn:
+            with config.db.begin() as conn:
                 metadata.reflect(bind=conn)
                 to_be_deleted = [metadata.tables[name] for name in metadata.tables]
-                metadata.drop_all(engine, to_be_deleted)
+                metadata.drop_all(conn, to_be_deleted)
 
         def _drop_views(schema, views):
-            with engine.connect() as conn:
+            with config.db.begin() as conn:
                 for name in views:
                     conn.execute(sql.text(f"DROP VIEW {schema}.{name};"))
 
@@ -143,4 +138,4 @@ def test_introspection_of_views_works_with(self, pool_type):
         engine = create_engine(config.db.url, poolclass=pool_type)
         inspector = inspect(engine)
         tables = inspector.get_view_names(schema=self.schema)
-        assert expected == tables
+        assert tables == expected

test/integration/exasol/test_update.py

@@ -1,10 +1,10 @@
 import pytest
 from sqlalchemy import *
-from sqlalchemy import testing
 from sqlalchemy.testing import (
     eq_,
     fixtures,
 )
+from sqlalchemy.testing.fixtures import config
 from sqlalchemy.testing.schema import (
     Column,
     Table,
@@ -82,30 +82,33 @@ def fixtures(cls):
 
 
 @pytest.mark.skipif(
-    testing.db.dialect.driver == "turbodbc", reason="not supported by turbodbc"
+    config.db.dialect.driver == "turbodbc", reason="not supported by turbodbc"
 )
 class UpdateTest(_UpdateTestBase, fixtures.TablesTest):
     __backend__ = True
 
     def test_update_simple(self):
         """test simple update and assert that exasol returns the right rowcount"""
         users = self.tables[f"{self.schema}.users"]
-        result = testing.db.execute(
-            users.update().values(name="peter").where(users.c.id == 10)
-        )
-        expected = [(7, "jack"), (8, "ed"), (9, "fred"), (10, "peter")]
+
+        with config.db.begin() as conn:
+            result = conn.execute(
+                users.update().values(name="peter").where(users.c.id == 10)
+            )
+
         assert result.rowcount == 1
-        self._assert_users(users, expected)
+        self._assert_users(users, [(7, "jack"), (8, "ed"), (9, "fred"), (10, "peter")])
 
     def test_update_simple_multiple_rows_rowcount(self):
         """test simple update and assert that exasol returns the right rowcount"""
         users = self.tables[f"{self.schema}.users"]
-        result = testing.db.execute(
-            users.update().values(name="peter").where(users.c.id >= 9)
-        )
-        expected = [(7, "jack"), (8, "ed"), (9, "peter"), (10, "peter")]
+
+        with config.db.begin() as conn:
+            result = conn.execute(
+                users.update().values(name="peter").where(users.c.id >= 9)
+            )
         assert result.rowcount == 2
-        self._assert_users(users, expected)
+        self._assert_users(users, [(7, "jack"), (8, "ed"), (9, "peter"), (10, "peter")])
 
     def test_update_executemany(self):
         """test that update with executemany work as well, but rowcount
@@ -123,8 +126,8 @@ def test_update_executemany(self):
             {"oldname": "fred", "newname": "fred2"},
         ]
 
-        result = testing.db.execute(stmt, values)
-        expected = [(7, "jack2"), (8, "ed"), (9, "fred2"), (10, "chuck")]
+        with config.db.begin() as conn:
+            result = conn.execute(stmt, values)
 
         # Depending on the dialect it either reports that the affected rows information
         # is not available (-1) or it reports the actual number of updated/affected rows(2)
@@ -133,12 +136,15 @@ def test_update_executemany(self):
         expected_rowcount = [expected_rowcount_odbc, expected_rowcount_wss]
         assert result.rowcount in expected_rowcount
 
-        self._assert_users(users, expected)
+        self._assert_users(
+            users, [(7, "jack2"), (8, "ed"), (9, "fred2"), (10, "chuck")]
+        )
 
     def _assert_addresses(self, addresses, expected):
         stmt = addresses.select().order_by(addresses.c.id)
-        eq_(testing.db.execute(stmt).fetchall(), expected)
+        eq_(config.db.execute(stmt).fetchall(), expected)
 
     def _assert_users(self, users, expected):
         stmt = users.select().order_by(users.c.id)
-        eq_(testing.db.execute(stmt).fetchall(), expected)
+        with config.db.connect() as conn:
+            eq_(conn.execute(stmt).fetchall(), expected)