SQLAlchemy 2.1.0rc2__py3-none-any.whl → 2.1.1__py3-none-any.whl

sqlalchemy/__init__.py

@@ -285,7 +285,7 @@ from .types import Uuid as Uuid
 from .types import VARBINARY as VARBINARY
 from .types import VARCHAR as VARCHAR
 
-__version__ = "2.1.0rc2"
+__version__ = "2.1.1"
 
 
 def __go(lcls: Any) -> None:

sqlalchemy/dialects/mssql/mssqlpython.py

@@ -101,9 +101,6 @@ class MSDialect_mssqlpython(MSDialect):
         }
     )
 
-    # used by pyodbc _ms_numeric_pyodbc class
-    _need_decimal_fix = True
-
     colspecs = util.update_copy(
         MSDialect.colspecs,
         {
@@ -117,6 +114,18 @@ class MSDialect_mssqlpython(MSDialect):
         if not enable_pooling and self.dbapi is not None:
             self.loaded_dbapi.pooling(enabled=False)
 
+        # used by pyodbc _ms_numeric_pyodbc class.  mssql-python 1.15
+        # binds every Decimal as SQL_NUMERIC; prior versions bound Decimal
+        # values within the MONEY range as VARCHAR, so that very large and
+        # very small values needed to be passed as strings as well.  On
+        # 1.15 those strings are instead coerced to the NUMERIC type of
+        # the Decimal values alongside them, which overflows.
+        # a version which can't be determined is assumed to be an old one
+        version = self._dbapi_version_or_none
+        self._need_decimal_fix = bool(self.dbapi) and (
+            version is None or version < (1, 15)
+        )
+
     @classmethod
     def import_dbapi(cls) -> DBAPIModule:
         return __import__("mssql_python")
@@ -204,7 +213,7 @@ class MSDialect_mssqlpython(MSDialect):
     def retrieve_dbapi_version(
         self, dbapi: interfaces.DBAPIModule
     ) -> util.VersionInfo:
-        return util.parse_version_string(dbapi.version)
+        return util.parse_version_string(getattr(dbapi, "__version__", None))
 
     def _get_server_version_info(self, connection):
         vers = connection.exec_driver_sql("select @@version").scalar()

sqlalchemy/dialects/oracle/oracledb.py

@@ -600,6 +600,7 @@ from ...connectors.asyncio import AsyncAdapt_dbapi_connection
 from ...connectors.asyncio import AsyncAdapt_dbapi_cursor
 from ...connectors.asyncio import AsyncAdapt_dbapi_module
 from ...connectors.asyncio import AsyncAdapt_dbapi_ss_cursor
+from ...connectors.asyncio import AsyncAdapt_terminate
 from ...engine import default
 from ...util import await_
 
@@ -773,7 +774,9 @@ class AsyncAdapt_oracledb_ss_cursor(
             self._cursor = None  # type: ignore
 
 
-class AsyncAdapt_oracledb_connection(AsyncAdapt_dbapi_connection):
+class AsyncAdapt_oracledb_connection(
+    AsyncAdapt_terminate, AsyncAdapt_dbapi_connection
+):
     _connection: AsyncConnection
     __slots__ = ()
 
@@ -838,6 +841,12 @@ class AsyncAdapt_oracledb_connection(AsyncAdapt_dbapi_connection):
     def tpc_rollback(self, *args: Any, **kwargs: Any) -> Any:
         return await_(self._connection.tpc_rollback(*args, **kwargs))
 
+    async def _terminate_graceful_close(self) -> None:
+        await self._connection.close()
+
+    def _terminate_force_close(self) -> None:
+        self._connection.terminate()
+
 
 class OracledbAdaptDBAPI(AsyncAdapt_dbapi_module):
     def __init__(self, oracledb) -> None:
@@ -883,6 +892,14 @@ class OracleDialectAsync_oracledb(OracleDialect_oracledb):
 
     minimum_dbapi_version = util.VersionInfo((2, 0, 1))
 
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+        self.has_terminate = (
+            self._dbapi_version_or_none is not None
+            and self._dbapi_version_or_none >= (26, 0, 0)
+        )
+
     # thick_mode mode is not supported by asyncio, oracledb will raise
     @classmethod
     def import_dbapi(cls):
@@ -893,6 +910,12 @@ class OracleDialectAsync_oracledb(OracleDialect_oracledb):
     def get_driver_connection(self, connection):
         return connection._connection
 
+    def do_terminate(self, dbapi_connection) -> None:
+        if self.has_terminate:
+            dbapi_connection.terminate()
+        else:
+            super().do_terminate(dbapi_connection)
+
 
 dialect = OracleDialect_oracledb
 dialect_async = OracleDialectAsync_oracledb

sqlalchemy/dialects/postgresql/base.py

@@ -1179,6 +1179,12 @@ construct, the DBAPI's "autocommit" mode must be used::
 PostgreSQL Index Reflection
 ---------------------------
 
+Notes on Index reflection
+
+
+Implicit UNIQUE index for UNIQUE CONSTRAINT
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
 The PostgreSQL database creates a UNIQUE INDEX implicitly whenever the
 UNIQUE CONSTRAINT construct is used.   When inspecting a table using
 :class:`_reflection.Inspector`, the :meth:`_reflection.Inspector.get_indexes`
@@ -1189,8 +1195,38 @@ two constructs distinctly; in the case of the index, the key
 detected as mirroring a constraint.   When performing reflection using
 ``Table(..., autoload_with=engine)``, the UNIQUE INDEX is **not** returned
 in :attr:`_schema.Table.indexes` when it is detected as mirroring a
-:class:`.UniqueConstraint` in the :attr:`_schema.Table.constraints` collection
-.
+:class:`.UniqueConstraint` in the :attr:`_schema.Table.constraints` collection.
+
+.. _postgresql_invalid_index_reflection:
+
+Invalid indexes
+^^^^^^^^^^^^^^^
+
+Indexes marked "invalid" by PostgreSQL (i.e. an index that exists in the
+catalog, but is ignored by the query planner because it may be incomplete,
+while still being maintained on writes) remain present in reflection. The
+:meth:`_reflection.Inspector.get_indexes` and
+:meth:`_reflection.Inspector.get_multi_indexes` methods include
+``postgresql_invalid=True`` in the index's ``dialect_options`` dictionary when
+``pg_index.indisvalid`` is false. Valid indexes omit this flag.
+
+When reflecting a :class:`_schema.Table`, the flag, if present, is stored
+separately from DDL options on each reflected :class:`.Index`::
+
+    table = Table("my_table", MetaData(), autoload_with=engine)
+    for index in table.indexes:
+        if index.reflect_only_elements["postgresql"].get("invalid"):
+            print(index.name)
+
+The :attr:`.Index.reflect_only_elements` mapping is read-only. These values are
+not included in :attr:`.Index.dialect_kwargs` and do not affect DDL.
+
+An invalid index may be left by a failed ``CREATE INDEX CONCURRENTLY``, may
+still be building, or may be a partitioned index awaiting attachment of its
+partition indexes. This flag reports the state at reflection time; it does not
+request an index rebuild.
+
+.. versionadded:: 2.1
 
 Special Reflection Options
 --------------------------
@@ -1946,6 +1982,7 @@ from ...sql import functions
 from ...sql import roles
 from ...sql import sqltypes
 from ...sql import util as sql_util
+from ...sql.base import DialectKWArgConst
 from ...sql.compiler import InsertmanyvaluesSentinelOpts
 from ...sql.visitors import InternalTraversal
 from ...types import BIGINT
@@ -3666,6 +3703,7 @@ class PGDialect(default._BackendsMultiReflection, default.DefaultDialect):
                 "with": {},
                 "tablespace": None,
                 "nulls_not_distinct": None,
+                "invalid": DialectKWArgConst.REFLECTED_ONLY,
             },
         ),
         (
@@ -5269,6 +5307,7 @@ class PGDialect(default._BackendsMultiReflection, default.DefaultDialect):
                 pg_catalog.pg_index.c.indrelid,
                 pg_catalog.pg_class.c.relname,
                 pg_catalog.pg_index.c.indisunique,
+                pg_catalog.pg_index.c.indisvalid,
                 pg_catalog.pg_constraint.c.conrelid.is_not(None).label(
                     "has_constraint"
                 ),
@@ -5475,6 +5514,9 @@ class PGDialect(default._BackendsMultiReflection, default.DefaultDialect):
                             "indnullsnotdistinct"
                         ]
 
+                    if not row["indisvalid"]:
+                        dialect_options["postgresql_invalid"] = True
+
                     if dialect_options:
                         index["dialect_options"] = dialect_options
 

sqlalchemy/engine/interfaces.py

@@ -560,7 +560,7 @@ class ReflectedIndex(TypedDict):
     """
 
     dialect_options: NotRequired[Dict[str, Any]]
-    """Additional dialect-specific options detected for this index"""
+    """Additional dialect-specific options detected for this index."""
 
 
 class ReflectedTableComment(TypedDict):
@@ -1259,6 +1259,17 @@ class Dialect(EventTarget):
     here is so that third-party dialects that haven't yet implemented this
     feature continue to function in the old way.
 
+    Arguments that represent database state without any corresponding DDL,
+    but may nonetheless appear in a reflected set of arguments that should
+    be ignored by the construct, may make use of the
+    :attr:`.DialectKWArgConst.REFLECTED_ONLY` token as the default value.
+    Arguments passed to the schema object on such a key will be passed along
+    into the separate read-only collection
+    :attr:`.DialectKWArgs.reflect_only_elements` and should be omitted from
+    DDL rendering.
+
+    .. versionadded:: 2.1 Added :class:`.DialectKWArgConst`.
+
     .. seealso::
 
         :class:`.DialectKWArgs` - implementing base class which consumes

sqlalchemy/orm/_orm_constructors.py

@@ -642,6 +642,7 @@ def composite(
     return_none_on: Union[_NoArg, None, Callable[..., bool]] = _NoArg.NO_ARG,
     comparator_factory: Optional[Type[Composite.Comparator[_T]]] = None,
     active_history: bool = False,
+    column_template: Optional[str] = None,
     init: Union[_NoArg, bool] = _NoArg.NO_ARG,
     repr: Union[_NoArg, bool] = _NoArg.NO_ARG,  # noqa: A002
     default: Optional[Any] = _NoArg.NO_ARG,
@@ -667,6 +668,7 @@ def composite(
     return_none_on: Union[_NoArg, None, Callable[..., bool]] = _NoArg.NO_ARG,
     comparator_factory: Optional[Type[Composite.Comparator[_T]]] = None,
     active_history: bool = False,
+    column_template: Optional[str] = None,
     init: Union[_NoArg, bool] = _NoArg.NO_ARG,
     repr: Union[_NoArg, bool] = _NoArg.NO_ARG,  # noqa: A002
     default: Optional[Any] = _NoArg.NO_ARG,
@@ -691,6 +693,7 @@ def composite(
     return_none_on: Union[_NoArg, None, Callable[..., bool]] = _NoArg.NO_ARG,
     comparator_factory: Optional[Type[Composite.Comparator[_T]]] = None,
     active_history: bool = False,
+    column_template: Optional[str] = None,
     init: Union[_NoArg, bool] = _NoArg.NO_ARG,
     repr: Union[_NoArg, bool] = _NoArg.NO_ARG,  # noqa: A002
     default: Optional[Any] = _NoArg.NO_ARG,
@@ -716,6 +719,7 @@ def composite(
     return_none_on: Union[_NoArg, None, Callable[..., bool]] = _NoArg.NO_ARG,
     comparator_factory: Optional[Type[Composite.Comparator[_T]]] = None,
     active_history: bool = False,
+    column_template: Optional[str] = None,
     init: Union[_NoArg, bool] = _NoArg.NO_ARG,
     repr: Union[_NoArg, bool] = _NoArg.NO_ARG,  # noqa: A002
     default: Optional[Any] = _NoArg.NO_ARG,
@@ -785,6 +789,18 @@ def composite(
       :class:`.Composite.Comparator` which provides custom SQL
       clause generation for comparison operations.
 
+    :param column_template: A string template such as ``"person_%s"``,
+     containing exactly one ``%s`` placeholder, that's used to generate
+     column names for fields of a dataclass :paramref:`.composite.class_`
+     that don't otherwise have an explicit name.  Only supported for
+     dataclass-based composite classes.
+
+     .. seealso::
+
+        :ref:`composite_column_template`
+
+     .. versionadded:: 2.1
+
     :param doc:
       optional string that will be applied as the doc on the
       class-bound descriptor.
@@ -852,6 +868,7 @@ def composite(
         raiseload=raiseload,
         comparator_factory=comparator_factory,
         active_history=active_history,
+        column_template=column_template,
         info=info,
         doc=doc,
     )

sqlalchemy/orm/descriptor_props.py

@@ -208,6 +208,7 @@ class CompositeProperty(
 
     composite_class: Union[Type[_CC], Callable[..., _CC]]
     attrs: Tuple[_CompositeAttrType[Any], ...]
+    column_template: Optional[str]
 
     _generated_composite_accessor: CallableReference[
         Optional[Callable[[_CC], Tuple[Any, ...]]]
@@ -229,6 +230,7 @@ class CompositeProperty(
         deferred: bool = False,
         group: Optional[str] = None,
         comparator_factory: Optional[Type[Comparator[_CC]]] = None,
+        column_template: Optional[str] = None,
         info: Optional[_InfoType] = None,
         **kwargs: Any,
     ):
@@ -242,6 +244,17 @@ class CompositeProperty(
             self.composite_class = _class_or_attr  # type: ignore[assignment]
             self.attrs = attrs
 
+        if column_template is not None:
+            try:
+                column_template % "x"
+            except (TypeError, ValueError) as te:
+                raise sa_exc.ArgumentError(
+                    f"column_template {column_template!r} is not a valid "
+                    "template; expected a string containing exactly one "
+                    "'%s' placeholder"
+                ) from te
+        self.column_template = column_template
+
         self.return_none_on = return_none_on
         self.active_history = active_history
         self.deferred = deferred
@@ -428,6 +441,11 @@ class CompositeProperty(
                 decl_scan, registry, cls, originating_module, key
             )
         else:
+            if self.column_template is not None:
+                raise sa_exc.ArgumentError(
+                    "column_template is only supported when composite_class "
+                    "is a dataclass"
+                )
             for attr in self.attrs:
                 if (
                     isinstance(attr, (MappedColumn, schema.Column))
@@ -492,8 +510,12 @@ class CompositeProperty(
                     f"{self.composite_class.__name__} {len(insp.parameters)}"
                 )
             if attr is None:
-                # fill in missing attr spots with empty MappedColumn
-                attr = MappedColumn()
+                # fill in missing attr spots with empty MappedColumn,
+                # or one named from column_template if present
+                if self.column_template is not None:
+                    attr = MappedColumn(self.column_template % param.name)
+                else:
+                    attr = MappedColumn()
                 self.attrs += (attr,)
 
             if isinstance(attr, MappedColumn):

sqlalchemy/orm/strategies.py

@@ -66,6 +66,13 @@ if TYPE_CHECKING:
     from ..sql.elements import ColumnElement
 
 
+# sentinel for _LoadLazyAttribute.extra_criteria indicating that the loader
+# option had no additional criteria.  the attribute is otherwise a single
+# element returned by Load._generate_extra_criteria(), which has no
+# meaningful boolean value of its own.
+_NO_EXTRA_CRITERIA = None
+
+
 def _register_attribute(
     prop,
     mapper,
@@ -1233,7 +1240,7 @@ class _LazyLoader(
                     (
                         loadopt._generate_extra_criteria(context)
                         if loadopt._extra_criteria
-                        else None
+                        else _NO_EXTRA_CRITERIA
                     ),
                 ),
                 key,
@@ -1281,7 +1288,7 @@ class _LoadLazyAttribute:
         self.extra_criteria = extra_criteria
 
     def __getstate__(self):
-        if self.extra_criteria is not None:
+        if self.extra_criteria is not _NO_EXTRA_CRITERIA:
             util.warn(
                 "Can't reliably serialize a lazyload() option that "
                 "contains additional criteria; please use eager loading "
@@ -1291,7 +1298,7 @@ class _LoadLazyAttribute:
             "key": self.key,
             "strategy_key": self.strategy_key,
             "loadopt": self.loadopt,
-            "extra_criteria": (),
+            "extra_criteria": _NO_EXTRA_CRITERIA,
         }
 
     def __call__(self, state, passive=attributes.PASSIVE_OFF):

sqlalchemy/orm/util.py

@@ -10,6 +10,7 @@ from __future__ import annotations
 
 import enum
 import functools
+import itertools
 import re
 import types
 import typing
@@ -633,6 +634,41 @@ class ORMAdapter(sql_util.ColumnAdapter):
         return not entity or entity.isa(self.mapper) or self.mapper.isa(entity)
 
 
+def _is_alias_of_selectable(
+    selectable: FromClause, target: FromClause
+) -> bool:
+    """Return True if ``selectable`` is ``target``, or a plain alias of it,
+    including a flat alias of a join of the same structure and join types."""
+
+    if selectable is target or (
+        isinstance(selectable, expression.Alias)
+        and selectable.element is target
+    ):
+        return True
+
+    return all(
+        elem is tgt
+        or (isinstance(elem, expression.Alias) and elem.element is tgt)
+        or (
+            # zip_longest() pads the shorter of the two with None
+            elem is not None
+            and tgt is not None
+            and elem._is_join
+            and tgt._is_join
+            and elem.isouter == tgt.isouter
+            and elem.full == tgt.full
+        )
+        or (
+            isinstance(elem, expression.FromGrouping)
+            and isinstance(tgt, expression.FromGrouping)
+        )
+        for elem, tgt in itertools.zip_longest(
+            sql_util.surface_selectables(selectable),
+            sql_util.surface_selectables(target),
+        )
+    )
+
+
 class AliasedClass(
     inspection.Inspectable["AliasedInsp[_O]"], ORMColumnsClauseRole[_O]
 ):
@@ -718,9 +754,38 @@ class AliasedClass(
         nest_adapters = False
 
         if alias is None:
-            if insp.is_aliased_class and insp.selectable._is_subquery:
-                alias = insp.selectable.alias()
-            else:
+            if insp_is_aliased_class(insp):
+                if insp._is_with_polymorphic:
+                    # polymorphic arguments are only passed along with an
+                    # explicit selectable, by with_polymorphic() and
+                    # AliasedInsp._merge_with()
+                    assert (
+                        not with_polymorphic_mappers
+                        and with_polymorphic_discriminator is None
+                        and not represents_outer_join
+                    )
+
+                    # aliased() of a with_polymorphic() carries along its
+                    # polymorphic configuration, #13584
+                    with_polymorphic_mappers = insp.with_polymorphic_mappers
+                    with_polymorphic_discriminator = insp.polymorphic_on
+                    represents_outer_join = insp.represents_outer_join
+
+                if not _is_alias_of_selectable(
+                    insp.selectable, mapper._with_polymorphic_selectable
+                ):
+                    # aliased() of an aliased() that refers to a subquery,
+                    # CTE, with_polymorphic() or other selectable; alias
+                    # that selectable rather than the mapped table,
+                    # #13583, #13584
+                    alias = insp.selectable._anonymous_fromclause(
+                        name=name, flat=flat
+                    )
+                    adapt_on_names = adapt_on_names or insp._adapt_on_names
+                elif insp.selectable._is_subquery:
+                    alias = insp.selectable.alias()
+
+            if alias is None:
                 alias = (
                     mapper._with_polymorphic_selectable._anonymous_fromclause(
                         name=name,
@@ -925,6 +990,7 @@ class AliasedInsp(
     _adapter: ORMAdapter
     with_polymorphic_mappers: Sequence[Mapper[Any]]
     _with_polymorphic_entities: Sequence[AliasedInsp[Any]]
+    _adapt_on_names: bool
 
     _weak_entity: weakref.ref[AliasedClass[_O]]
     """the AliasedClass that refers to this AliasedInsp"""
@@ -2344,6 +2410,29 @@ def _cleanup_mapped_str_annotation(
     return annotation
 
 
+def _unresolved_annotation_is_mapped(
+    raw_annotation: _AnnotationScanType,
+) -> bool:
+    """given an un-resolvable annotation, guess if it's ``Mapped[]``.
+
+    Used only to decide whether a ``NameError`` raised while de-stringifying
+    is worth reporting as a mapping error.  The annotation may be a plain
+    string (``__future__`` annotations / explicitly quoted), a ``ForwardRef``
+    (:pep:`649` deferred annotations on Python 3.14 and above), or an
+    already-resolved object.
+
+    """
+    if isinstance(raw_annotation, str):
+        return "Mapped[" in raw_annotation
+    elif isinstance(raw_annotation, typing.ForwardRef):
+        return "Mapped[" in raw_annotation.__forward_arg__
+    else:
+        origin = typing.get_origin(raw_annotation)
+        return isinstance(origin, type) and issubclass(
+            origin, _MappedAnnotationBase
+        )
+
+
 def _extract_mapped_subtype(
     raw_annotation: Optional[_AnnotationScanType],
     cls: type,
@@ -2390,7 +2479,7 @@ def _extract_mapped_subtype(
             "module level. See chained stack trace for more hints."
         ) from ce
     except NameError as ne:
-        if raiseerr and "Mapped[" in raw_annotation:  # type: ignore[operator]
+        if raiseerr and _unresolved_annotation_is_mapped(raw_annotation):
             raise orm_exc.MappedAnnotationError(
                 f"Could not interpret annotation {raw_annotation}.  "
                 "Check that it uses names that are correctly imported at the "

sqlalchemy/sql/base.py

@@ -377,6 +377,31 @@ def _cloned_difference(a: Iterable[_CLE], b: Iterable[_CLE]) -> Set[_CLE]:
     }
 
 
+class DialectKWArgConst(Enum):
+    """Constants for dialect argument defaults in
+    :attr:`.DefaultDialect.construct_arguments`.
+
+    """
+
+    REFLECTED_ONLY = 1
+    """Mark a dialect argument as database state reported by reflection.
+
+    Applies to any construct that takes part in
+    :attr:`.DefaultDialect.construct_arguments`, such as :class:`.Table`,
+    :class:`.Column`, :class:`.Index` or :class:`.CheckConstraint`.  The
+    value is kept in the construct's read-only
+    :attr:`.DialectKWArgs.reflect_only_elements` mapping, separate from the
+    options used to generate DDL.
+
+    .. seealso::
+
+        :attr:`.DialectKWArgs.reflect_only_elements`
+
+    .. versionadded:: 2.1
+
+    """
+
+
 class _DialectArgView(MutableMapping[str, Any]):
     """A dictionary view of dialect-level arguments in the form
     <dialectname>_<argument_name>.
@@ -436,6 +461,46 @@ class _DialectArgView(MutableMapping[str, Any]):
         )
 
 
