alembic 1.12.1__py3-none-any.whl → 1.13.1__py3-none-any.whl

alembic/ddl/postgresql.py

@@ -1,3 +1,6 @@
+# mypy: allow-untyped-defs, allow-incomplete-defs, allow-untyped-calls
+# mypy: no-warn-return-any, allow-any-generics
+
 from __future__ import annotations
 
 import logging
@@ -21,10 +24,8 @@ from sqlalchemy.dialects.postgresql import BIGINT
 from sqlalchemy.dialects.postgresql import ExcludeConstraint
 from sqlalchemy.dialects.postgresql import INTEGER
 from sqlalchemy.schema import CreateIndex
-from sqlalchemy.sql import operators
 from sqlalchemy.sql.elements import ColumnClause
 from sqlalchemy.sql.elements import TextClause
-from sqlalchemy.sql.elements import UnaryExpression
 from sqlalchemy.sql.functions import FunctionElement
 from sqlalchemy.types import NULLTYPE
 
@@ -32,12 +33,12 @@ from .base import alter_column
 from .base import alter_table
 from .base import AlterColumn
 from .base import ColumnComment
-from .base import compiles
 from .base import format_column_name
 from .base import format_table_name
 from .base import format_type
 from .base import IdentityColumnDefault
 from .base import RenameTable
+from .impl import ComparisonResult
 from .impl import DefaultImpl
 from .. import util
 from ..autogenerate import render
@@ -46,6 +47,7 @@ from ..operations import schemaobj
 from ..operations.base import BatchOperations
 from ..operations.base import Operations
 from ..util import sqla_compat
+from ..util.sqla_compat import compiles
 
 if TYPE_CHECKING:
     from typing import Literal
@@ -137,7 +139,9 @@ class PostgresqlImpl(DefaultImpl):
             metadata_default = literal_column(metadata_default)
 
         # run a real compare against the server
