drop SQLAlchemy 1.3, Python 3.8

Jenkins issues reveal that SQLAlchemy 1.3's testing provision has
unidentified deficiencies that are causing instability with the
mssql engine.   As provisioning was highly refactored in 1.4, just drop
1.3 support rather than trying to figure out the exact thing that
changed.

Support for SQLAlchemy 1.3, which was EOL as of 2021, is now dropped from
Alembic as of version 1.15.0.

Support for Python 3.8 is dropped as of Alembic 1.15.0.  Python 3.8 is EOL.

Try pytest 8.3 as this seems to be running fine for SQLAlchemy

Change-Id: I06614a6f73d5b1a1ac5b9b04225ecb305f5b35ee

Author: zzzeek

.gitignore

@@ -22,3 +22,4 @@ coverage.xml
 /docs/build/_build/
 /pysqlite_test_schema.db
 *.sqlite3
+.mypy_cache/

alembic/__init__.py

@@ -1,4 +1,4 @@
 from . import context
 from . import op
 
-__version__ = "1.14.2"
+__version__ = "1.15.0"

alembic/autogenerate/compare.py

@@ -216,7 +216,7 @@ def _compare_tables(
                 (inspector),
                 # fmt: on
             )
-            sqla_compat._reflect_table(inspector, t)
+            inspector.reflect_table(t, include_columns=None)
         if autogen_context.run_object_filters(t, tname, "table", True, None):
             modify_table_ops = ops.ModifyTableOps(tname, [], schema=s)
 
@@ -246,7 +246,7 @@ def _compare_tables(
                 _compat_autogen_column_reflect(inspector),
                 # fmt: on
             )
-            sqla_compat._reflect_table(inspector, t)
+            inspector.reflect_table(t, include_columns=None)
         conn_column_info[(s, tname)] = t
 
     for s, tname in sorted(existing_tables, key=lambda x: (x[0] or "", x[1])):
@@ -1067,27 +1067,15 @@ def _compare_server_default(
         return False
 
     if sqla_compat._server_default_is_computed(metadata_default):
-        # return False in case of a computed column as the server
-        # default. Note that DDL for adding or removing "GENERATED AS" from
-        # an existing column is not currently known for any backend.
-        # Once SQLAlchemy can reflect "GENERATED" as the "computed" element,
-        # we would also want to ignore and/or warn for changes vs. the
-        # metadata (or support backend specific DDL if applicable).
-        if not sqla_compat.has_computed_reflection:
-            return False
-
-        else:
-            return (
-                _compare_computed_default(  # type:ignore[func-returns-value]
-                    autogen_context,
-                    alter_column_op,
-                    schema,
-                    tname,
-                    cname,
-                    conn_col,
-                    metadata_col,
-                )
-            )
+        return _compare_computed_default(  # type:ignore[func-returns-value]
+            autogen_context,
+            alter_column_op,
+            schema,
+            tname,
+            cname,
+            conn_col,
+            metadata_col,
+        )
     if sqla_compat._server_default_is_computed(conn_col_default):
         _warn_computed_not_supported(tname, cname)
         return False

alembic/autogenerate/render.py

@@ -28,6 +28,8 @@
 if TYPE_CHECKING:
     from typing import Literal
 
+    from sqlalchemy import Computed
+    from sqlalchemy import Identity
     from sqlalchemy.sql.base import DialectKWArgs
     from sqlalchemy.sql.elements import ColumnElement
     from sqlalchemy.sql.elements import TextClause
@@ -48,8 +50,6 @@
     from alembic.config import Config
     from alembic.operations.ops import MigrationScript
     from alembic.operations.ops import ModifyTableOps
-    from alembic.util.sqla_compat import Computed
-    from alembic.util.sqla_compat import Identity
 
 
 MAX_PYTHON_ARGS = 255
@@ -741,7 +741,7 @@ def _render_column(
                 + [
                     "%s=%s"
                     % (key, _render_potential_expr(val, autogen_context))
-                    for key, val in sqla_compat._column_kwargs(column).items()
+                    for key, val in column.kwargs.items()
                 ]
             )
         ),

alembic/ddl/base.py

@@ -25,6 +25,8 @@
 if TYPE_CHECKING:
     from typing import Any
 
+    from sqlalchemy import Computed
+    from sqlalchemy import Identity
     from sqlalchemy.sql.compiler import Compiled
     from sqlalchemy.sql.compiler import DDLCompiler
     from sqlalchemy.sql.elements import TextClause
@@ -33,8 +35,6 @@
     from sqlalchemy.sql.type_api import TypeEngine
 
     from .impl import DefaultImpl
-    from ..util.sqla_compat import Computed
-    from ..util.sqla_compat import Identity
 
 _ServerDefault = Union["TextClause", "FetchedValue", "Function[Any]", str]
 

alembic/ddl/impl.py