+class _ReflectOnlyView(Mapping[str, Mapping[str, Any]]):
+    """A read-only dictionary view of reflection-only dialect-level
+    arguments, keyed to <dialectname>, then <argument_name>.
+
+    A dialect name that has no reflection-only arguments present returns
+    an empty mapping.
+
+    """
+
+    __slots__ = ("obj",)
+
+    def __init__(self, obj: DialectKWArgs) -> None:
+        self.obj = obj
+
+    def __getitem__(self, key: str) -> Mapping[str, Any]:
+        # check membership first so that the lookup does not attempt
+        # to load a dialect
+        if key in self.obj.dialect_options:
+            return self.obj.dialect_options[key]._reflect_only_elements
+        else:
+            return EMPTY_DICT
+
+    def __contains__(self, key: object) -> bool:
+        return bool(
+            isinstance(key, str)
+            and key in self.obj.dialect_options
+            and self.obj.dialect_options[key]._reflect_only_elements
+        )
+
+    def __len__(self) -> int:
+        return sum(1 for _ in self)
+
+    def __iter__(self) -> Generator[str, None, None]:
+        return (
+            dialect_name
+            for dialect_name, args in self.obj.dialect_options.items()
+            if args._reflect_only_elements
+        )
+
+
 class _DialectArgDict(MutableMapping[str, Any]):
     """A dictionary view of dialect-level arguments for a specific
     dialect.
@@ -448,6 +513,10 @@ class _DialectArgDict(MutableMapping[str, Any]):
     def __init__(self) -> None:
         self._non_defaults: Dict[str, Any] = {}
         self._defaults: Dict[str, Any] = {}
+        self._reflection_only_keys: FrozenSet[str] = util.EMPTY_SET
+        self._reflect_only_elements: util.immutabledict[str, Any] = (
+            util.EMPTY_DICT
+        )
 
     def __len__(self) -> int:
         return len(set(self._non_defaults).union(self._defaults))
@@ -462,7 +531,12 @@ class _DialectArgDict(MutableMapping[str, Any]):
             return self._defaults[key]
 
     def __setitem__(self, key: str, value: Any) -> None:
-        self._non_defaults[key] = value
+        if key in self._reflection_only_keys:
+            self._reflect_only_elements = self._reflect_only_elements.union(
+                {key: value}
+            )
+        else:
+            self._non_defaults[key] = value
 
     def __delitem__(self, key: str) -> None:
         del self._non_defaults[key]
@@ -525,6 +599,11 @@ class DialectKWArgs:
             return else_
 
         if argument_name in registry.get(self.__class__, {}):
+            if (
+                argument_name
+                in self.dialect_options[dialect.name]._reflection_only_keys
+            ):
+                return else_
             if (
                 deprecated_fallback is None
                 or dialect.name == deprecated_fallback
@@ -646,6 +725,60 @@ class DialectKWArgs:
         """A synonym for :attr:`.DialectKWArgs.dialect_kwargs`."""
         return self.dialect_kwargs
 
+    @property
+    def reflect_only_elements(self) -> Mapping[str, Mapping[str, Any]]:
+        """A read-only collection of dialect-specific database state
+        reported by reflection, separate from DDL options.
+
+        Holds values for arguments whose
+        :attr:`.DefaultDialect.construct_arguments` default is
+        :attr:`.DialectKWArgConst.REFLECTED_ONLY`.  Like
+        :attr:`.DialectKWArgs.dialect_options`, this is a two-level nested
+        collection keyed to ``<dialect_name>`` and ``<argument_name>``; a
+        dialect name with no values present returns an empty mapping, for
+        example::
+
+            invalid = my_index.reflect_only_elements["postgresql"].get("invalid")
+
+        These values are not included in
+        :attr:`.DialectKWArgs.dialect_options` or
+        :attr:`.DialectKWArgs.dialect_kwargs` and take no part in DDL
+        compilation.  They are carried along to copies of the object, such
+        as those produced by :meth:`.Table.to_metadata`.
+
+        .. versionadded:: 2.1
+
+        .. seealso::
+
+            :attr:`.DialectKWArgConst.REFLECTED_ONLY`
+
+        """  # noqa: E501
+        return _ReflectOnlyView(self)
+
+    @property
+    def _reflect_only_kwargs(self) -> Dict[str, Any]:
+        """The contents of :attr:`.DialectKWArgs.reflect_only_elements` in
+        flat ``<dialect>_<argument>`` form, suitable to be passed to the
+        constructor of a copy of this object."""
+
+        return {
+            f"{dialect_name}_{key}": value
+            for dialect_name, elements in self.reflect_only_elements.items()
+            for key, value in elements.items()
+        }
+
+    def _copy_reflect_only_elements(self, other: DialectKWArgs) -> None:
+        """Copy the contents of :attr:`.DialectKWArgs.reflect_only_elements`
+        onto ``other``, a copy of this object."""
+
+        if "dialect_options" not in self.__dict__:
+            return
+        for dialect_name, args in self.dialect_options.items():
+            if args._reflect_only_elements:
+                other.dialect_options[dialect_name]._reflect_only_elements = (
+                    args._reflect_only_elements
+                )
+
     _kw_registry: util.PopulateDict[str, Optional[Dict[Any, Any]]] = (
         util.PopulateDict(_kw_reg_for_dialect)
     )
@@ -661,6 +794,13 @@ class DialectKWArgs:
             for cls in reversed(cls.__mro__):
                 if cls in construct_arg_dictionary:
                     d._defaults.update(construct_arg_dictionary[cls])
+        d._reflection_only_keys = frozenset(
+            key
+            for key, value in d._defaults.items()
+            if value is DialectKWArgConst.REFLECTED_ONLY
+        )
+        for key in d._reflection_only_keys:
+            del d._defaults[key]
         return d
 
     @util.memoized_property
@@ -676,10 +816,18 @@ class DialectKWArgs:
 
         .. versionadded:: 0.9.2
 
+        Arguments a dialect declares as
+        :attr:`.DialectKWArgConst.REFLECTED_ONLY` are not included in this
+        collection; they are available from
+        :attr:`.DialectKWArgs.reflect_only_elements`.
+
         .. seealso::
 
             :attr:`.DialectKWArgs.dialect_kwargs` - flat dictionary form
 
+            :attr:`.DialectKWArgs.reflect_only_elements` - database state
+            reported by reflection
+
         """
 
         return util.PopulateDict(self._kw_reg_for_dialect_cls)
