SQLAlchemy 2.1.6__py3-none-any.whl → 2.1.8__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.6"
+__version__ = "2.1.8"
 
 
 def __go(lcls: Any) -> None:

sqlalchemy/dialects/mssql/base.py

@@ -3553,35 +3553,27 @@ class MSDialect(default._BackendsMultiReflection, default.DefaultDialect):
         else:
             raise exc.NoSuchTableError(f"{owner}.{viewname}")
 
-    def _temp_table_name_like_pattern(self, tablename):
-        # LIKE uses '%' to match zero or more characters and '_' to match any
-        # single character. We want to match literal underscores, so T-SQL
-        # requires that we enclose them in square brackets.
-        return tablename + (
-            ("[_][_][_]%") if not tablename.startswith("##") else ""
-        )
-
     def _get_internal_temp_table_name(self, connection, tablename):
         # it's likely that schema is always "dbo", but since we can
         # get it here, let's get it.
         # see https://stackoverflow.com/questions/8311959/
         # specifying-schema-for-temporary-tables
 
+        # object_id() resolves a local temp table name only against the
+        # current session's tables (plus any ##global one), so the lookup
+        # neither sees nor locks other sessions' same-named temp tables in
+        # tempdb, as a scan of tempdb's catalog by name would.  See #13754.
         try:
             return connection.execute(
                 sql.text(
-                    "select table_schema, table_name "
-                    "from tempdb.information_schema.tables "
-                    "where table_name like :p1"
+                    "select s.name, o.name "
+                    "from tempdb.sys.objects as o "
+                    "join tempdb.sys.schemas as s "
+                    "on s.schema_id = o.schema_id "
+                    "where o.object_id = object_id(:qualified, 'U')"
                 ),
-                {"p1": self._temp_table_name_like_pattern(tablename)},
+                {"qualified": f"tempdb..[{tablename}]"},
             ).one()
