alembic 1.12.0__py3-none-any.whl → 1.13.0__py3-none-any.whl

alembic/ddl/postgresql.py

@@ -21,10 +21,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
 
@@ -38,6 +36,7 @@ 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
@@ -57,8 +56,8 @@ if TYPE_CHECKING:
     from sqlalchemy.dialects.postgresql.hstore import HSTORE
     from sqlalchemy.dialects.postgresql.json import JSON
     from sqlalchemy.dialects.postgresql.json import JSONB
-    from sqlalchemy.sql.elements import BinaryExpression
     from sqlalchemy.sql.elements import ClauseElement
+    from sqlalchemy.sql.elements import ColumnElement
     from sqlalchemy.sql.elements import quoted_name
     from sqlalchemy.sql.schema import MetaData
     from sqlalchemy.sql.schema import Table
@@ -79,7 +78,6 @@ class PostgresqlImpl(DefaultImpl):
     type_synonyms = DefaultImpl.type_synonyms + (
         {"FLOAT", "DOUBLE PRECISION"},
     )
-    identity_attrs_ignore = ("on_null", "order")
 
     def create_index(self, index: Index, **kw: Any) -> None:
         # this likely defaults to None if not present, so get()
@@ -253,62 +251,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
@@ -317,25 +313,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
@@ -346,12 +410,37 @@ 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},
         ).string
 
+    def render_ddl_sql_expr(
+        self,
+        expr: ClauseElement,
+        is_server_default: bool = False,
+        is_index: bool = False,
+        **kw: Any,
+    ) -> str:
+        """Render a SQL expression that is typically a server default,
+        index expression, etc.
+
+        """
+
+        # apply self_group to index expressions;
+        # see https://github.com/sqlalchemy/sqlalchemy/blob/
+        # 82fa95cfce070fab401d020c6e6e4a6a96cc2578/
+        # lib/sqlalchemy/dialects/postgresql/base.py#L2261
+        if is_index and not isinstance(expr, ColumnClause):
+            expr = expr.self_group()
+
+        return super().render_ddl_sql_expr(
+            expr, is_server_default=is_server_default, is_index=is_index, **kw
+        )
+
     def render_type(
         self, type_: TypeEngine, autogen_context: AutogenContext
     ) -> Union[str, Literal[False]]:
@@ -513,7 +602,7 @@ class CreateExcludeConstraintOp(ops.AddConstraintOp):
             Sequence[Tuple[str, str]],
             Sequence[Tuple[ColumnClause[Any], str]],
         ],
-        where: Optional[Union[BinaryExpression, str]] = None,
+        where: Optional[Union[ColumnElement[bool], str]] = None,
         schema: Optional[str] = None,
         _orig_constraint: Optional[ExcludeConstraint] = None,
         **kw,
@@ -538,9 +627,7 @@ class CreateExcludeConstraintOp(ops.AddConstraintOp):
                 (expr, op)
                 for expr, name, op in constraint._render_exprs  # type:ignore[attr-defined] # noqa
             ],
-            where=cast(
-                "Optional[Union[BinaryExpression, str]]", constraint.where
-            ),
+            where=cast("ColumnElement[bool] | None", constraint.where),
             schema=constraint_table.schema,
             _orig_constraint=constraint,
             deferrable=constraint.deferrable,

alembic/op.pyi

@@ -19,14 +19,13 @@ from typing import TYPE_CHECKING
 from typing import TypeVar
 from typing import Union
 
-from sqlalchemy.sql.expression import TableClause
-from sqlalchemy.sql.expression import Update
-
 if TYPE_CHECKING:
     from sqlalchemy.engine import Connection
-    from sqlalchemy.sql.elements import BinaryExpression
+    from sqlalchemy.sql import Executable
+    from sqlalchemy.sql.elements import ColumnElement
     from sqlalchemy.sql.elements import conv
     from sqlalchemy.sql.elements import TextClause
+    from sqlalchemy.sql.expression import TableClause
     from sqlalchemy.sql.functions import Function
     from sqlalchemy.sql.schema import Column
     from sqlalchemy.sql.schema import Computed