@@ -714,6 +862,8 @@ class DialectKWArgs:
                 if (
                     "*" not in construct_arg_dictionary
                     and arg_name not in construct_arg_dictionary
+                    and arg_name
+                    not in construct_arg_dictionary._reflection_only_keys
                 ):
                     raise exc.ArgumentError(
                         "Argument %r is not accepted by "

sqlalchemy/sql/schema.py

@@ -265,6 +265,9 @@ class SchemaItem(SchemaVisitable):
     def _schema_item_copy(self, schema_item: _SI) -> _SI:
         if "info" in self.__dict__:
             schema_item.info = self.info.copy()
+        if isinstance(self, DialectKWArgs):
+            assert isinstance(schema_item, DialectKWArgs)
+            self._copy_reflect_only_elements(schema_item)
         schema_item.dispatch._update(self.dispatch)
         return schema_item
 
@@ -1766,6 +1769,7 @@ class Table(
                 ],
                 _table=table,
                 **index.kwargs,
+                **index._reflect_only_kwargs,
             )
         return self._schema_item_copy(table)
 
@@ -4655,6 +4659,7 @@ class Sequence(HasSchemaAttr, IdentityOptions, DefaultGenerator):
             for_update=self.for_update,
             **self._as_dict(),
             **self.dialect_kwargs,