-        return not self.connection.scalar(
+        conn = self.connection
+        assert conn is not None
+        return not conn.scalar(
             sqla_compat._select(
                 literal_column(conn_col_default) == metadata_default
             )
@@ -252,62 +256,60 @@ class PostgresqlImpl(DefaultImpl):
         if not sqla_compat.sqla_2:
             self._skip_functional_indexes(metadata_indexes, conn_indexes)
 
-    def _cleanup_index_expr(
-        self, index: Index, expr: str, remove_suffix: str
-    ) -> str:
-        # start = expr
+    # pg behavior regarding modifiers
+    # | # | compiled sql     | returned sql     | regexp. group is removed |
+    # | - | ---------------- | -----------------| ------------------------ |
+    # | 1 | nulls first      | nulls first      | -                        |
+    # | 2 | nulls last       |                  | (?<! desc)( nulls last)$ |
+    # | 3 | asc              |                  | ( asc)$                  |
+    # | 4 | asc nulls first  | nulls first      | ( asc) nulls first$      |
+    # | 5 | asc nulls last   |                  | ( asc nulls last)$       |
+    # | 6 | desc             | desc             | -                        |
+    # | 7 | desc nulls first | desc             | desc( nulls first)$      |
+    # | 8 | desc nulls last  | desc nulls last  | -                        |
+    _default_modifiers_re = (  # order of case 2 and 5 matters
+        re.compile("( asc nulls last)$"),  # case 5
+        re.compile("(?<! desc)( nulls last)$"),  # case 2
+        re.compile("( asc)$"),  # case 3
+        re.compile("( asc) nulls first$"),  # case 4
+        re.compile(" desc( nulls first)$"),  # case 7
+    )
+
+    def _cleanup_index_expr(self, index: Index, expr: str) -> str:
         expr = expr.lower().replace('"', "").replace("'", "")
         if index.table is not None:
             # should not be needed, since include_table=False is in compile
             expr = expr.replace(f"{index.table.name.lower()}.", "")
 
-        while expr and expr[0] == "(" and expr[-1] == ")":
-            expr = expr[1:-1]
         if "::" in expr:
             # strip :: cast. types can have spaces in them
             expr = re.sub(r"(::[\w ]+\w)", "", expr)
 
-        if remove_suffix and expr.endswith(remove_suffix):
-            expr = expr[: -len(remove_suffix)]
-
-        # print(f"START: {start} END: {expr}")
-        return expr
+        while expr and expr[0] == "(" and expr[-1] == ")":
+            expr = expr[1:-1]
 
-    def _default_modifiers(self, exp: ClauseElement) -> str:
-        to_remove = ""
-        while isinstance(exp, UnaryExpression):
-            if exp.modifier is None:
-                exp = exp.element
-            else:
-                op = exp.modifier
-                if isinstance(exp.element, UnaryExpression):
-                    inner_op = exp.element.modifier
-                else:
-                    inner_op = None
-                if inner_op is None:
-                    if op == operators.asc_op:
-                        # default is asc
-                        to_remove = " asc"
-                    elif op == operators.nullslast_op:
-                        # default is nulls last
-                        to_remove = " nulls last"
-                else:
-                    if (
-                        inner_op == operators.asc_op
-                        and op == operators.nullslast_op
-                    ):
-                        # default is asc nulls last
-                        to_remove = " asc nulls last"
-                    elif (
-                        inner_op == operators.desc_op
-                        and op == operators.nullsfirst_op
-                    ):
-                        # default for desc is nulls first
-                        to_remove = " nulls first"
+        # NOTE: when parsing the connection expression this cleanup could
+        # be skipped
+        for rs in self._default_modifiers_re:
+            if match := rs.search(expr):
+                start, end = match.span(1)
+                expr = expr[:start] + expr[end:]
                 break
-        return to_remove
 
-    def _dialect_sig(
+        while expr and expr[0] == "(" and expr[-1] == ")":
+            expr = expr[1:-1]
+
+        # strip casts
+        cast_re = re.compile(r"cast\s*\(")
+        if cast_re.match(expr):
+            expr = cast_re.sub("", expr)
+            # remove the as type
+            expr = re.sub(r"as\s+[^)]+\)", "", expr)
+        # remove spaces
+        expr = expr.replace(" ", "")
+        return expr
+
+    def _dialect_options(
         self, item: Union[Index, UniqueConstraint]
     ) -> Tuple[Any, ...]:
         # only the positive case is returned by sqlalchemy reflection so
@@ -316,25 +318,93 @@ class PostgresqlImpl(DefaultImpl):
             return ("nulls_not_distinct",)
         return ()
 
-    def create_index_sig(self, index: Index) -> Tuple[Any, ...]:
-        return tuple(
-            self._cleanup_index_expr(
-                index,
-                *(
-                    (e, "")
-                    if isinstance(e, str)
-                    else (self._compile_element(e), self._default_modifiers(e))
-                ),
+    def compare_indexes(
+        self,
+        metadata_index: Index,
+        reflected_index: Index,
+    ) -> ComparisonResult:
+        msg = []
+        unique_msg = self._compare_index_unique(
+            metadata_index, reflected_index
+        )
+        if unique_msg:
+            msg.append(unique_msg)
+        m_exprs = metadata_index.expressions
+        r_exprs = reflected_index.expressions
+        if len(m_exprs) != len(r_exprs):
+            msg.append(f"expression number {len(r_exprs)} to {len(m_exprs)}")
+        if msg:
+            # no point going further, return early
+            return ComparisonResult.Different(msg)
+        skip = []
+        for pos, (m_e, r_e) in enumerate(zip(m_exprs, r_exprs), 1):
+            m_compile = self._compile_element(m_e)
+            m_text = self._cleanup_index_expr(metadata_index, m_compile)
+            # print(f"META ORIG: {m_compile!r} CLEANUP: {m_text!r}")
+            r_compile = self._compile_element(r_e)
+            r_text = self._cleanup_index_expr(metadata_index, r_compile)
+            # print(f"CONN ORIG: {r_compile!r} CLEANUP: {r_text!r}")
+            if m_text == r_text:
+                continue  # expressions these are equal
+            elif m_compile.strip().endswith("_ops") and (
+                " " in m_compile or ")" in m_compile  # is an expression
+            ):
+                skip.append(
+                    f"expression #{pos} {m_compile!r} detected "
+                    "as including operator clause."
+                )
+                util.warn(
+                    f"Expression #{pos} {m_compile!r} in index "
+                    f"{reflected_index.name!r} detected to include "
+                    "an operator clause. Expression compare cannot proceed. "
+                    "Please move the operator clause to the "
+                    "``postgresql_ops`` dict to enable proper compare "
+                    "of the index expressions: "
+                    "https://docs.sqlalchemy.org/en/latest/dialects/postgresql.html#operator-classes",  # noqa: E501
+                )
+            else:
+                msg.append(f"expression #{pos} {r_compile!r} to {m_compile!r}")
+
+        m_options = self._dialect_options(metadata_index)
+        r_options = self._dialect_options(reflected_index)
+        if m_options != r_options:
+            msg.extend(f"options {r_options} to {m_options}")
+
+        if msg:
+            return ComparisonResult.Different(msg)
+        elif skip:
+            # if there are other changes detected don't skip the index
+            return ComparisonResult.Skip(skip)
+        else:
+            return ComparisonResult.Equal()
+
+    def compare_unique_constraint(
+        self,
+        metadata_constraint: UniqueConstraint,
+        reflected_constraint: UniqueConstraint,
+    ) -> ComparisonResult:
+        metadata_tup = self._create_metadata_constraint_sig(
+            metadata_constraint
+        )
+        reflected_tup = self._create_reflected_constraint_sig(
+            reflected_constraint
+        )
+
+        meta_sig = metadata_tup.unnamed
+        conn_sig = reflected_tup.unnamed
+        if conn_sig != meta_sig:
+            return ComparisonResult.Different(
+                f"expression {conn_sig} to {meta_sig}"
             )
-            for e in index.expressions
-        ) + self._dialect_sig(index)
 
-    def create_unique_constraint_sig(
-        self, const: UniqueConstraint
-    ) -> Tuple[Any, ...]:
-        return tuple(
-            sorted([col.name for col in const.columns])
-        ) + self._dialect_sig(const)
+        metadata_do = self._dialect_options(metadata_tup.const)
+        conn_do = self._dialect_options(reflected_tup.const)
+        if metadata_do != conn_do:
+            return ComparisonResult.Different(
+                f"expression {conn_do} to {metadata_do}"
+            )
+
+        return ComparisonResult.Equal()
 
     def adjust_reflected_dialect_options(
         self, reflected_options: Dict[str, Any], kind: str
@@ -345,7 +415,9 @@ class PostgresqlImpl(DefaultImpl):
             options.pop("postgresql_include", None)
         return options
 
-    def _compile_element(self, element: ClauseElement) -> str:
+    def _compile_element(self, element: Union[ClauseElement, str]) -> str:
+        if isinstance(element, str):
+            return element
         return element.compile(
             dialect=self.dialect,
             compile_kwargs={"literal_binds": True, "include_table": False},
@@ -556,9 +628,8 @@ class CreateExcludeConstraintOp(ops.AddConstraintOp):
         return cls(
             constraint.name,
             constraint_table.name,
-            [
-                (expr, op)
-                for expr, name, op in constraint._render_exprs  # type:ignore[attr-defined] # noqa
+            [  # type: ignore
+                (expr, op) for expr, name, op in constraint._render_exprs
             ],
             where=cast("ColumnElement[bool] | None", constraint.where),
             schema=constraint_table.schema,
@@ -585,7 +656,7 @@ class CreateExcludeConstraintOp(ops.AddConstraintOp):
             expr,
             name,
             oper,
-        ) in excl._render_exprs:  # type:ignore[attr-defined]
+        ) in excl._render_exprs:
             t.append_column(Column(name, NULLTYPE))
         t.append_constraint(excl)
         return excl
@@ -643,7 +714,7 @@ class CreateExcludeConstraintOp(ops.AddConstraintOp):
         constraint_name: str,
         *elements: Any,
         **kw: Any,
-    ):
+    ) -> Optional[Table]:
         """Issue a "create exclude constraint" instruction using the
         current batch migration context.
 
@@ -715,10 +786,13 @@ def _exclude_constraint(
         args = [
             "(%s, %r)"
             % (
-                _render_potential_column(sqltext, autogen_context),
+                _render_potential_column(
+                    sqltext,  # type:ignore[arg-type]
+                    autogen_context,
+                ),
                 opstring,
             )
-            for sqltext, name, opstring in constraint._render_exprs  # type:ignore[attr-defined] # noqa
+            for sqltext, name, opstring in constraint._render_exprs
         ]
         if constraint.where is not None:
             args.append(

alembic/ddl/sqlite.py

@@ -1,3 +1,6 @@
+# mypy: allow-untyped-defs, allow-incomplete-defs, allow-untyped-calls
+# mypy: no-warn-return-any, allow-any-generics
+
 from __future__ import annotations
 
 import re
@@ -11,13 +14,13 @@ from sqlalchemy import cast
 from sqlalchemy import JSON
 from sqlalchemy import schema
 from sqlalchemy import sql
-from sqlalchemy.ext.compiler import compiles
 
 from .base import alter_table
 from .base import format_table_name
 from .base import RenameTable
 from .impl import DefaultImpl
 from .. import util
+from ..util.sqla_compat import compiles
 
 if TYPE_CHECKING:
     from sqlalchemy.engine.reflection import Inspector
@@ -71,13 +74,13 @@ class SQLiteImpl(DefaultImpl):
     def add_constraint(self, const: Constraint):
         # attempt to distinguish between an
         # auto-gen constraint and an explicit one
-        if const._create_rule is None:  # type:ignore[attr-defined]
+        if const._create_rule is None:
             raise NotImplementedError(
                 "No support for ALTER of constraints in SQLite dialect. "
                 "Please refer to the batch mode feature which allows for "
                 "SQLite migrations using a copy-and-move strategy."
             )
-        elif const._create_rule(self):  # type:ignore[attr-defined]
+        elif const._create_rule(self):
             util.warn(
                 "Skipping unsupported ALTER for "
                 "creation of implicit constraint. "
@@ -86,7 +89,7 @@ class SQLiteImpl(DefaultImpl):
             )
 
     def drop_constraint(self, const: Constraint):
-        if const._create_rule is None:  # type:ignore[attr-defined]
+        if const._create_rule is None:
             raise NotImplementedError(
                 "No support for ALTER of constraints in SQLite dialect. "
                 "Please refer to the batch mode feature which allows for "
@@ -177,8 +180,7 @@ class SQLiteImpl(DefaultImpl):
         new_type: TypeEngine,
     ) -> None:
         if (
-            existing.type._type_affinity  # type:ignore[attr-defined]
-            is not new_type._type_affinity  # type:ignore[attr-defined]
+            existing.type._type_affinity is not new_type._type_affinity
             and not isinstance(new_type, JSON)
         ):
             existing_transfer["expr"] = cast(

alembic/op.pyi

@@ -12,6 +12,7 @@ from typing import List
 from typing import Literal
 from typing import Mapping
 from typing import Optional
+from typing import overload
 from typing import Sequence
 from typing import Tuple
 from typing import Type
@@ -35,12 +36,28 @@ if TYPE_CHECKING:
     from sqlalchemy.sql.type_api import TypeEngine
     from sqlalchemy.util import immutabledict
 
-    from .operations.ops import BatchOperations
+    from .operations.base import BatchOperations
+    from .operations.ops import AddColumnOp
+    from .operations.ops import AddConstraintOp
+    from .operations.ops import AlterColumnOp
+    from .operations.ops import AlterTableOp
+    from .operations.ops import BulkInsertOp
+    from .operations.ops import CreateIndexOp
+    from .operations.ops import CreateTableCommentOp
+    from .operations.ops import CreateTableOp
+    from .operations.ops import DropColumnOp
+    from .operations.ops import DropConstraintOp
+    from .operations.ops import DropIndexOp
+    from .operations.ops import DropTableCommentOp
+    from .operations.ops import DropTableOp
+    from .operations.ops import ExecuteSQLOp
     from .operations.ops import MigrateOperation
     from .runtime.migration import MigrationContext
     from .util.sqla_compat import _literal_bindparam
 
 _T = TypeVar("_T")
+_C = TypeVar("_C", bound=Callable[..., Any])
+
 ### end imports ###
 
 def add_column(
@@ -132,8 +149,8 @@ def alter_column(
     comment: Union[str, Literal[False], None] = False,
     server_default: Any = False,
     new_column_name: Optional[str] = None,
-    type_: Union[TypeEngine, Type[TypeEngine], None] = None,
-    existing_type: Union[TypeEngine, Type[TypeEngine], None] = None,
+    type_: Union[TypeEngine[Any], Type[TypeEngine[Any]], None] = None,
+    existing_type: Union[TypeEngine[Any], Type[TypeEngine[Any]], None] = None,
     existing_server_default: Union[
         str, bool, Identity, Computed, None
     ] = False,
@@ -230,7 +247,7 @@ def batch_alter_table(
     table_name: str,
     schema: Optional[str] = None,
     recreate: Literal["auto", "always", "never"] = "auto",
-    partial_reordering: Optional[tuple] = None,
+    partial_reordering: Optional[Tuple[Any, ...]] = None,
     copy_from: Optional[Table] = None,
     table_args: Tuple[Any, ...] = (),
     table_kwargs: Mapping[str, Any] = immutabledict({}),
@@ -377,7 +394,7 @@ def batch_alter_table(
 
 def bulk_insert(
     table: Union[Table, TableClause],
-    rows: List[dict],
+    rows: List[Dict[str, Any]],
     *,
     multiinsert: bool = True,
 ) -> None:
@@ -1162,7 +1179,7 @@ def get_context() -> MigrationContext:
 
     """
 
-def implementation_for(op_cls: Any) -> Callable[..., Any]:
+def implementation_for(op_cls: Any) -> Callable[[_C], _C]:
     """Register an implementation for a given :class:`.MigrateOperation`.
 
     This is part of the operation extensibility API.
@@ -1174,7 +1191,7 @@ def implementation_for(op_cls: Any) -> Callable[..., Any]:
     """
 
 def inline_literal(
-    value: Union[str, int], type_: Optional[TypeEngine] = None
+    value: Union[str, int], type_: Optional[TypeEngine[Any]] = None
 ) -> _literal_bindparam:
     r"""Produce an 'inline literal' expression, suitable for
     using in an INSERT, UPDATE, or DELETE statement.
@@ -1218,6 +1235,27 @@ def inline_literal(
 
     """
 
+@overload
+def invoke(operation: CreateTableOp) -> Table: ...
+@overload
+def invoke(
+    operation: Union[
+        AddConstraintOp,
+        DropConstraintOp,
+        CreateIndexOp,
+        DropIndexOp,
+        AddColumnOp,
+        AlterColumnOp,
+        AlterTableOp,
+        CreateTableCommentOp,
+        DropTableCommentOp,
+        DropColumnOp,
+        BulkInsertOp,
+        DropTableOp,
+        ExecuteSQLOp,
+    ]
+) -> None: ...
+@overload
 def invoke(operation: MigrateOperation) -> Any:
     """Given a :class:`.MigrateOperation`, invoke it in terms of
     this :class:`.Operations` instance.
@@ -1226,7 +1264,7 @@ def invoke(operation: MigrateOperation) -> Any:
 
 def register_operation(
     name: str, sourcename: Optional[str] = None
-) -> Callable[[_T], _T]:
+) -> Callable[[Type[_T]], Type[_T]]:
     """Register a new operation for this class.
 
     This method is normally used to add new operations

alembic/operations/base.py

@@ -1,3 +1,5 @@
+# mypy: allow-untyped-calls
+
 from __future__ import annotations
 
 from contextlib import contextmanager
@@ -10,7 +12,9 @@ from typing import Dict
 from typing import Iterator
 from typing import List  # noqa
 from typing import Mapping
+from typing import NoReturn
 from typing import Optional
+from typing import overload
 from typing import Sequence  # noqa
 from typing import Tuple
 from typing import Type  # noqa
@@ -47,12 +51,28 @@ if TYPE_CHECKING:
     from sqlalchemy.types import TypeEngine
 
     from .batch import BatchOperationsImpl
+    from .ops import AddColumnOp
+    from .ops import AddConstraintOp
+    from .ops import AlterColumnOp
+    from .ops import AlterTableOp
+    from .ops import BulkInsertOp
+    from .ops import CreateIndexOp
+    from .ops import CreateTableCommentOp
+    from .ops import CreateTableOp
+    from .ops import DropColumnOp
+    from .ops import DropConstraintOp
+    from .ops import DropIndexOp
+    from .ops import DropTableCommentOp
+    from .ops import DropTableOp
+    from .ops import ExecuteSQLOp
     from .ops import MigrateOperation
     from ..ddl import DefaultImpl
     from ..runtime.migration import MigrationContext
 __all__ = ("Operations", "BatchOperations")
 _T = TypeVar("_T")
 
+_C = TypeVar("_C", bound=Callable[..., Any])
+
 
 class AbstractOperations(util.ModuleClsProxy):
     """Base class for Operations and BatchOperations.
@@ -86,7 +106,7 @@ class AbstractOperations(util.ModuleClsProxy):
     @classmethod
     def register_operation(
         cls, name: str, sourcename: Optional[str] = None
-    ) -> Callable[[_T], _T]:
+    ) -> Callable[[Type[_T]], Type[_T]]:
         """Register a new operation for this class.
 
         This method is normally used to add new operations
@@ -103,7 +123,7 @@ class AbstractOperations(util.ModuleClsProxy):
 
         """
 
-        def register(op_cls):
+        def register(op_cls: Type[_T]) -> Type[_T]:
             if sourcename is None:
                 fn = getattr(op_cls, name)
                 source_name = fn.__name__
@@ -122,8 +142,11 @@ class AbstractOperations(util.ModuleClsProxy):
                 *spec, formatannotation=formatannotation_fwdref
             )
             num_defaults = len(spec[3]) if spec[3] else 0
+
+            defaulted_vals: Tuple[Any, ...]
+
             if num_defaults:
-                defaulted_vals = name_args[0 - num_defaults :]
+                defaulted_vals = tuple(name_args[0 - num_defaults :])
             else:
                 defaulted_vals = ()
 
@@ -164,7 +187,7 @@ class AbstractOperations(util.ModuleClsProxy):
 
             globals_ = dict(globals())
             globals_.update({"op_cls": op_cls})
-            lcl = {}
+            lcl: Dict[str, Any] = {}
 
             exec(func_text, globals_, lcl)
             setattr(cls, name, lcl[name])
@@ -180,7 +203,7 @@ class AbstractOperations(util.ModuleClsProxy):
         return register
 
     @classmethod
-    def implementation_for(cls, op_cls: Any) -> Callable[..., Any]:
+    def implementation_for(cls, op_cls: Any) -> Callable[[_C], _C]:
         """Register an implementation for a given :class:`.MigrateOperation`.
 
         This is part of the operation extensibility API.
@@ -191,7 +214,7 @@ class AbstractOperations(util.ModuleClsProxy):
 
         """
 
-        def decorate(fn):
+        def decorate(fn: _C) -> _C:
             cls._to_impl.dispatch_for(op_cls)(fn)
             return fn
 
@@ -213,7 +236,7 @@ class AbstractOperations(util.ModuleClsProxy):
         table_name: str,
         schema: Optional[str] = None,
         recreate: Literal["auto", "always", "never"] = "auto",
-        partial_reordering: Optional[tuple] = None,
+        partial_reordering: Optional[Tuple[Any, ...]] = None,
         copy_from: Optional[Table] = None,
         table_args: Tuple[Any, ...] = (),
         table_kwargs: Mapping[str, Any] = util.immutabledict(),
@@ -382,6 +405,35 @@ class AbstractOperations(util.ModuleClsProxy):
 
         return self.migration_context
 
+    @overload
+    def invoke(self, operation: CreateTableOp) -> Table:
+        ...
+
+    @overload
+    def invoke(
+        self,
+        operation: Union[
+            AddConstraintOp,
+            DropConstraintOp,
+            CreateIndexOp,
+            DropIndexOp,
+            AddColumnOp,
+            AlterColumnOp,
+            AlterTableOp,
+            CreateTableCommentOp,
+            DropTableCommentOp,
+            DropColumnOp,
+            BulkInsertOp,
+            DropTableOp,
+            ExecuteSQLOp,
+        ],
+    ) -> None:
+        ...
+
+    @overload
+    def invoke(self, operation: MigrateOperation) -> Any:
+        ...
+
     def invoke(self, operation: MigrateOperation) -> Any:
         """Given a :class:`.MigrateOperation`, invoke it in terms of
         this :class:`.Operations` instance.
@@ -659,8 +711,10 @@ class Operations(AbstractOperations):
             comment: Union[str, Literal[False], None] = False,
             server_default: Any = False,
             new_column_name: Optional[str] = None,
-            type_: Union[TypeEngine, Type[TypeEngine], None] = None,
-            existing_type: Union[TypeEngine, Type[TypeEngine], None] = None,
+            type_: Union[TypeEngine[Any], Type[TypeEngine[Any]], None] = None,
+            existing_type: Union[
+                TypeEngine[Any], Type[TypeEngine[Any]], None
+            ] = None,
             existing_server_default: Union[
                 str, bool, Identity, Computed, None
             ] = False,
@@ -756,7 +810,7 @@ class Operations(AbstractOperations):
         def bulk_insert(
             self,
             table: Union[Table, TableClause],
-            rows: List[dict],
+            rows: List[Dict[str, Any]],
             *,
             multiinsert: bool = True,
         ) -> None:
@@ -1560,7 +1614,7 @@ class BatchOperations(AbstractOperations):
 
     impl: BatchOperationsImpl
 
-    def _noop(self, operation):
+    def _noop(self, operation: Any) -> NoReturn:
         raise NotImplementedError(
             "The %s method does not apply to a batch table alter operation."
             % operation
@@ -1596,8 +1650,10 @@ class BatchOperations(AbstractOperations):
             comment: Union[str, Literal[False], None] = False,
             server_default: Any = False,
             new_column_name: Optional[str] = None,
-            type_: Union[TypeEngine, Type[TypeEngine], None] = None,
-            existing_type: Union[TypeEngine, Type[TypeEngine], None] = None,
+            type_: Union[TypeEngine[Any], Type[TypeEngine[Any]], None] = None,
+            existing_type: Union[
+                TypeEngine[Any], Type[TypeEngine[Any]], None
+            ] = None,
             existing_server_default: Union[
                 str, bool, Identity, Computed, None
             ] = False,
@@ -1652,7 +1708,7 @@ class BatchOperations(AbstractOperations):
 
         def create_exclude_constraint(
             self, constraint_name: str, *elements: Any, **kw: Any
-        ):
+        ) -> Optional[Table]:
             """Issue a "create exclude constraint" instruction using the
             current batch migration context.