@@ -459,7 +459,9 @@ def bulk_insert(
         if self.as_sql:
             for row in rows:
                 self._exec(
-                    sqla_compat._insert_inline(table).values(
+                    table.insert()
+                    .inline()
+                    .values(
                         **{
                             k: (
                                 sqla_compat._literal_bindparam(
@@ -477,14 +479,10 @@ def bulk_insert(
         else:
             if rows:
                 if multiinsert:
-                    self._exec(
-                        sqla_compat._insert_inline(table), multiparams=rows
-                    )
+                    self._exec(table.insert().inline(), multiparams=rows)
                 else:
                     for row in rows:
-                        self._exec(
-                            sqla_compat._insert_inline(table).values(**row)
-                        )
+                        self._exec(table.insert().inline().values(**row))
 
     def _tokenize_column_type(self, column: Column) -> Params:
         definition: str
@@ -693,7 +691,7 @@ def _compare_identity_default(self, metadata_identity, inspector_identity):
         diff, ignored = _compare_identity_options(
             metadata_identity,
             inspector_identity,
-            sqla_compat.Identity(),
+            schema.Identity(),
             skip={"always"},
         )
 
@@ -874,12 +872,13 @@ def check_dicts(
         set(meta_d).union(insp_d),
     )
     if sqla_compat.identity_has_dialect_kwargs:
+        assert hasattr(default_io, "dialect_kwargs")
         # use only the dialect kwargs in inspector_io since metadata_io
         # can have options for many backends
         check_dicts(
             getattr(metadata_io, "dialect_kwargs", {}),
             getattr(inspector_io, "dialect_kwargs", {}),
-            default_io.dialect_kwargs,  # type: ignore[union-attr]
+            default_io.dialect_kwargs,
             getattr(inspector_io, "dialect_kwargs", {}),
         )
 

alembic/ddl/mysql.py

@@ -23,7 +23,6 @@
 from .impl import DefaultImpl
 from .. import util
 from ..util import sqla_compat
-from ..util.sqla_compat import _is_mariadb
 from ..util.sqla_compat import _is_type_bound
 from ..util.sqla_compat import compiles
 
@@ -475,7 +474,7 @@ def _mysql_drop_constraint(
         # note that SQLAlchemy as of 1.2 does not yet support
         # DROP CONSTRAINT for MySQL/MariaDB, so we implement fully
         # here.
-        if _is_mariadb(compiler.dialect):
+        if compiler.dialect.is_mariadb:  # type: ignore[attr-defined]
             return "ALTER TABLE %s DROP CONSTRAINT %s" % (
                 compiler.preparer.format_table(constraint.table),
                 compiler.preparer.format_constraint(constraint),

alembic/ddl/postgresql.py

@@ -17,8 +17,10 @@
 
 from sqlalchemy import Column
 from sqlalchemy import Float
+from sqlalchemy import Identity
 from sqlalchemy import literal_column
 from sqlalchemy import Numeric
+from sqlalchemy import select
 from sqlalchemy import text
 from sqlalchemy import types as sqltypes
 from sqlalchemy.dialects.postgresql import BIGINT
@@ -143,9 +145,7 @@ def compare_server_default(
         conn = self.connection
         assert conn is not None
         return not conn.scalar(
-            sqla_compat._select(
-                literal_column(conn_col_default) == metadata_default
-            )
+            select(literal_column(conn_col_default) == metadata_default)
         )
 
     def alter_column(  # type:ignore[override]
@@ -586,7 +586,7 @@ def visit_identity_column(
                 )
             else:
                 text += "SET %s " % compiler.get_identity_options(
-                    sqla_compat.Identity(**{attr: getattr(identity, attr)})
+                    Identity(**{attr: getattr(identity, attr)})
                 )
         return text
 

alembic/ddl/sqlite.py

@@ -11,6 +11,7 @@
 from typing import Union
 
 from sqlalchemy import cast
+from sqlalchemy import Computed
 from sqlalchemy import JSON
 from sqlalchemy import schema
 from sqlalchemy import sql
@@ -64,7 +65,7 @@ def requires_recreate_in_batch(
                 ) and isinstance(col.server_default.arg, sql.ClauseElement):
                     return True
                 elif (
-                    isinstance(col.server_default, util.sqla_compat.Computed)
+                    isinstance(col.server_default, Computed)
                     and col.server_default.persisted
                 ):
                     return True

alembic/operations/batch.py

@@ -18,6 +18,7 @@
 from sqlalchemy import MetaData
 from sqlalchemy import PrimaryKeyConstraint
 from sqlalchemy import schema as sql_schema
+from sqlalchemy import select
 from sqlalchemy import Table
 from sqlalchemy import types as sqltypes
 from sqlalchemy.sql.schema import SchemaEventTarget
@@ -31,11 +32,9 @@
 from ..util.sqla_compat import _ensure_scope_for_ddl
 from ..util.sqla_compat import _fk_is_self_referential
 from ..util.sqla_compat import _idx_table_bound_expressions
-from ..util.sqla_compat import _insert_inline
 from ..util.sqla_compat import _is_type_bound
 from ..util.sqla_compat import _remove_column_from_collection
 from ..util.sqla_compat import _resolve_for_variant
-from ..util.sqla_compat import _select
 from ..util.sqla_compat import constraint_name_defined
 from ..util.sqla_compat import constraint_name_string
 
@@ -449,13 +448,15 @@ def _create(self, op_impl: DefaultImpl) -> None:
 
         try:
             op_impl._exec(
-                _insert_inline(self.new_table).from_select(
+                self.new_table.insert()
+                .inline()
+                .from_select(
                     list(
                         k
                         for k, transfer in self.column_transfers.items()
                         if "expr" in transfer
                     ),
-                    _select(
+                    select(
                         *[
                             transfer["expr"]
                             for transfer in self.column_transfers.values()