+            **self._reflect_only_kwargs,
         )
 
     def _set_parent(self, parent: SchemaEventTarget, **kw: Any) -> None:

sqlalchemy/sql/selectable.py

@@ -1654,6 +1654,19 @@ class Join(roles.DMLTableRole, FromClause[_KeyColCC_co]):
         """
         return Select(self.left, self.right).select_from(self)
 
+    @staticmethod
+    def _flat_element_name(
+        name: Optional[str], element: FromClause
+    ) -> Optional[str]:
+        if name and isinstance(element, NamedFromClause):
+            if isinstance(element.name, _anonymous_label):
+                # an anonymous name can't be embedded within a new name;
+                # alias the element anonymously, #13583
+                return None
+            return f"{name}_{element.name}"
+        else:
+            return name
+
     @util.preload_module("sqlalchemy.sql.util")
     def _anonymous_fromclause(
         self, name: Optional[str] = None, flat: bool = False
@@ -1663,17 +1676,11 @@ class Join(roles.DMLTableRole, FromClause[_KeyColCC_co]):
             if isinstance(self.left, (FromGrouping, Join)):
                 left_name = name  # will recurse
             else:
-                if name and isinstance(self.left, NamedFromClause):
-                    left_name = f"{name}_{self.left.name}"
-                else:
-                    left_name = name
+                left_name = self._flat_element_name(name, self.left)
             if isinstance(self.right, (FromGrouping, Join)):
                 right_name = name  # will recurse
             else:
-                if name and isinstance(self.right, NamedFromClause):
-                    right_name = f"{name}_{self.right.name}"
-                else:
-                    right_name = name
+                right_name = self._flat_element_name(name, self.right)
             left_a, right_a = (
                 self.left._anonymous_fromclause(name=left_name, flat=flat),
                 self.right._anonymous_fromclause(name=right_name, flat=flat),
@@ -2291,7 +2298,10 @@ class CTE(
             name=name,
             recursive=self.recursive,
             nesting=self.nesting,
-            _cte_alias=self,
+            # an alias of an alias refers to the original CTE, #13583
+            _cte_alias=(
+                self._cte_alias if self._cte_alias is not None else self
+            ),
             _prefixes=self._prefixes,
             _suffixes=self._suffixes,
         )

sqlalchemy/testing/requirements.py

@@ -483,6 +483,19 @@ class SuiteRequirements(Requirements):
             "%(database)s %(does_support)s 'UPDATE ... RETURNING'",
         )
 
+    @property
+    def update_returning_dialect_not_supported(self):
+        """target database rejects UPDATE ... RETURNING when the dialect
+        reports that ``update_returning`` is not supported.
+
+        This is normally the case; it's false only where a server has
+        gained UPDATE ... RETURNING that the dialect doesn't implement
+        yet, so that the statement runs rather than raising.
+
+        """
+
+        return exclusions.open()
+
     @property
     def insert_executemany_returning(self):
         """target platform supports RETURNING when INSERT is used with
