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

alembic/ddl/impl.py

@@ -1,11 +1,14 @@
 from __future__ import annotations
 
-from collections import namedtuple
+import logging
 import re
 from typing import Any
 from typing import Callable
 from typing import Dict
+from typing import Iterable
 from typing import List
+from typing import Mapping
+from typing import NamedTuple
 from typing import Optional
 from typing import Sequence
 from typing import Set
@@ -18,7 +21,10 @@ from sqlalchemy import cast
 from sqlalchemy import schema
 from sqlalchemy import text
 
+from . import _autogen
 from . import base
+from ._autogen import _constraint_sig
+from ._autogen import ComparisonResult
 from .. import util
 from ..util import sqla_compat
 
@@ -30,7 +36,8 @@ if TYPE_CHECKING:
     from sqlalchemy.engine import Dialect
     from sqlalchemy.engine.cursor import CursorResult
     from sqlalchemy.engine.reflection import Inspector
-    from sqlalchemy.sql.elements import ClauseElement
+    from sqlalchemy.sql import ClauseElement
+    from sqlalchemy.sql import Executable
     from sqlalchemy.sql.elements import ColumnElement
     from sqlalchemy.sql.elements import quoted_name
     from sqlalchemy.sql.schema import Column
@@ -47,6 +54,8 @@ if TYPE_CHECKING:
     from ..operations.batch import ApplyBatchImpl
     from ..operations.batch import BatchOperationsImpl
 