@@ -197,7 +196,7 @@ def alter_column(
      don't otherwise specify a new type, as well as for
      when nullability is being changed on a SQL Server
      column.  It is also used if the type is a so-called
-     SQLlchemy "schema" type which may define a constraint (i.e.
+     SQLAlchemy "schema" type which may define a constraint (i.e.
      :class:`~sqlalchemy.types.Boolean`,
      :class:`~sqlalchemy.types.Enum`),
      so that the constraint can be dropped.
@@ -481,7 +480,7 @@ def bulk_insert(
 def create_check_constraint(
     constraint_name: Optional[str],
     table_name: str,
-    condition: Union[str, BinaryExpression, TextClause],
+    condition: Union[str, ColumnElement[bool], TextClause],
     *,
     schema: Optional[str] = None,
     **kw: Any,
@@ -1024,7 +1023,7 @@ def drop_table_comment(
     """
 
 def execute(
-    sqltext: Union[str, TextClause, Update],
+    sqltext: Union[Executable, str],
     *,
     execution_options: Optional[dict[str, Any]] = None,
 ) -> None:
@@ -1080,7 +1079,7 @@ def execute(
         )
 
     Additionally, when passing the statement as a plain string, it is first
-    coerceed into a :func:`sqlalchemy.sql.expression.text` construct
+    coerced into a :func:`sqlalchemy.sql.expression.text` construct
     before being passed along.  In the less likely case that the
     literal SQL string contains a colon, it must be escaped with a
     backslash, as::
@@ -1093,9 +1092,8 @@ def execute(
     * a string
     * a :func:`sqlalchemy.sql.expression.text` construct.
     * a :func:`sqlalchemy.sql.expression.insert` construct.
-    * a :func:`sqlalchemy.sql.expression.update`,
-      :func:`sqlalchemy.sql.expression.insert`,
-      or :func:`sqlalchemy.sql.expression.delete`  construct.
+    * a :func:`sqlalchemy.sql.expression.update` construct.
+    * a :func:`sqlalchemy.sql.expression.delete` construct.
     * Any "executable" described in SQLAlchemy Core documentation,
       noting that no result set is returned.
 

alembic/operations/__init__.py

@@ -3,6 +3,7 @@ from .base import AbstractOperations
 from .base import BatchOperations
 from .base import Operations
 from .ops import MigrateOperation
+from .ops import MigrationScript
 
 
 __all__ = [
@@ -10,4 +11,5 @@ __all__ = [
     "Operations",
     "BatchOperations",
     "MigrateOperation",
+    "MigrationScript",
 ]

alembic/operations/base.py

@@ -35,10 +35,10 @@ if TYPE_CHECKING:
 
     from sqlalchemy import Table
     from sqlalchemy.engine import Connection
-    from sqlalchemy.sql.expression import BinaryExpression
+    from sqlalchemy.sql import Executable
+    from sqlalchemy.sql.expression import ColumnElement
     from sqlalchemy.sql.expression import TableClause
     from sqlalchemy.sql.expression import TextClause
-    from sqlalchemy.sql.expression import Update
     from sqlalchemy.sql.functions import Function
     from sqlalchemy.sql.schema import Column
     from sqlalchemy.sql.schema import Computed
@@ -723,7 +723,7 @@ class Operations(AbstractOperations):
              don't otherwise specify a new type, as well as for
              when nullability is being changed on a SQL Server
              column.  It is also used if the type is a so-called
-             SQLlchemy "schema" type which may define a constraint (i.e.
+             SQLAlchemy "schema" type which may define a constraint (i.e.
              :class:`~sqlalchemy.types.Boolean`,
              :class:`~sqlalchemy.types.Enum`),
              so that the constraint can be dropped.
@@ -861,7 +861,7 @@ class Operations(AbstractOperations):
             self,
             constraint_name: Optional[str],
             table_name: str,
-            condition: Union[str, BinaryExpression, TextClause],
+            condition: Union[str, ColumnElement[bool], TextClause],
             *,
             schema: Optional[str] = None,
             **kw: Any,
@@ -1433,7 +1433,7 @@ class Operations(AbstractOperations):
 
         def execute(
             self,
-            sqltext: Union[str, TextClause, Update],
+            sqltext: Union[Executable, str],
             *,
             execution_options: Optional[dict[str, Any]] = None,
         ) -> None:
@@ -1489,7 +1489,7 @@ class Operations(AbstractOperations):
                 )
 
             Additionally, when passing the statement as a plain string, it is first
-            coerceed into a :func:`sqlalchemy.sql.expression.text` construct
+            coerced into a :func:`sqlalchemy.sql.expression.text` construct
             before being passed along.  In the less likely case that the
             literal SQL string contains a colon, it must be escaped with a
             backslash, as::
@@ -1502,9 +1502,8 @@ class Operations(AbstractOperations):
             * a string
             * a :func:`sqlalchemy.sql.expression.text` construct.
             * a :func:`sqlalchemy.sql.expression.insert` construct.
-            * a :func:`sqlalchemy.sql.expression.update`,
-              :func:`sqlalchemy.sql.expression.insert`,
-              or :func:`sqlalchemy.sql.expression.delete`  construct.
+            * a :func:`sqlalchemy.sql.expression.update` construct.
+            * a :func:`sqlalchemy.sql.expression.delete` construct.
             * Any "executable" described in SQLAlchemy Core documentation,
               noting that no result set is returned.
 
@@ -1635,7 +1634,7 @@ class BatchOperations(AbstractOperations):
         def create_check_constraint(
             self,
             constraint_name: str,
-            condition: Union[str, BinaryExpression, TextClause],
+            condition: Union[str, ColumnElement[bool], TextClause],
             **kw: Any,
         ) -> None:
             """Issue a "create check constraint" instruction using the
@@ -1822,7 +1821,7 @@ class BatchOperations(AbstractOperations):
 
         def execute(
             self,
-            sqltext: Union[str, TextClause, Update],
+            sqltext: Union[Executable, str],
             *,
             execution_options: Optional[dict[str, Any]] = None,
         ) -> None:

alembic/operations/ops.py

@@ -28,9 +28,7 @@ from ..util import sqla_compat
 if TYPE_CHECKING:
     from typing import Literal
 
-    from sqlalchemy.sql.dml import Insert
-    from sqlalchemy.sql.dml import Update
-    from sqlalchemy.sql.elements import BinaryExpression
+    from sqlalchemy.sql import Executable
     from sqlalchemy.sql.elements import ColumnElement
     from sqlalchemy.sql.elements import conv
     from sqlalchemy.sql.elements import quoted_name
@@ -788,7 +786,7 @@ class CreateCheckConstraintOp(AddConstraintOp):
         operations: Operations,
         constraint_name: Optional[str],
         table_name: str,
-        condition: Union[str, BinaryExpression, TextClause],
+        condition: Union[str, ColumnElement[bool], TextClause],
         *,
         schema: Optional[str] = None,
         **kw: Any,
@@ -841,7 +839,7 @@ class CreateCheckConstraintOp(AddConstraintOp):
         cls,
         operations: BatchOperations,
         constraint_name: str,
-        condition: Union[str, BinaryExpression, TextClause],
+        condition: Union[str, ColumnElement[bool], TextClause],
         **kw: Any,
     ) -> None:
         """Issue a "create check constraint" instruction using the
@@ -901,7 +899,7 @@ class CreateIndexOp(MigrateOperation):
         return cls(
             index.name,  # type: ignore[arg-type]
             index.table.name,
-            sqla_compat._get_index_expressions(index),
+            index.expressions,
             schema=index.table.schema,
             unique=index.unique,
             **index.kwargs,
@@ -1883,7 +1881,7 @@ class AlterColumnOp(AlterTableOp):
          don't otherwise specify a new type, as well as for
          when nullability is being changed on a SQL Server
          column.  It is also used if the type is a so-called
-         SQLlchemy "schema" type which may define a constraint (i.e.
+         SQLAlchemy "schema" type which may define a constraint (i.e.
          :class:`~sqlalchemy.types.Boolean`,
          :class:`~sqlalchemy.types.Enum`),
          so that the constraint can be dropped.
@@ -2424,7 +2422,7 @@ class ExecuteSQLOp(MigrateOperation):
 
     def __init__(
         self,
-        sqltext: Union[Update, str, Insert, TextClause],
+        sqltext: Union[Executable, str],
         *,
         execution_options: Optional[dict[str, Any]] = None,
     ) -> None:
@@ -2435,7 +2433,7 @@ class ExecuteSQLOp(MigrateOperation):
     def execute(
         cls,
         operations: Operations,
-        sqltext: Union[str, TextClause, Update],
+        sqltext: Union[Executable, str],
         *,
         execution_options: Optional[dict[str, Any]] = None,
     ) -> None:
@@ -2491,7 +2489,7 @@ class ExecuteSQLOp(MigrateOperation):
             )
 
         Additionally, when passing the statement as a plain string, it is first
-        coerceed into a :func:`sqlalchemy.sql.expression.text` construct
+        coerced into a :func:`sqlalchemy.sql.expression.text` construct
         before being passed along.  In the less likely case that the
         literal SQL string contains a colon, it must be escaped with a
         backslash, as::
@@ -2504,9 +2502,8 @@ class ExecuteSQLOp(MigrateOperation):
         * a string
         * a :func:`sqlalchemy.sql.expression.text` construct.
         * a :func:`sqlalchemy.sql.expression.insert` construct.
-        * a :func:`sqlalchemy.sql.expression.update`,
-          :func:`sqlalchemy.sql.expression.insert`,
-          or :func:`sqlalchemy.sql.expression.delete`  construct.
+        * a :func:`sqlalchemy.sql.expression.update` construct.
+        * a :func:`sqlalchemy.sql.expression.delete` construct.
         * Any "executable" described in SQLAlchemy Core documentation,
           noting that no result set is returned.
 
@@ -2527,7 +2524,7 @@ class ExecuteSQLOp(MigrateOperation):
     def batch_execute(
         cls,
         operations: Operations,
-        sqltext: Union[str, TextClause, Update],
+        sqltext: Union[Executable, str],
         *,
         execution_options: Optional[dict[str, Any]] = None,
     ) -> None:
@@ -2542,6 +2539,9 @@ class ExecuteSQLOp(MigrateOperation):
             operations, sqltext, execution_options=execution_options
         )
 
+    def to_diff_tuple(self) -> Tuple[str, Union[Executable, str]]:
+        return ("execute", self.sqltext)
+
 
 class OpContainer(MigrateOperation):
     """Represent a sequence of operations operation."""

alembic/operations/toimpl.py

@@ -5,7 +5,7 @@ from sqlalchemy import schema as sa_schema
 from . import ops
 from .base import Operations
 from ..util.sqla_compat import _copy
-from ..util.sqla_compat import sqla_2
+from ..util.sqla_compat import sqla_14
 
 if TYPE_CHECKING:
     from sqlalchemy.sql.schema import Table
@@ -98,8 +98,8 @@ def create_index(
     idx = operation.to_index(operations.migration_context)
     kw = {}
     if operation.if_not_exists is not None:
-        if not sqla_2:
-            raise NotImplementedError("SQLAlchemy 2.0+ required")
+        if not sqla_14:
+            raise NotImplementedError("SQLAlchemy 1.4+ required")
 
         kw["if_not_exists"] = operation.if_not_exists
     operations.impl.create_index(idx, **kw)
@@ -109,8 +109,8 @@ def create_index(
 def drop_index(operations: "Operations", operation: "ops.DropIndexOp") -> None:
     kw = {}
     if operation.if_exists is not None:
-        if not sqla_2:
-            raise NotImplementedError("SQLAlchemy 2.0+ required")
+        if not sqla_14:
+            raise NotImplementedError("SQLAlchemy 1.4+ required")
 
         kw["if_exists"] = operation.if_exists
 

alembic/runtime/environment.py

@@ -10,6 +10,7 @@ from typing import Mapping
 from typing import MutableMapping
 from typing import Optional
 from typing import overload
+from typing import Sequence
 from typing import TextIO
 from typing import Tuple
 from typing import TYPE_CHECKING
@@ -23,11 +24,12 @@ from .migration import _ProxyTransaction
 from .migration import MigrationContext
 from .. import util
 from ..operations import Operations
+from ..script.revision import _GetRevArg
 
 if TYPE_CHECKING:
     from sqlalchemy.engine import URL
     from sqlalchemy.engine.base import Connection
-    from sqlalchemy.sql.elements import ClauseElement
+    from sqlalchemy.sql import Executable
     from sqlalchemy.sql.schema import MetaData
     from sqlalchemy.sql.schema import SchemaItem
     from sqlalchemy.sql.type_api import TypeEngine
@@ -36,13 +38,13 @@ if TYPE_CHECKING:
     from ..autogenerate.api import AutogenContext
     from ..config import Config
     from ..ddl import DefaultImpl
-    from ..operations.ops import MigrateOperation
+    from ..operations.ops import MigrationScript
     from ..script.base import ScriptDirectory
 
 _RevNumber = Optional[Union[str, Tuple[str, ...]]]
 
 ProcessRevisionDirectiveFn = Callable[
-    [MigrationContext, Tuple[str, str], List["MigrateOperation"]], None
+    [MigrationContext, _GetRevArg, List["MigrationScript"]], None
 ]
 
 RenderItemFn = Callable[
@@ -415,7 +417,7 @@ class EnvironmentContext(util.ModuleClsProxy):
         tag: Optional[str] = None,
         template_args: Optional[Dict[str, Any]] = None,
         render_as_batch: bool = False,
-        target_metadata: Optional[MetaData] = None,
+        target_metadata: Union[MetaData, Sequence[MetaData], None] = None,
         include_name: Optional[IncludeNameFn] = None,
         include_object: Optional[IncludeObjectFn] = None,
         include_schemas: bool = False,
@@ -938,7 +940,7 @@ class EnvironmentContext(util.ModuleClsProxy):
 
     def execute(
         self,
-        sql: Union[ClauseElement, str],
+        sql: Union[Executable, str],
         execution_options: Optional[dict] = None,
     ) -> None:
         """Execute the given SQL using the current change context.