@@ -1698,6 +1711,12 @@ class SuiteRequirements(Requirements):
             lambda: not util.freethreading, "GIL-enabled build needed"
         )
 
+    @property
+    def freethreading(self):
+        return exclusions.only_if(
+            lambda: util.freethreading, "free-threaded build needed"
+        )
+
     @property
     def is64bit(self):
         return exclusions.only_if(lambda: util.is64bit, "64bit required")

sqlalchemy/testing/suite/test_dialect.py

@@ -707,6 +707,7 @@ class ReturningGuardsTest(fixtures.TablesTest):
             stmt, True, "id", connection.dialect.insert_executemany_returning
         )
 
+    @testing.requires.update_returning_dialect_not_supported
     def test_update_single(self, connection, run_stmt):
         t = self.tables.t
 

sqlalchemy/testing/suite/test_update_delete.py

@@ -100,6 +100,43 @@ class SimpleUpdateDeleteTest(fixtures.TablesTest):
             ),
         )
 
+    @testing.variation("unchanged", ["some", "all"])
+    @testing.requires.update_returning
+    def test_update_returning_unchanged_rows(self, connection, unchanged):
+        """test that UPDATE..RETURNING returns all rows matched by the WHERE
+        clause, including those where the new value is the same as the
+        existing value.
+
+        """
+        t = self.tables.plain_pk
+
+        if unchanged.some:
+            # WHERE matches 2, 1 row changed
+            stmt = t.update().where(t.c.id.in_([2, 3]))
+        elif unchanged.all:
+            # WHERE matches 1, 0 rows changed
+            stmt = t.update().where(t.c.id == 3)
+        else:
+            unchanged.fail()
+
+        r = connection.execute(
+            stmt.returning(t.c.id, t.c.data), dict(data="d3")
+        )
+
+        if unchanged.some:
+            eq_(sorted(r.all()), [(2, "d3"), (3, "d3")])
+        else:
+            eq_(r.all(), [(3, "d3")])
+
+        eq_(
+            connection.execute(t.select().order_by(t.c.id)).fetchall(),
+            (
+                [(1, "d1"), (2, "d3"), (3, "d3")]
+                if unchanged.some
+                else [(1, "d1"), (2, "d2"), (3, "d3")]
+            ),
+        )
+
     @testing.variation("criteria", ["rows", "norows", "emptyin"])
     @testing.requires.delete_returning
     def test_delete_returning(self, connection, criteria):

sqlalchemy/util/langhelpers.py