+log = logging.getLogger(__name__)
+
 
 class ImplMeta(type):
     def __init__(
@@ -63,8 +72,6 @@ class ImplMeta(type):
 
 _impls: Dict[str, Type[DefaultImpl]] = {}
 
-Params = namedtuple("Params", ["token0", "tokens", "args", "kwargs"])
-
 
 class DefaultImpl(metaclass=ImplMeta):
 
@@ -86,8 +93,11 @@ class DefaultImpl(metaclass=ImplMeta):
     command_terminator = ";"
     type_synonyms: Tuple[Set[str], ...] = ({"NUMERIC", "DECIMAL"},)
     type_arg_extract: Sequence[str] = ()
-    # on_null is known to be supported only by oracle
-    identity_attrs_ignore: Tuple[str, ...] = ("on_null",)
+    # These attributes are deprecated in SQLAlchemy via #10247. They need to
+    # be ignored to support older version that did not use dialect kwargs.
+    # They only apply to Oracle and are replaced by oracle_order,
+    # oracle_on_null
+    identity_attrs_ignore: Tuple[str, ...] = ("order", "on_null")
 
     def __init__(
         self,
@@ -154,7 +164,7 @@ class DefaultImpl(metaclass=ImplMeta):
 
     def _exec(
         self,
-        construct: Union[ClauseElement, str],
+        construct: Union[Executable, str],
         execution_options: Optional[dict[str, Any]] = None,
         multiparams: Sequence[dict] = (),
         params: Dict[str, Any] = util.immutabledict(),
@@ -166,6 +176,7 @@ class DefaultImpl(metaclass=ImplMeta):
                 # TODO: coverage
                 raise Exception("Execution arguments not allowed with as_sql")
 
+            compile_kw: dict[str, Any]
             if self.literal_binds and not isinstance(
                 construct, schema.DDLElement
             ):
@@ -173,9 +184,9 @@ class DefaultImpl(metaclass=ImplMeta):
             else:
                 compile_kw = {}
 
-            compiled = construct.compile(
-                dialect=self.dialect, **compile_kw  # type: ignore[arg-type]
-            )
+            if TYPE_CHECKING:
+                assert isinstance(construct, ClauseElement)
+            compiled = construct.compile(dialect=self.dialect, **compile_kw)
             self.static_output(
                 str(compiled).replace("\t", "    ").strip()
                 + self.command_terminator
@@ -190,13 +201,11 @@ class DefaultImpl(metaclass=ImplMeta):
                 assert isinstance(multiparams, tuple)
                 multiparams += (params,)
 
-            return conn.execute(  # type: ignore[call-overload]
-                construct, multiparams
-            )
+            return conn.execute(construct, multiparams)
 
     def execute(
         self,
-        sql: Union[ClauseElement, str],
+        sql: Union[Executable, str],
         execution_options: Optional[dict[str, Any]] = None,
     ) -> None:
         self._exec(sql, execution_options)
@@ -433,6 +442,7 @@ class DefaultImpl(metaclass=ImplMeta):
                         )
 
     def _tokenize_column_type(self, column: Column) -> Params:
+        definition: str
         definition = self.dialect.type_compiler.process(column.type).lower()
 
         # tokenize the SQLAlchemy-generated version of a type, so that
@@ -447,9 +457,9 @@ class DefaultImpl(metaclass=ImplMeta):
         # varchar character set utf8
         #
 
-        tokens = re.findall(r"[\w\-_]+|\(.+?\)", definition)
+        tokens: List[str] = re.findall(r"[\w\-_]+|\(.+?\)", definition)
 
-        term_tokens = []
+        term_tokens: List[str] = []
         paren_term = None
 
         for token in tokens:
@@ -461,6 +471,7 @@ class DefaultImpl(metaclass=ImplMeta):
         params = Params(term_tokens[0], term_tokens[1:], [], {})
 
         if paren_term:
+            term: str
             for term in re.findall("[^(),]+", paren_term):
                 if "=" in term:
                     key, val = term.split("=")
@@ -573,13 +584,10 @@ class DefaultImpl(metaclass=ImplMeta):
 
         """
 
-        compile_kw = {
-            "compile_kwargs": {"literal_binds": True, "include_table": False}
-        }
+        compile_kw = {"literal_binds": True, "include_table": False}
+
         return str(
-            expr.compile(
-                dialect=self.dialect, **compile_kw  # type: ignore[arg-type]
-            )
+            expr.compile(dialect=self.dialect, compile_kwargs=compile_kw)
         )
 
     def _compat_autogen_column_reflect(self, inspector: Inspector) -> Callable:
@@ -638,10 +646,10 @@ class DefaultImpl(metaclass=ImplMeta):
         # ignored contains the attributes that were not considered
         # because assumed to their default values in the db.
         diff, ignored = _compare_identity_options(
-            sqla_compat._identity_attrs,
             metadata_identity,
             inspector_identity,
             sqla_compat.Identity(),
+            skip={"always"},
         )
 
         meta_always = getattr(metadata_identity, "always", None)
@@ -662,15 +670,96 @@ class DefaultImpl(metaclass=ImplMeta):
             bool(diff) or bool(metadata_identity) != bool(inspector_identity),
         )
 
-    def create_index_sig(self, index: Index) -> Tuple[Any, ...]:
-        # order of col matters in an index
-        return tuple(col.name for col in index.columns)
+    def _compare_index_unique(
+        self, metadata_index: Index, reflected_index: Index
+    ) -> Optional[str]:
+        conn_unique = bool(reflected_index.unique)
+        meta_unique = bool(metadata_index.unique)
+        if conn_unique != meta_unique:
+            return f"unique={conn_unique} to unique={meta_unique}"
+        else:
+            return None
+
+    def _create_metadata_constraint_sig(
+        self, constraint: _autogen._C, **opts: Any
+    ) -> _constraint_sig[_autogen._C]:
+        return _constraint_sig.from_constraint(True, self, constraint, **opts)
+
+    def _create_reflected_constraint_sig(
+        self, constraint: _autogen._C, **opts: Any
+    ) -> _constraint_sig[_autogen._C]:
+        return _constraint_sig.from_constraint(False, self, constraint, **opts)
+
+    def compare_indexes(
+        self,
+        metadata_index: Index,
+        reflected_index: Index,
+    ) -> ComparisonResult:
+        """Compare two indexes by comparing the signature generated by
+        ``create_index_sig``.
+
+        This method returns a ``ComparisonResult``.
+        """
+        msg: List[str] = []
+        unique_msg = self._compare_index_unique(
+            metadata_index, reflected_index
+        )
+        if unique_msg:
+            msg.append(unique_msg)
+        m_sig = self._create_metadata_constraint_sig(metadata_index)
+        r_sig = self._create_reflected_constraint_sig(reflected_index)
+
+        assert _autogen.is_index_sig(m_sig)
+        assert _autogen.is_index_sig(r_sig)
+
+        # The assumption is that the index have no expression
+        for sig in m_sig, r_sig:
+            if sig.has_expressions:
+                log.warning(
+                    "Generating approximate signature for index %s. "
+                    "The dialect "
+                    "implementation should either skip expression indexes "
+                    "or provide a custom implementation.",
+                    sig.const,
+                )
+
+        if m_sig.column_names != r_sig.column_names:
+            msg.append(
+                f"expression {r_sig.column_names} to {m_sig.column_names}"
+            )
+
+        if msg:
+            return ComparisonResult.Different(msg)
+        else:
+            return ComparisonResult.Equal()
+
+    def compare_unique_constraint(
+        self,
+        metadata_constraint: UniqueConstraint,
+        reflected_constraint: UniqueConstraint,
+    ) -> ComparisonResult:
+        """Compare two unique constraints by comparing the two signatures.
+
+        The arguments are two tuples that contain the unique constraint and
+        the signatures generated by ``create_unique_constraint_sig``.
+
+        This method returns a ``ComparisonResult``.
+        """
+        metadata_tup = self._create_metadata_constraint_sig(
+            metadata_constraint
+        )
+        reflected_tup = self._create_reflected_constraint_sig(
+            reflected_constraint
+        )
 
-    def create_unique_constraint_sig(
-        self, const: UniqueConstraint
-    ) -> Tuple[Any, ...]:
-        # order of col does not matters in an unique constraint
-        return tuple(sorted([col.name for col in const.columns]))
+        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}"
+            )
+        else:
+            return ComparisonResult.Equal()
 
     def _skip_functional_indexes(self, metadata_indexes, conn_indexes):
         conn_indexes_by_name = {c.name: c for c in conn_indexes}
@@ -695,21 +784,58 @@ class DefaultImpl(metaclass=ImplMeta):
         return reflected_object.get("dialect_options", {})
 
 
+class Params(NamedTuple):
+    token0: str
+    tokens: List[str]
+    args: List[str]
+    kwargs: Dict[str, str]
+
+
 def _compare_identity_options(
-    attributes, metadata_io, inspector_io, default_io
+    metadata_io: Union[schema.Identity, schema.Sequence, None],
+    inspector_io: Union[schema.Identity, schema.Sequence, None],
+    default_io: Union[schema.Identity, schema.Sequence],
+    skip: Set[str],
 ):
     # this can be used for identity or sequence compare.
     # default_io is an instance of IdentityOption with all attributes to the
     # default value.
+    meta_d = sqla_compat._get_identity_options_dict(metadata_io)
+    insp_d = sqla_compat._get_identity_options_dict(inspector_io)
+
     diff = set()
     ignored_attr = set()
-    for attr in attributes:
-        meta_value = getattr(metadata_io, attr, None)
-        default_value = getattr(default_io, attr, None)
-        conn_value = getattr(inspector_io, attr, None)
-        if conn_value != meta_value:
-            if meta_value == default_value:
-                ignored_attr.add(attr)
-            else:
-                diff.add(attr)
+
+    def check_dicts(
+        meta_dict: Mapping[str, Any],
+        insp_dict: Mapping[str, Any],
+        default_dict: Mapping[str, Any],
+        attrs: Iterable[str],
+    ):
+        for attr in set(attrs).difference(skip):
+            meta_value = meta_dict.get(attr)
+            insp_value = insp_dict.get(attr)
+            if insp_value != meta_value:
+                default_value = default_dict.get(attr)
+                if meta_value == default_value:
+                    ignored_attr.add(attr)
+                else:
+                    diff.add(attr)
+
+    check_dicts(
+        meta_d,
+        insp_d,
+        sqla_compat._get_identity_options_dict(default_io),
+        set(meta_d).union(insp_d),
+    )
+    if sqla_compat.identity_has_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]
+            getattr(inspector_io, "dialect_kwargs", {}),
+        )
+
     return diff, ignored_attr

alembic/ddl/mssql.py

@@ -51,16 +51,13 @@ class MSSQLImpl(DefaultImpl):
     batch_separator = "GO"
 
     type_synonyms = DefaultImpl.type_synonyms + ({"VARCHAR", "NVARCHAR"},)
-    identity_attrs_ignore = (
+    identity_attrs_ignore = DefaultImpl.identity_attrs_ignore + (
         "minvalue",
         "maxvalue",
         "nominvalue",
         "nomaxvalue",
         "cycle",
         "cache",
-        "order",
-        "on_null",
-        "order",
     )
 
     def __init__(self, *arg, **kw) -> None:

alembic/ddl/mysql.py

@@ -20,7 +20,6 @@ from .base import format_column_name
 from .base import format_server_default
 from .impl import DefaultImpl
 from .. import util
-from ..autogenerate import compare
 from ..util import sqla_compat
 from ..util.sqla_compat import _is_mariadb
 from ..util.sqla_compat import _is_type_bound
@@ -272,10 +271,12 @@ class MySQLImpl(DefaultImpl):
 
     def correct_for_autogen_foreignkeys(self, conn_fks, metadata_fks):
         conn_fk_by_sig = {
-            compare._fk_constraint_sig(fk).sig: fk for fk in conn_fks
+            self._create_reflected_constraint_sig(fk).unnamed_no_options: fk
+            for fk in conn_fks
         }
         metadata_fk_by_sig = {
-            compare._fk_constraint_sig(fk).sig: fk for fk in metadata_fks
+            self._create_metadata_constraint_sig(fk).unnamed_no_options: fk
+            for fk in metadata_fks
         }
 
         for sig in set(conn_fk_by_sig).intersection(metadata_fk_by_sig):