-        except exc.MultipleResultsFound as me:
-            raise exc.UnreflectableTableError(
-                "Found more than one temporary table named '%s' in tempdb "
-                "at this time. Cannot reliably resolve that name to its "
-                "internal table name." % tablename
-            ) from me
         except exc.NoResultFound as ne:
             raise exc.NoSuchTableError(
                 "Unable to find a temporary table named '%s' in tempdb."

sqlalchemy/dialects/oracle/base.py

@@ -1932,7 +1932,7 @@ class OracleDDLCompiler(compiler.DDLCompiler):
     def define_constraint_cascades(self, constraint):
         text = ""
         if constraint.ondelete is not None:
-            text += " ON DELETE %s" % constraint.ondelete
+            text += self.define_constraint_ondelete_cascade(constraint)
 
         # oracle has no ON UPDATE CASCADE -
         # its only available via triggers

sqlalchemy/dialects/postgresql/array.py

@@ -29,6 +29,7 @@ from ...sql.visitors import InternalTraversal
 if TYPE_CHECKING:
     from ...engine.interfaces import Dialect
     from ...sql._typing import _ColumnExpressionArgument
+    from ...sql._typing import _CovariantTypeEngineArgument
     from ...sql._typing import _TypeEngineArgument
     from ...sql.elements import ColumnElement
     from ...sql.elements import Grouping
@@ -324,7 +325,7 @@ class ARRAY(sqltypes.ARRAY[_T]):
 
     def __init__(
         self,
-        item_type: _TypeEngineArgument[_T],
+        item_type: _CovariantTypeEngineArgument[_T],
         as_tuple: bool = False,
         dimensions: Optional[int] = None,
         zero_indexes: bool = False,
@@ -366,9 +367,7 @@ class ARRAY(sqltypes.ARRAY[_T]):
                 "Do not nest ARRAY types; ARRAY(basetype) "
                 "handles multi-dimensional arrays of basetype"
             )
-        if isinstance(item_type, type):
-            item_type = item_type()
-        self.item_type = item_type
+        self.item_type = sqltypes.to_instance(item_type)
         self.as_tuple = as_tuple
         self.dimensions = dimensions
         self.zero_indexes = zero_indexes

sqlalchemy/dialects/postgresql/base.py

@@ -2783,10 +2783,13 @@ class PGDDLCompiler(compiler.DDLCompiler):
 
     @util.memoized_property
     def _fk_ondelete_pattern(self):
+        # a keyword phrase, optionally followed by the column list accepted
+        # by SET NULL / SET DEFAULT.  column names may be double-quoted, as
+        # rendered by pg_get_constraintdef() when reflected
+        ident = r'(?:[\w$]+|"(?:[^"]|"")+")'
         return re.compile(
-            r"^(?:RESTRICT|CASCADE|SET (?:NULL|DEFAULT)(?:\s*\(.+\))?"
-            r"|NO ACTION)$",
-            re.I,
+            r"^\w+(?:\s+\w+)*"
+            rf"(?:\s*\(\s*{ident}(?:\s*,\s*{ident})*\s*\))?$"
         )
 
     def define_constraint_ondelete_cascade(self, constraint):

sqlalchemy/engine/base.py

@@ -129,6 +129,11 @@ class Connection(ConnectionEventsTarget, inspection.Inspectable["Inspector"]):
 
     _execution_options: _ExecuteOptions
 
+    # set to True at the class level by ConnectionEvents when listeners
+    # are associated with the Connection class; set at the instance level
+    # when listeners are associated with a specific Connection
+    _has_events: bool = False
+
     _transaction: Optional[RootTransaction]
     _nested_transaction: Optional[NestedTransaction]
 
@@ -167,10 +172,13 @@ class Connection(ConnectionEventsTarget, inspection.Inspectable["Inspector"]):
             # if _has_events is sent explicitly as False,
             # then don't join the dispatch of the engine; we don't
             # want to handle any of the engine's events in that case.
+            # the engine's _has_events is checked alongside our own at
+            # each event point; leave our own _has_events unset so that
+            # the class-level flag, set by listeners on the Connection
+            # class, takes effect
             self.dispatch = self.dispatch._join(engine.dispatch)
-        self._has_events = _has_events or (
-            _has_events is None and engine._has_events
-        )
+        else:
+            self._has_events = _has_events
 
         self._execution_options = engine._execution_options
 
@@ -181,6 +189,29 @@ class Connection(ConnectionEventsTarget, inspection.Inspectable["Inspector"]):
     # characteristics.LoggingTokenCharacteristic
     _message_formatter: Any = None
 
+    def _log_parameters(
+        self,
+        parameters: _AnyExecuteParams | None,
+        stats: str,
+        *,
+        ismulti: bool,
+    ) -> None:
+        if not self.engine.hide_parameters:
+            self._log_info(
+                "[%s] %r",
+                stats,
+                sql_util._repr_params(
+                    parameters,
+                    batches=10,
+                    ismulti=ismulti,
+                ),
+            )
+        else:
+            self._log_info(
+                "[%s] [SQL parameters hidden due to hide_parameters=True]",
+                stats,
+            )
+
     def _log_info(self, message: str, *arg: Any, **kw: Any) -> None:
         fmt = self._message_formatter
 
@@ -1893,22 +1924,10 @@ class Connection(ConnectionEventsTarget, inspection.Inspectable["Inspector"]):
 
                 stats = context._get_cache_stats()
 
-                if not self.engine.hide_parameters:
-                    self._log_info(
-                        "[%s] %r",
-                        stats,
-                        sql_util._repr_params(
-                            effective_parameters,
-                            batches=10,
-                            ismulti=context.executemany,
-                        ),
-                    )
-                else:
-                    self._log_info(
-                        "[%s] [SQL parameters hidden due to "
-                        "hide_parameters=True]",
-                        stats,
-                    )
+                self._log_parameters(
+                    effective_parameters, stats, ismulti=context.executemany
+                )
+
             if context.execute_style is ExecuteStyle.EXECUTEMANY:
                 effective_parameters = cast(
                     "_CoreMultiExecuteParams", effective_parameters
@@ -2080,22 +2099,7 @@ class Connection(ConnectionEventsTarget, inspection.Inspectable["Inspector"]):
                     else:
                         stats = f"insertmanyvalues{imv_stats}"
 
-                    if not self.engine.hide_parameters:
-                        self._log_info(
-                            "[%s] %r",
-                            stats,
-                            sql_util._repr_params(
-                                sub_params,
-                                batches=10,
-                                ismulti=False,
-                            ),
-                        )
-                    else:
-                        self._log_info(
-                            "[%s] [SQL parameters hidden due to "
-                            "hide_parameters=True]",
-                            stats,
-                        )
+                    self._log_parameters(sub_params, stats, ismulti=False)
 
                 for fn in do_execute_dispatch:
                     if fn(
@@ -2176,7 +2180,7 @@ class Connection(ConnectionEventsTarget, inspection.Inspectable["Inspector"]):
 
             if self._echo:
                 self._log_info(statement)
-                self._log_info("[raw sql] %r", parameters)
+                self._log_parameters(parameters, "raw sql", ismulti=False)
 
             for fn in (
                 ()

sqlalchemy/engine/url.py

@@ -576,7 +576,8 @@ class URL(NamedTuple):
 
         """
 
-        if not set(names).intersection(self.query):
+        names = set(names)
+        if not names.intersection(self.query):
             return self
 
         return URL(

sqlalchemy/ext/asyncio/session.py

@@ -12,6 +12,7 @@ from typing import Callable
 from typing import cast
 from typing import Concatenate
 from typing import Dict
+from typing import FrozenSet
 from typing import Generic
 from typing import Iterable
 from typing import Iterator
@@ -2164,6 +2165,76 @@ class AsyncSessionTransaction(
             self._raise_for_not_started()
         return self.sync_transaction
 
+    @property
+    def connections(self) -> FrozenSet[AsyncConnection]:
+        """The :class:`_asyncio.AsyncConnection` objects this transaction
+        has already acquired.
+
+        This is the asyncio-facing counterpart to
+        :attr:`_orm.SessionTransaction.connections`.
+
+        .. note::
+
+            A savepoint holds only the connections it has used itself.
+            To get all connections in the outer transaction, even while a
+            savepoint is active, use :meth:`.AsyncSession.get_transaction`
+            rather than :meth:`.AsyncSession.get_nested_transaction`::
+
+                root = async_session.get_transaction()
+                connections = root.connections
+
+        .. versionadded:: 2.1.7
+
+        .. seealso::
+
+            :attr:`_orm.SessionTransaction.connections` - main documentation
+            for "connections"
+
+        """
+        return frozenset(
+            engine.AsyncConnection._retrieve_proxy_for_target(conn)
+            for conn in self._sync_transaction().connections
+        )
+
+    def bound_connection(
+        self,
+        bindkey: Optional[_EntityBindKey[Any]] = None,
+        *,
+        bind: Optional[_AsyncSessionBind] = None,
+        **kw: Any,
+    ) -> AsyncConnection:
+        """Return the :class:`_asyncio.AsyncConnection` this transaction has
+        already acquired for the given bind key.
+
+        This is the asyncio-facing counterpart to
+        :meth:`_orm.SessionTransaction.bound_connection`.
+        :paramref:`.AsyncSessionTransaction.bound_connection.bind` is given
+        as an asyncio object, and is translated on the way in.
+
+        .. note::
+
+            A savepoint can return only a connection it has used itself.
+            To look up a connection in the outer transaction, even while a
+            savepoint is active, use :meth:`.AsyncSession.get_transaction`
+            rather than :meth:`.AsyncSession.get_nested_transaction`::
+
+                root = async_session.get_transaction()
+                connection = root.bound_connection(bindkey)
+
+        .. versionadded:: 2.1.7
+
+        .. seealso::
+
+            :meth:`_orm.SessionTransaction.bound_connection` - main
+            documentation for "bound_connection"
+
+        """
+        if bind is not None:
+            kw["bind"] = engine._get_sync_engine_or_connection(bind)
+        return engine.AsyncConnection._retrieve_proxy_for_target(
+            self._sync_transaction().bound_connection(bindkey, **kw)
+        )
+
     async def rollback(self) -> None:
         """Roll back this :class:`_asyncio.AsyncTransaction`."""
         await greenlet_spawn(self._sync_transaction().rollback)

sqlalchemy/inspection.py

@@ -104,11 +104,11 @@ def inspect(subject: Inspectable[_IN], raiseerr: bool = True) -> _IN: ...
 
 
 @overload
-def inspect(subject: Any, raiseerr: Literal[False] = ...) -> Optional[Any]: ...
+def inspect(subject: Any, raiseerr: Literal[True] = ...) -> Any: ...
 
 
 @overload
-def inspect(subject: Any, raiseerr: bool = True) -> Any: ...
+def inspect(subject: Any, raiseerr: bool) -> Optional[Any]: ...
 
 
 def inspect(subject: Any, raiseerr: bool = True) -> Any:

sqlalchemy/orm/context.py

@@ -14,6 +14,7 @@ from typing import AbstractSet
 from typing import Any
 from typing import cast
 from typing import Dict
+from typing import FrozenSet
 from typing import Iterable
 from typing import List
 from typing import Optional
@@ -84,6 +85,7 @@ if TYPE_CHECKING:
     from .query import Query
     from .session import _BindArguments
     from .session import Session
+    from .util import LoaderCriteriaOption
     from ..engine import Result
     from ..engine.interfaces import _CoreSingleExecuteParams
     from ..sql._typing import _ColumnsClauseArgument
@@ -1115,6 +1117,13 @@ class _ORMSelectCompileState(_ORMCompileState, SelectState):
     _explicit_correlate_froms: AbstractSet[FromClause] = util.EMPTY_SET
     _implicit_correlate_froms: AbstractSet[FromClause] = util.EMPTY_SET
 
+    # with_loader_criteria() options whose criteria contain this SELECT,
+    # either directly or within an enclosing SELECT; see
+    # LoaderCriteriaOption._should_include()
+    _containing_loader_criteria: FrozenSet[LoaderCriteriaOption] = (
+        util.EMPTY_SET
+    )
+
     @classmethod
     def _create_orm_context(
         cls,
@@ -1138,6 +1147,21 @@ class _ORMSelectCompileState(_ORMCompileState, SelectState):
                 kw.get("lateral", False),
             )
 
+            # the nearest enclosing ORM SELECT has already collected the
+            # options of all the SELECTs enclosing it
+            for entry in reversed(compiler.stack):
+                enclosing_state = entry.get("compile_state")
+                if isinstance(enclosing_state, _ORMSelectCompileState):
+                    self._containing_loader_criteria = (
+                        enclosing_state._containing_loader_criteria
+                    )
+                    break
+
+            if "for_loader_criteria" in statement._annotations:
+                self._containing_loader_criteria |= {
+                    statement._annotations["for_loader_criteria"]
+                }
+
         select_statement = statement
 
         # if we are a select() that was never a legacy Query, we won't

sqlalchemy/orm/mapper.py

@@ -2754,6 +2754,39 @@ class Mapper(
             for table, columns in self._cols_by_table.items()
         }
 
+    @HasMemoized.memoized_attribute
+    def _insert_orm_defaults(
+        self,
+    ) -> Mapping[FromClause, Sequence[Tuple[str, ColumnElement[Any], Any]]]:
+        """per table, (propkey, column, value) for ORM-level defaults on
+        column properties, i.e. dataclass defaults, which the column's own
+        default would not deliver to an INSERT.
+
+        Normally the ORM-level default is the same as the column's default.
+        They differ when the column is shared with another mapper, as is the
+        case for use_existing_column on single inheritance subclasses, #13748
+
+        """
+        return {
+            table: [
+                (prop.key, col, prop._default_scalar_value)
+                for col in columns
+                # None indicates no ORM-level default; a None value would
+                # be omitted from the INSERT in any case
+                if (prop := self._columntoproperty[col])._default_scalar_value
+                is not None
+                # skip if the column's own default already delivers the
+                # same value
+                and not (
+                    col.default is not None
+                    and col.default.compare_argument(
+                        prop._default_scalar_value
+                    )
+                )
+            ]
+            for table, columns in self._cols_by_table.items()
+        }
+
     @HasMemoized.memoized_attribute
     def _propkey_to_col(self):
         return {

sqlalchemy/orm/persistence.py

@@ -322,6 +322,19 @@ def _organize_states_for_delete(base_mapper, states, uowtransaction):
         yield (state, dict_, mapper, connection, update_version_id)
 
 
+def _set_insert_value(col, value, params, value_params):
+    """Place a value for an INSERT into either ``value_params``, if it is a
+    SQL expression, or ``params``, if it is a plain value.
+
+    """
+    if hasattr(value, "__clause_element__"):
+        value_params[col] = value.__clause_element__()
+    elif isinstance(value, sql.ClauseElement):
+        value_params[col] = value
+    else:
+        params[col.key] = value
+
+
 def _collect_insert_commands(
     table,
     states_to_insert,
@@ -351,19 +364,19 @@ def _collect_insert_commands(
             col = propkey_to_col[propkey]
             if value is None and col not in eval_none and not render_nulls:
                 continue
-            elif not bulk and (
-                hasattr(value, "__clause_element__")
-                or isinstance(value, sql.ClauseElement)
-            ):
-                value_params[col] = (
-                    value.__clause_element__()
-                    if hasattr(value, "__clause_element__")
-                    else value
-                )
-            else:
+            elif bulk:
                 params[col.key] = value
+            else:
+                _set_insert_value(col, value, params, value_params)
 
         if not bulk:
+            # ORM-level defaults, i.e. dataclass defaults, for columns that
+            # have no value, where the column's own default does not
+            # deliver the value, #13748
+            for propkey, col, value in mapper._insert_orm_defaults[table]:
+                if col.key not in params and col not in value_params:
+                    _set_insert_value(col, value, params, value_params)
+
             # for all the columns that have no default and we don't have
             # a value and where "None" is not a special value, add
             # explicit None to the INSERT.   This is a legacy behavior
@@ -1659,6 +1672,18 @@ def _postfetch(
     ):
         prefetch_cols = list(prefetch_cols) + [mapper.version_id_col]
 
+    if not isupdate:
+        # ORM-level defaults that _collect_insert_commands delivered to the
+        # INSERT for attributes with no value are handled in the same way as
+        # prefetched column defaults, #13748
+        orm_default_cols = [
+            col
+            for pkey, col, _ in mapper._insert_orm_defaults[table]
+            if dict_.get(pkey) is None and params.get(col.key) is not None
+        ]
+        if orm_default_cols:
+            prefetch_cols = list(prefetch_cols) + orm_default_cols
+
     refresh_flush = bool(mapper.class_manager.dispatch.refresh_flush)
     if refresh_flush:
         load_evt_attrs = []

sqlalchemy/orm/query.py

@@ -1307,7 +1307,7 @@ class Query(
             for prop in mapper.iterate_properties:
                 if (
                     isinstance(prop, relationships.RelationshipProperty)
-                    and prop.mapper is entity_zero.mapper  # type: ignore[union-attr]  # noqa: E501
+                    and prop.mapper is entity_zero.mapper
                 ):
                     property = prop  # type: ignore[assignment]  # noqa: A001
                     break
@@ -1316,7 +1316,7 @@ class Query(
                     "Could not locate a property which relates instances "
                     "of class '%s' to instances of class '%s'"
                     % (
-                        entity_zero.mapper.class_.__name__,  # type: ignore[union-attr]  # noqa: E501
+                        entity_zero.mapper.class_.__name__,
                         instance.__class__.__name__,
                     )
                 )
@@ -1325,7 +1325,7 @@ class Query(
             with_parent(
                 instance,
                 property,  # type: ignore[arg-type]
-                entity_zero.entity,  # type: ignore[union-attr]
+                entity_zero.entity,
             )
         )
 

sqlalchemy/orm/relationships.py

@@ -667,7 +667,7 @@ class RelationshipProperty(
 
         def _memoized_attr_entity(self) -> _InternalEntityType[_PT]:
             if self._of_type:
-                return inspect(self._of_type)  # type: ignore[return-value]
+                return inspect(self._of_type)  # type: ignore[no-any-return]
             else:
                 return self.prop.entity
 
@@ -1914,22 +1914,38 @@ class RelationshipProperty(
             self._attribute_options.dataclasses_default_factory
             is not _NoArg.NO_ARG
         ):
+            default_factory = (
+                self._attribute_options.dataclasses_default_factory
+            )
+
             # write only / dynamic relationships have no collection_class,
             # however they accept a list of objects when assigned, so
             # ``list`` is the expected default_factory for these
-            expected_default_factory = (
+            exact_default_factory = (
                 list if is_write_only or is_dynamic else self.collection_class
             )
 
-            if (
-                self._attribute_options.dataclasses_default_factory
-                is not expected_default_factory
+            # the plain list / set / dict that a custom collection class
+            # acts as is also accepted, such as ``dict`` for
+            # attribute_keyed_dict()
+            plain_collection_type = util.duck_type_collection(
+                exact_default_factory
+            )
+            if plain_collection_type is exact_default_factory:
+                plain_collection_type = None
+
+            if default_factory is not exact_default_factory and (
+                plain_collection_type is None
+                or default_factory is not plain_collection_type
             ):
+                expected = str(exact_default_factory)
+                if plain_collection_type is not None:
+                    expected += f" or {plain_collection_type}"
                 raise sa_exc.ArgumentError(
                     "For relationship "
                     f"{self._format_as_string(cls, key)} using "
                     "dataclass options, default_factory must be exactly "
-                    f"{expected_default_factory}"
+                    f"{expected}"
                 )
 
     @util.preload_module("sqlalchemy.orm.mapper")