@@ -404,7 +404,13 @@ def _remove_linecache_entry(filename: str, entry: _LinecacheEntry) -> None:
     linecache within exec_code_in_env.
 
     """
-    linecache_cache = _linecache_cache_getter()
+    try:
+        linecache_cache = _linecache_cache_getter()
+    except AttributeError:
+        # linecache.cache is gone or is no longer a dict; as this runs
+        # from a finalizer, an exception here would only surface as an
+        # unraisable error
+        return
 
     if linecache_cache.get(filename) is entry:
         linecache_cache.pop(filename, None)

{sqlalchemy-2.1.0rc2.dist-info → sqlalchemy-2.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SQLAlchemy
-Version: 2.1.0rc2
+Version: 2.1.1
 Summary: Database Abstraction Library
 Author-email: Mike Bayer <mike_mp@zzzcomputing.com>
 License-Expression: MIT
@@ -86,28 +86,6 @@ Requires-Dist: sqlalchemy[asyncio]; extra == "aiosqlite"
 Requires-Dist: aiosqlite; extra == "aiosqlite"
 Provides-Extra: sqlcipher
 Requires-Dist: sqlcipher3_binary; extra == "sqlcipher"
-Provides-Extra: mssql-pymssql
-Requires-Dist: sqlalchemy[mssql-pymssql]; extra == "mssql-pymssql"
-Provides-Extra: mssql-pyodbc
-Requires-Dist: sqlalchemy[mssql-pyodbc]; extra == "mssql-pyodbc"
-Provides-Extra: mysql-connector
-Requires-Dist: sqlalchemy[mysql-connector]; extra == "mysql-connector"
-Provides-Extra: mariadb-connector
-Requires-Dist: sqlalchemy[mariadb-connector]; extra == "mariadb-connector"
-Provides-Extra: oracle-oracledb
-Requires-Dist: sqlalchemy[oracle-oracledb]; extra == "oracle-oracledb"
-Provides-Extra: postgresql-pg8000
-Requires-Dist: sqlalchemy[postgresql-pg8000]; extra == "postgresql-pg8000"
-Provides-Extra: postgresql-asyncpg
-Requires-Dist: sqlalchemy[postgresql-asyncpg]; extra == "postgresql-asyncpg"
-Provides-Extra: postgresql-psycopg2binary
-Requires-Dist: sqlalchemy[postgresql-psycopg2binary]; extra == "postgresql-psycopg2binary"
-Provides-Extra: postgresql-psycopg2cffi
-Requires-Dist: sqlalchemy[postgresql-psycopg2cffi]; extra == "postgresql-psycopg2cffi"
-Provides-Extra: postgresql-psycopg
-Requires-Dist: sqlalchemy[postgresql-psycopg]; extra == "postgresql-psycopg"
-Provides-Extra: postgresql-psycopgbinary
-Requires-Dist: sqlalchemy[postgresql-psycopgbinary]; extra == "postgresql-psycopgbinary"
 Dynamic: license-file
 
 SQLAlchemy

{sqlalchemy-2.1.0rc2.dist-info → sqlalchemy-2.1.1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-sqlalchemy/__init__.py,sha256=ZF4-5aXataCikWPmdUgorkau2S8Q4Qm8wff1v43c3do,13565
+sqlalchemy/__init__.py,sha256=ujjm1qYHLGW9VikKFzIo5e1rkEv3dyvpvw9r8X2htw8,13562
 sqlalchemy/events.py,sha256=vEDW04X_PMhMw5y0_95tbEzht3wua8_gnkMBJstYNRw,525
 sqlalchemy/exc.py,sha256=CKyzx9WSeWTYxueZLAtTFpZTNKSon0YlpGt9v-C8dl8,27503
 sqlalchemy/inspection.py,sha256=2mcgybcOVuQDB2bSIhwidrMteP9qOpEbmehyT2lrnt8,5661
@@ -18,7 +18,7 @@ sqlalchemy/dialects/mssql/aioodbc.py,sha256=RS9TZI4cDa9My9YHQbWW2nD3lUBx-s8aQZ7G
 sqlalchemy/dialects/mssql/base.py,sha256=w_R8bOhMkDa6qRQEyqbcRepL9RF2ZaP8jmovMtJ7Kac,159925
 sqlalchemy/dialects/mssql/information_schema.py,sha256=xoO2mKqq99GBN9osJaaYjLw3VQg4YB8rFrh5K6gGfaI,10544
 sqlalchemy/dialects/mssql/json.py,sha256=SgcLWK-xmy_5FCzgxoz2Xa8pnJemVFCuiNQ6aFApHyk,5338
-sqlalchemy/dialects/mssql/mssqlpython.py,sha256=eE8xmSOOpFSpBcdN5poKTXQjHh4eqSHfld4J3xRd_sE,7224
+sqlalchemy/dialects/mssql/mssqlpython.py,sha256=Boe6dsrabesUauvFUDIHeFXDXLBh3qi2pgqYCqI__eI,7832
 sqlalchemy/dialects/mssql/provision.py,sha256=KUTOtIMDDSi9R3uoIkTJiz_L3qUg6rFvDY6RzbgQsl4,6884
 sqlalchemy/dialects/mssql/pymssql.py,sha256=gIeA411WXjMKBg_Zg8pPc4alci3OqF9yTzVqwUaRCEY,4215
 sqlalchemy/dialects/mssql/pyodbc.py,sha256=hcyGiZb1dJUsegbwdYRjotr9UPvPZkXx9Bt-oorN8hc,25100
@@ -47,7 +47,7 @@ sqlalchemy/dialects/oracle/base.py,sha256=TDl2u3tL6QzbDHTbrmnltQhxgqOvrG9lVdLzV4
 sqlalchemy/dialects/oracle/cx_oracle.py,sha256=ITGIIUnkWFLm9jb4Z7VD1UrZGebVDORrvFY_ZzLPOqM,63932
 sqlalchemy/dialects/oracle/dictionary.py,sha256=hotIZctkY58oepLJ3NYQxWb44oMOurxsXgD2yhe3neg,19519
 sqlalchemy/dialects/oracle/json.py,sha256=JingOTIOeoiN9ymSFK7K5RnUefKzEgQzb5RlTNR8hfY,6218
-sqlalchemy/dialects/oracle/oracledb.py,sha256=YmwzKyC6KrwlBbd-URGiF6H8y9jAn1yI5ROKx7zTdWw,32268
+sqlalchemy/dialects/oracle/oracledb.py,sha256=uFfhyZazx2NcIwiTxeSy570LbJP6MV_GDjH0qAzP0Vk,32944
 sqlalchemy/dialects/oracle/provision.py,sha256=SiDKY7lVY5DsEMI1HEsoQe1cvzSL6AdrrliQtRonLgc,10685
 sqlalchemy/dialects/oracle/types.py,sha256=iVayov9nyK1MCIS26BvawokAn4PwIXIvdgH3j-JB56E,10894
 sqlalchemy/dialects/oracle/vector.py,sha256=v7zf88XX7ICORNuycw3da1d5G7KHmYytNtU6pI9Mv-4,10922
@@ -55,7 +55,7 @@ sqlalchemy/dialects/postgresql/__init__.py,sha256=uqvgSydDm7mbLeLtuARI8AXFkcHPCk
 sqlalchemy/dialects/postgresql/_psycopg_common.py,sha256=3btoOFqAcFmkectNE1Vgs7cOv4ccF28xIQZIDEYwOWA,7178
 sqlalchemy/dialects/postgresql/array.py,sha256=fHA_e2ez1SGHXa4BrXxbwCKMEkrDxn2GFzWJOjZrM0c,17907
 sqlalchemy/dialects/postgresql/asyncpg.py,sha256=IE2FNLURUBGvsofgGpqCJ6sx8Qd_alUsOz2Mb0YkeVk,42376
-sqlalchemy/dialects/postgresql/base.py,sha256=KVqJULdkTEiTD2XlLygkx7-7n0MVSFrtNFUtjY1Bbk4,212184
+sqlalchemy/dialects/postgresql/base.py,sha256=lxkSsXXsKcEGbQwGXVrF7lY2Vn5_iEetJ3T7gxrrYk0,213886
 sqlalchemy/dialects/postgresql/bitstring.py,sha256=-AowJ4DqlcT0PcFXML44TU4VND_hFuvtkwqUgKBcE1I,10603
 sqlalchemy/dialects/postgresql/dml.py,sha256=ckxPBWuAXCRKkSFvdmwEppvirvczFY-voniqgC3X6DA,12959
 sqlalchemy/dialects/postgresql/ext.py,sha256=ZgdhLnWDYcm3RQ0XlUtrsW3WF1YRcGmzEK-8sdg16wc,19603
@@ -90,7 +90,7 @@ sqlalchemy/engine/create.py,sha256=7G0aidSUYtghZjyv7C19TZcv_3o3pS62UXj-sRgsWVs,3
 sqlalchemy/engine/cursor.py,sha256=B5NmeqIEsOiPU8QaE4dXh7s1cSp2_5erukysuKs7ipo,85474
 sqlalchemy/engine/default.py,sha256=nwcP1u060d0UpKWUnpTqZNyeTX_5zsbJnEyS9v_M5Wg,94262
 sqlalchemy/engine/events.py,sha256=d-BzEd6M8dG8q22w3N6RX98cDcrANTgYyPjb5oFQznE,37475
-sqlalchemy/engine/interfaces.py,sha256=uCYsffQTxLc4yw8MtCwnhClHEfdghTIZWVtc4sRYcjo,121749
+sqlalchemy/engine/interfaces.py,sha256=JU4s2sK_LPKYM9Bqegb_eoAdUbTHO0-zSTN_sdtHwCU,122305
 sqlalchemy/engine/mock.py,sha256=i9J-z0NsL78VlqC85MRgo5SNNQU256UtEqficO3DCwY,4155
 sqlalchemy/engine/processors.py,sha256=uh6xb1ajvSzJufQDG2DmmMeP0VbgaeSHZOJPBSN3mwU,2710
 sqlalchemy/engine/reflection.py,sha256=vbRdfQ00pekzzdC3mwL6gwZ8iFnsVIbiawvDzoXTXBc,77136
@@ -129,7 +129,7 @@ sqlalchemy/ext/declarative/extensions.py,sha256=xcTpvgQo_DetyXNZtvnSZRaNTczVYIUh
 sqlalchemy/future/__init__.py,sha256=9pngQPAhogCThkP0WMqp43MYiMHQ8usQekk0IBhrUYw,513
 sqlalchemy/future/engine.py,sha256=CNIeZz-03GSBylYCTTam_Yk5kHD0EprfTxaNEgQc-0I,495
 sqlalchemy/orm/__init__.py,sha256=VhzsKd_oKslCrurAbQii-0IJ4wuDngQnLwnfZhb80GI,8791
-sqlalchemy/orm/_orm_constructors.py,sha256=ngXunJA_6WlDs-E8BaS2iYG5n_uEQpyfVy4fzdlXj3k,107250
+sqlalchemy/orm/_orm_constructors.py,sha256=73M6QqtNY8H2NgwMfUjooo8eoPP8DvyIC9wgCiWO44g,107879
 sqlalchemy/orm/_typing.py,sha256=dj7GE9yxelGlP5XeJXAH3VHNawd6eBxcJyoQht0tVS8,5012
 sqlalchemy/orm/attributes.py,sha256=SJLVDunnq00povV2vfZq_b7c9wTWv0PSaV7W7Gx9YmM,93774
 sqlalchemy/orm/base.py,sha256=W8nHDIrPiFsRwiePCiSPRYLepUgM_gTsFi2UgvuFyeI,28350
@@ -140,7 +140,7 @@ sqlalchemy/orm/context.py,sha256=F1poIa-NftQTO_cNUfSnbJKjbPQs9kWy6tBEyznTD_8,120
 sqlalchemy/orm/decl_api.py,sha256=gK5IGcbAXMdCN6SzprewMhfbXiZe1yO1Ghv2y2z3EHA,78721
 sqlalchemy/orm/decl_base.py,sha256=IQzfu1cySobZg0-Boy3HQs11rO-hYrU1D6q6ERIXOPc,87150
 sqlalchemy/orm/dependency.py,sha256=gqUUJi7LMF2RIEvq7hw_w-WfbpW8CXzSaDW5QTW5NlQ,47739
-sqlalchemy/orm/descriptor_props.py,sha256=JI6I8frxACHtNIPdxTYBNfTMcbvRK1lOaqkCKpsA_0Q,41430
+sqlalchemy/orm/descriptor_props.py,sha256=2R4NUuPIyinL5RrTbOAYebb3ZJNJLnT6_J2QCWy0nEM,42407
 sqlalchemy/orm/dynamic.py,sha256=7wyr0eM7xIRqWQk6jcoHjqGYatORwImRbrysJhQaGm8,9968
 sqlalchemy/orm/evaluator.py,sha256=DkKS71DYkzZRtxXRh-8pCyup_X7Xfbi9FjWHceTicOA,12352
 sqlalchemy/orm/events.py,sha256=fiDZRyN3-ikjkQEOypuADlkc_Jb9NXZEdd_wIAiikrI,131318
@@ -160,11 +160,11 @@ sqlalchemy/orm/scoping.py,sha256=eGXEv3sthVrBau1t7XCy-Irq9DA1uc7vpqw0IulAwjk,811
 sqlalchemy/orm/session.py,sha256=6-nextPWqVjwA7hW79oozm6pXbGHXF7Js3HLfJcgyUQ,203522
 sqlalchemy/orm/state.py,sha256=IxVE17w39HuK_U3vYKEGry-TE53ptfdCVuZmHjKn2MM,38600
 sqlalchemy/orm/state_changes.py,sha256=zbtHp9OaZhU80uTQSPyiDyQuCOQZsYil4mdiRa0Lvrw,6809
-sqlalchemy/orm/strategies.py,sha256=RPUiG0tvUt_gBPZo2Q0sFDVDXULt0idb4kbMGm8wxKI,124067
+sqlalchemy/orm/strategies.py,sha256=PSEGq2fvV8YECRp03L5LSlsIMMFgoUGug-quSU0ksPQ,124396
 sqlalchemy/orm/strategy_options.py,sha256=Wzfd8hB-Xqd5eubYNfIfcsjzdd9DOFpsI0V4cvHUZ6k,89057
 sqlalchemy/orm/sync.py,sha256=j1v5g0M_0_cSKiv6UEek-DhPWAL9eSpc4hY9Z14c988,5785
 sqlalchemy/orm/unitofwork.py,sha256=ewxWWxVZw62LndJL0K_L3VFaACe_9m7ub0w-j2vyIjU,27135
-sqlalchemy/orm/util.py,sha256=CEiDtniU_ZKILpHr80rOptdRvjoecB3XKnFO9wcP3N4,83424
+sqlalchemy/orm/util.py,sha256=hyHPD38nPxcJ7OpoJMMHW4kG4hWx-xj9OXTtY2D-gDs,86884
 sqlalchemy/orm/writeonly.py,sha256=LAbF6qIkV6agnH6f9piLFdsPvdewLsvhEagNebd-Kig,23096
 sqlalchemy/pool/__init__.py,sha256=h3EJgaBrR5w7aTqbf9cH8j3qf64jKj4fGe7nQ61jKNg,1714
 sqlalchemy/pool/base.py,sha256=ZRhJfpRiCBE8yqlrDPY5_NgiASxZ711FSHM3T6NtRLA,53716
@@ -181,7 +181,7 @@ sqlalchemy/sql/_typing.py,sha256=jDHln_-yp5AqbFY_B1uyFwuWAxrYF_iTJZ-KAb54tgI,140
 sqlalchemy/sql/_util_cy.pxd,sha256=JEkdMfO03ulZoZSalWA0goLog-TxIfEuXkZZadW0ZGg,349
 sqlalchemy/sql/_util_cy.py,sha256=vluLhp88b-vWkXIuZb971L9oRao7mlMDHk-DUGKGgIA,3871
 sqlalchemy/sql/annotation.py,sha256=gkFPOq3qGo6fahIxTwXgxCdcEyiD8W4CH0q01d1E0mo,18487
-sqlalchemy/sql/base.py,sha256=WaVrLBZxiniheZM4K8YgEjw-ebzumV01ApKouYslEGo,93319
+sqlalchemy/sql/base.py,sha256=1xkh7mgC25GVZS8tczZbwDAxRvdumoaW3UPrJXbynbQ,98615
 sqlalchemy/sql/cache_key.py,sha256=OihJqOVsdU0F_IShr0FIptTRHtIlM1UIZ_5LR8LQd0Q,28872
 sqlalchemy/sql/coercions.py,sha256=XyV6wyiIHHD6ViGdZhLMQ8OVWNk4_LyBvv15t504UYI,39144
 sqlalchemy/sql/compiler.py,sha256=7xY9nqfs7_svpZqFNjxF4KOh2sVJtBE0ws1_XuQTlv0,299616
@@ -197,8 +197,8 @@ sqlalchemy/sql/lambdas.py,sha256=msXSQmXp2sVWDalooJBcm5xKXdLjSlf5vyNX8vdOq3A,494
 sqlalchemy/sql/naming.py,sha256=qBLfM2BizVlnFrDTcZ2AzTiUMml281BiOHRD-Qw1uXg,6705
 sqlalchemy/sql/operators.py,sha256=91HJboxRkDFNHx9JlpO9hsss7wqTfeoANOxjMFszTt0,87215
 sqlalchemy/sql/roles.py,sha256=QG4iNsYMCqjnMP3wt-5lEKxQZIh3uD2yVhurcS-z7VM,7857
-sqlalchemy/sql/schema.py,sha256=gwxTWZCMNYgDoWO6Wz8IzyjG0gBCb7rS243caC3xff8,262222
-sqlalchemy/sql/selectable.py,sha256=HasW5kz-dFy2eJq9_NZp-uV3RyZOFAJoBmgjvnfm-x0,257265
+sqlalchemy/sql/schema.py,sha256=55oc5r8Mqtkcr2ker8kHjlBSUSO3QhwyyqrG2gaFgu4,262469
+sqlalchemy/sql/selectable.py,sha256=xadnLUCBQFChbp2xMGjZrwXz86iOpUPBMGF8aPxYcgY,257659
 sqlalchemy/sql/sqltypes.py,sha256=Qa9Sl6iuLx0pB73O0LNgr_fauY8rGl_f9dU5wbOwth8,138409
 sqlalchemy/sql/traversals.py,sha256=xLBzv1qpTUjBTiTGMBvPUvl1UPffYSWMxV4wHgOM4i4,34355
 sqlalchemy/sql/type_api.py,sha256=ZWQkgF2vH61G4qNfv2cREPOUXeM5o0QaOHWkb1cmILo,88622
@@ -217,7 +217,7 @@ sqlalchemy/testing/pickleable.py,sha256=gXgySNI39dUcuNY6e-vM9HFKxQ7Uva7NVZgeYyNY
 sqlalchemy/testing/profiles_file.py,sha256=sxwF-c6Wd6IBEMHpU1QSdsouyCX7b-4EWWsTTdD8m4w,11349
 sqlalchemy/testing/profiling.py,sha256=pCeurQNGnsyMHotKuaT8GM8Aq_p1JADaIXPsWsvEJ9w,9159
 sqlalchemy/testing/provision.py,sha256=pOMK51WaXJyWAh48HbBjgywDPLk02pSS7rHQqoMLulI,18628
-sqlalchemy/testing/requirements.py,sha256=8DWnBaSsTESvXVF3QfFTZAMZKtro4CMKfgDQbcPb93I,57095
+sqlalchemy/testing/requirements.py,sha256=gX6WD4YhhOSF1f8Hmc3Fl0odNQKqXlJuAxO4PK1G1c0,57705
 sqlalchemy/testing/schema.py,sha256=49x-TXARL2k8oIiaSzyGxXG5fh7vJOuBoUv5h9YTfKo,5360
 sqlalchemy/testing/util.py,sha256=vbd6v3shfmdxqnqbL0K_hg-yi-ou5Fe9FpkUZeCEyUk,15809
 sqlalchemy/testing/warnings.py,sha256=j8GWiP-yraCW0Ig5iJxAa5ekN82ZWqcQWyR-BUb4MZA,1546
@@ -233,7 +233,7 @@ sqlalchemy/testing/plugin/pytestplugin.py,sha256=swDvlVLofRYz3Q-w-svvHgdWIPoS_bv
 sqlalchemy/testing/suite/__init__.py,sha256=jLYLmFQ6k0Fn7N2iPrbXwzJMKDSe4oMdmD-AC6yu3ws,726
 sqlalchemy/testing/suite/test_cte.py,sha256=7AnV9dR9h76JWY0yWuyeQT-5GQsYbNMz3q2SG8IA_R4,7276
 sqlalchemy/testing/suite/test_ddl.py,sha256=03nV2s8lfcCw4Czq6pkHl0ZGho8KyFe_C-f0HthP3B0,13010
-sqlalchemy/testing/suite/test_dialect.py,sha256=b8jmV4F2mnBAxN_a5v430WcBJU9aDlB0OTIqmlliBRA,24215
+sqlalchemy/testing/suite/test_dialect.py,sha256=D72O2WP7iinte5psWDaJXO4uRyKZNVRTK4FaxxO9fy0,24276
 sqlalchemy/testing/suite/test_insert.py,sha256=tapEYecSPKqL8xrjlcQzDOfbWdKJz9ldT7pRi0biDeM,18824
 sqlalchemy/testing/suite/test_reflection.py,sha256=Em0XdladxD6Lk9YH6ZQUw0cdEvkaXJfEPs-1E21xVn0,128866
 sqlalchemy/testing/suite/test_results.py,sha256=Aw8RK5CX1y39wDK6U8ub8PX9OYe8aoBCBCohjVPvRks,22499
@@ -243,7 +243,7 @@ sqlalchemy/testing/suite/test_sequence.py,sha256=8a6UO3pjRFnQ23ELG9m5cMMRoD3iD7a
 sqlalchemy/testing/suite/test_table_via_select.py,sha256=ZMJKUhAiqIzTKyK9J2cA_rvTij7CUt77d6o5sqDdrkc,21706
 sqlalchemy/testing/suite/test_types.py,sha256=zhL-us3ReUkX_klkbjYz0ve8op2ODSRTVLDo7OgWy38,72577
 sqlalchemy/testing/suite/test_unicode_ddl.py,sha256=tVLf9RqCJe-CsyhCWL9d-WuWazDx5iWYzoBrSCbgjXs,6141
-sqlalchemy/testing/suite/test_update_delete.py,sha256=xUHytwsMyvJcH3UhzmvGpzix7yBbQ-0thmlEpF-eNI8,4008
+sqlalchemy/testing/suite/test_update_delete.py,sha256=llAnxDGvbK-C7CzEXbSNEjczhOSL1sKTLuzGyJahqV8,5195
 sqlalchemy/util/__init__.py,sha256=9e3x2jLp1offzq2pWK5xIHLVQXkQtBIGDmqP9ePNS_4,8621
 sqlalchemy/util/_collections.py,sha256=kYBmJwkf3SSOmVyAPvRULLOM_3JmfXVWnxxEkEkgrUw,19157
 sqlalchemy/util/_collections_cy.pxd,sha256=DjGW5D9N6Dv_wXdIscNTGKttmjcJBCSdz5lTHtvbe2o,291
@@ -254,15 +254,15 @@ sqlalchemy/util/compat.py,sha256=9_xMEtXJsbe5IWgKbqRT9u6bdgmq47c_xXc4FtFmxcc,891
 sqlalchemy/util/concurrency.py,sha256=MpIMr-DqUnsYool27DfOeIMXndyzdWe_JnsktAYxLSc,8849
 sqlalchemy/util/cython.py,sha256=mfWXvmFqP4y3eiA2kGgcgV5GR5sTZfOob32UGY1BYA4,1968
 sqlalchemy/util/deprecations.py,sha256=9X3kYnZcVCEf1hyWU14_RNFahgUejlaLQX78B4UbhP8,12041
-sqlalchemy/util/langhelpers.py,sha256=K-RZycZ2NDVGsnDMyg76HLKWifon1R0P-P2GYYdCYdw,84350
+sqlalchemy/util/langhelpers.py,sha256=HldAht7neroRJLZhgTFmw8wgmzVMYNIkKw7OkcwD9hw,84574
 sqlalchemy/util/preloaded.py,sha256=DMfxtGeRyWpnUN3T9NvFdkPkTBPmruWOnUjLqrw8L0M,5975
 sqlalchemy/util/queue.py,sha256=9cMV3Dea0l5tfWIHw3LUE0L3knt48gtUP_C8fBKLQeo,9740
 sqlalchemy/util/tool_support.py,sha256=iZSwvKdF5pA8UtXuwbtln6dEDgerKJWasELSi7q6Epw,6136
 sqlalchemy/util/topological.py,sha256=yMpaA2s0JYIekQF4XKwzJzy8lVo-8yeo8o1J2xzxq48,3451
 sqlalchemy/util/typing.py,sha256=p3vOTJ4F7i3eqeFw7W_tayq88U0e53ZgOsCu7eNQ3lA,21125
-sqlalchemy-2.1.0rc2.dist-info/licenses/AUTHORS,sha256=3B2wtdF0Va3De2k_-OQJyagPYD5EFpWCVRjDb3hslj4,492
-sqlalchemy-2.1.0rc2.dist-info/licenses/LICENSE,sha256=6GK7W5BPtVE8PhQojXoloS6w7MeEegqWXTEOmpVefLk,1100
-sqlalchemy-2.1.0rc2.dist-info/METADATA,sha256=DZu361eBzD6yhsmMA9XBMZYfNWWR6FEH_gzf99lH1iY,10912
-sqlalchemy-2.1.0rc2.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-sqlalchemy-2.1.0rc2.dist-info/top_level.txt,sha256=rp-ZgB7D8G11ivXON5VGPjupT1voYmWqkciDt5Uaw_Q,11
-sqlalchemy-2.1.0rc2.dist-info/RECORD,,
+sqlalchemy-2.1.1.dist-info/licenses/AUTHORS,sha256=3B2wtdF0Va3De2k_-OQJyagPYD5EFpWCVRjDb3hslj4,492
+sqlalchemy-2.1.1.dist-info/licenses/LICENSE,sha256=6GK7W5BPtVE8PhQojXoloS6w7MeEegqWXTEOmpVefLk,1100
+sqlalchemy-2.1.1.dist-info/METADATA,sha256=gdC5VZ7rLaHkNA6O7U9JtIPm8CICTuMa-YwGJkLM5u0,9680
+sqlalchemy-2.1.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+sqlalchemy-2.1.1.dist-info/top_level.txt,sha256=rp-ZgB7D8G11ivXON5VGPjupT1voYmWqkciDt5Uaw_Q,11
+sqlalchemy-2.1.1.dist-info/RECORD,,