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

sqlalchemy/dialects/mssql/base.py

@@ -2098,6 +2098,13 @@ class MSSQLCompiler(compiler.SQLCompiler):
             self.process(binary.right, **kw),
         )
 
+    def visit_truediv_binary(self, binary, operator, **kw):
+        return (
+            self.process(binary.left, **kw)
+            + " / "
+            + f"({self.process(binary.right, **kw)} + 0.0)"
+        )
+
     def visit_true(self, expr, **kw):
         return "1"
 

sqlalchemy/dialects/oracle/base.py

@@ -2279,7 +2279,10 @@ class OracleDialect(default._BackendsMultiReflection, default.DefaultDialect):
             return self.get_isolation_level(dbapi_conn)
         except NotImplementedError:
             raise
-        except:
+        except Exception:
+            # Exception only; a bare except here also caught
+            # asyncio.CancelledError and KeyboardInterrupt, returning the
+            # default in place of propagating them
             return "READ COMMITTED"
 
     def _execute_reflection(

sqlalchemy/dialects/postgresql/asyncpg.py

@@ -886,14 +886,18 @@ class AsyncAdapt_asyncpg_connection(
 
         assert self._transaction is None
         try:
-            self._transaction = self._connection.transaction(
+            transaction = self._connection.transaction(
                 isolation=self.isolation_level,
                 readonly=self.readonly,
                 deferrable=self.deferrable,
             )
-            await self._transaction.start()
+            await transaction.start()
         except Exception as error:
             self._handle_exception(error)
+        else:
+            # only track the transaction once BEGIN has succeeded; a
+            # transaction that failed to start has nothing to roll back
+            self._transaction = transaction
 
     async def _call_and_discard(self, fn: Callable[[], Awaitable[Any]]):
         try:

sqlalchemy/dialects/postgresql/base.py

@@ -5070,8 +5070,9 @@ class PGDialect(default._BackendsMultiReflection, default.DefaultDialect):
 
         # https://www.postgresql.org/docs/current/static/sql-createtable.html
         return re.compile(
-            r"FOREIGN KEY \((.*?)\) "
-            rf"REFERENCES (?:({qtoken})\.)?({qtoken})\(((?:{qtoken}(?: *, *)?)+)\)"  # noqa: E501
+            rf"FOREIGN KEY \((.*?)(?:, PERIOD ({qtoken}))?\) "
+            rf"REFERENCES (?:({qtoken})\.)?({qtoken})"
+            rf"\(((?:{qtoken}(?: *, *)?)+)(?:, PERIOD ({qtoken}))?\)"
             r"[\s]?(MATCH (FULL|PARTIAL|SIMPLE)+)?"
             r"[\s]?(?:ON (UPDATE|DELETE) "
             r"(CASCADE|RESTRICT|NO ACTION|"
@@ -5089,9 +5090,11 @@ class PGDialect(default._BackendsMultiReflection, default.DefaultDialect):
 
         (
             constrained_columns,
+            constrained_period_column,
             referred_schema,
             referred_table,
             referred_columns,
+            referred_period_column,
             _,
             match,
             upddelkey1,
@@ -5103,6 +5106,13 @@ class PGDialect(default._BackendsMultiReflection, default.DefaultDialect):
             initially,
         ) = m
 
+        # TODO: the PERIOD designation of a temporal foreign key
+        # (PostgreSQL 18+) is not yet reflected
+        if constrained_period_column:
+            constrained_columns += f", {constrained_period_column}"
+        if referred_period_column:
+            referred_columns += f", {referred_period_column}"
+
         onupdate = (
             upddelval1
             if upddelkey1 == "UPDATE"

sqlalchemy/dialects/postgresql/named_types.py

@@ -339,6 +339,9 @@ class ENUM(NamedType, type_api.NativeForEmulated, sqltypes.Enum):
         kw.setdefault("_create_events", False)
         kw.setdefault("values_callable", impl.values_callable)
         kw.setdefault("omit_aliases", impl._omit_aliases)
+        kw.setdefault("sort_key_function", impl._sort_key_function)
+        kw.setdefault("create_constraint", impl.create_constraint)
+        kw.setdefault("length", impl.length)
         kw.setdefault("_adapted_from", impl)
 
         return cls(**kw)
@@ -514,6 +517,19 @@ class DOMAIN(NamedType, sqltypes.SchemaType):
     def __test_init__(cls):
         return cls("name", sqltypes.Integer)
 
+    def adapt(self, cls, **kw):
+        # the DOMAIN-specific arguments are keyword-only, which are not
+        # picked up by util.constructor_copy(); pass them explicitly so
+        # that copy(), to_metadata() and dialect adaptation retain them
+        kw.setdefault("collation", self.collation)
+        kw.setdefault("collation_schema", self.collation_schema)
+        kw.setdefault("default", self.default)
+        kw.setdefault("constraint_name", self.constraint_name)
+        kw.setdefault("not_null", self.not_null)
+        kw.setdefault("check", self.check)
+        kw.setdefault("create_type", self.create_type)
+        return super().adapt(cls, **kw)
+
 
 class CreateEnumType(schema._CreateDropBase):
     __visit_name__ = "create_enum_type"

sqlalchemy/engine/_result_cy.py

@@ -91,6 +91,37 @@ class _NoRow(Enum):
 _NO_ROW = _NoRow._NO_ROW
 
 
+def _list_map(
+    fn: Callable[[Any], _T], /
+) -> Callable[[Sequence[Any]], list[_T]]:
+    """Return a callable that applies ``fn`` to each element of a sequence,
+    returning a list.
+
+    This function serves to prevent a reference cycle between ``fn`` and
+    the closure scope of the function that defines it, when compiled with
+    Cython.
+
+    """
+    if cython.compiled:
+
+        def list_map(rows: Sequence[Any], /) -> list[_T]:
+            size: cython.Py_hash_t = len(rows)
+            i: cython.Py_ssize_t
+            result: list = PyList_New(size)
+            for i in range(size):
+                row: object = fn(rows[i])
+                Py_INCREF(row)
+                PyList_SET_ITEM(result, i, row)
+            return result
+
+    else:
+
+        def list_map(rows: Sequence[Any], /) -> list[_T]:
+            return [fn(row) for row in rows]
+
+    return list_map
+
+
 class BaseResultInternal(Generic[_R]):
     __slots__ = ()
 
@@ -245,22 +276,7 @@ class BaseResultInternal(Generic[_R]):
                 row = log_row(row)
             return row
 
-        if cython.compiled:
-
-            def many_rows(rows: Sequence[Any], /) -> list[Any]:
-                size: cython.Py_hash_t = len(rows)
-                i: cython.Py_ssize_t
-                result: list = PyList_New(size)
-                for i in range(size):
-                    row: object = single_row(rows[i])
-                    Py_INCREF(row)
-                    PyList_SET_ITEM(result, i, row)
-                return result
-
-        else:
-
-            def many_rows(rows: Sequence[Any], /) -> list[Any]:
-                return [single_row(row) for row in rows]
+        many_rows = _list_map(single_row)
 
         if flag == _FLAG_SCALAR_TO_TUPLE or has_log_row:
             # scalar-source rows have no tuple form; row logging requires
@@ -279,27 +295,12 @@ class BaseResultInternal(Generic[_R]):
                     input_row = tuple(input_row)
                 return input_row
 
-            if cython.compiled:
-
-                def interim_rows(rows: Sequence[Any], /) -> Sequence[Any]:
-                    size: cython.Py_hash_t = len(rows)
-                    i: cython.Py_ssize_t
-                    result: list = PyList_New(size)
-                    for i in range(size):
-                        row: object = single_interim_row(rows[i])
-                        Py_INCREF(row)
-                        PyList_SET_ITEM(result, i, row)
-                    return result
-
-            else:
-
-                def interim_rows(rows: Sequence[Any], /) -> Sequence[Any]:
-                    return [single_interim_row(row) for row in rows]
+            interim_rows = _list_map(single_interim_row)
 
         return single_row, many_rows, interim_rows  # type: ignore[return-value] # noqa: E501
 
     @HasMemoized_ro_memoized_attribute
-    def _iterator_getter(self) -> Callable[[], Iterator[_R]]:
+    def _iterator_getter(self) -> Callable[[Self], Iterator[_R]]:
         make_row = self._row_getter[0]
 
         post_creational_filter = self._post_creational_filter
@@ -308,7 +309,7 @@ class BaseResultInternal(Generic[_R]):
             uniques: set
             uniques, strategy = self._unique_strategy
 
-            def iterrows() -> Iterator[_R]:
+            def iterrows(self: Self) -> Iterator[_R]:
                 for raw_row in self._fetchiter_impl():
                     row = (
                         make_row(raw_row) if make_row is not None else raw_row
@@ -323,7 +324,7 @@ class BaseResultInternal(Generic[_R]):
 
         else:
 
-            def iterrows() -> Iterator[_R]:
+            def iterrows(self: Self) -> Iterator[_R]:
                 for raw_row in self._fetchiter_impl():
                     row = (
                         make_row(raw_row) if make_row is not None else raw_row
@@ -617,7 +618,7 @@ class BaseResultInternal(Generic[_R]):
             return row  # type: ignore[return-value]
 
     def _iter_impl(self) -> Iterator[_R]:
-        return self._iterator_getter()
+        return self._iterator_getter(self)
 
     def _next_impl(self) -> _R:
         row = self._onerow_getter(self)

sqlalchemy/engine/base.py

@@ -758,12 +758,19 @@ class Connection(ConnectionEventsTarget, inspection.Inspectable["Inspector"]):
         if self.closed:
             raise exc.ResourceClosedError("This Connection is closed")
 
-        if self._still_open_and_dbapi_connection_is_valid:
-            pool_proxied_connection = self._dbapi_connection
-            assert pool_proxied_connection is not None
-            pool_proxied_connection.invalidate(exception)
-
-        self._dbapi_connection = None
+        try:
+            if self._still_open_and_dbapi_connection_is_valid:
+                pool_proxied_connection = self._dbapi_connection
+                assert pool_proxied_connection is not None
+                pool_proxied_connection.invalidate(exception)
+        finally:
+            # this is always a hard invalidation, which closes the DBAPI
+            # connection; for an asyncio driver that close is an awaited
+            # terminate() which a cancellation can interrupt.  this
+            # Connection is invalidated regardless, so that nothing
+            # further, such as a rollback, is emitted on the DBAPI
+            # connection
+            self._dbapi_connection = None
 
     def detach(self) -> None:
         """Detach the underlying DB-API connection from its connection pool.
@@ -1257,30 +1264,33 @@ class Connection(ConnectionEventsTarget, inspection.Inspectable["Inspector"]):
 
         """
 
-        if self._transaction:
-            self._transaction.close()
-            skip_reset = True
-        else:
-            skip_reset = False
-
-        if self._dbapi_connection is not None:
-            conn = self._dbapi_connection
-
-            # as we just closed the transaction, close the connection
-            # pool connection without doing an additional reset
-            if skip_reset:
-                cast("_ConnectionFairy", conn)._close_special(
-                    transaction_reset=True
-                )
-            else:
-                conn.close()
-
-            # There is a slight chance that conn.close() may have
-            # triggered an invalidation here in which case
-            # _dbapi_connection would already be None, however usually
-            # it will be non-None here and in a "closed" state.
-            self._dbapi_connection = None
-        self.__can_reconnect = False
+        # if the rollback here raises, skip_reset stays False and the pool
+        # does its own reset of the connection, invalidating it if that
+        # fails also.  see #13657
+        skip_reset = False
+        try:
+            if self._transaction:
+                self._transaction.close()
+                skip_reset = True
+        finally:
+            if self._dbapi_connection is not None:
+                conn = self._dbapi_connection
+
+                # as we just closed the transaction, close the connection
+                # pool connection without doing an additional reset
+                if skip_reset:
+                    cast("_ConnectionFairy", conn)._close_special(
+                        transaction_reset=True
+                    )
+                else:
+                    conn.close()
+
+                # There is a slight chance that conn.close() may have
+                # triggered an invalidation here in which case
+                # _dbapi_connection would already be None, however usually
+                # it will be non-None here and in a "closed" state.
+                self._dbapi_connection = None
+            self.__can_reconnect = False
 
     # special case to handle mypy issue:
     # https://github.com/python/mypy/issues/20651

sqlalchemy/engine/characteristics.py

@@ -142,7 +142,7 @@ class LoggingTokenCharacteristic(ConnectionCharacteristic):
         if value:
             conn._message_formatter = lambda msg: "[%s] %s" % (value, msg)
         else:
-            del conn._message_formatter
+            conn._message_formatter = None
 
     def get_characteristic(
         self, dialect: Dialect, dbapi_conn: DBAPIConnection

sqlalchemy/engine/create.py

@@ -747,16 +747,26 @@ def create_engine(url: Union[str, _url.URL], **kwargs: Any) -> Engine:
             )
             c._execution_options = util.EMPTY_DICT
 
-            try:
-                dialect.initialize(c)
-            finally:
-                # note that "invalidated" and "closed" are mutually
-                # exclusive in 1.4 Connection.
-                if not c.invalidated and not c.closed:
-                    # transaction is rolled back otherwise, tested by
-                    # test/dialect/postgresql/test_dialect.py
-                    # ::MiscBackendTest::test_initial_transaction_state
-                    dialect.do_rollback(c.connection)
+            dialect.initialize(c)
+
+            # roll back only once initialize() has succeeded, rather than
+            # in a finally: block.  when initialize() raises, the DBAPI
+            # connection may be partway through an operation that c
+            # doesn't know about, such as psycopg's TypeInfo.fetch()
+            # interrupted by a cancellation; the rollback then fails
+            # and its error replaces the original one.  the pool closes
+            # the connection in that case, so there's nothing to roll
+            # back.
+            #
+            # note that "invalidated" and "closed" are mutually
+            # exclusive in 1.4 Connection.  c may be invalidated here if
+            # initialize() caught an error on a statement that was a
+            # disconnect.
+            if not c.invalidated and not c.closed:
+                # transaction is rolled back otherwise, tested by
+                # test/dialect/postgresql/test_dialect.py
+                # ::MiscBackendTest::test_initial_transaction_state
+                dialect.do_rollback(c.connection)
 
         # previously, the "first_connect" event was used here, which was then
         # scaled back if the "on_connect" handler were present.  now,

sqlalchemy/engine/default.py

@@ -2137,6 +2137,15 @@ class DefaultExecutionContext(ExecutionContext):
         ):
             self._setup_out_parameters(result)
 
+        if not result._soft_closed and not result._metadata.returns_rows:
+            # no results, get rowcount (which requires open cursor on
+            # some drivers) and release the cursor.  this applies to all
+            # statements that don't return rows, including DML, text(),
+            # DDL and SAVEPOINT
+            if self._rowcount is None:
+                self._rowcount = self.cursor.rowcount
+            result._soft_close()
+
         self._soft_closed = result._soft_closed
 
         if yp:
@@ -2272,12 +2281,6 @@ class DefaultExecutionContext(ExecutionContext):
             # the rows have all been fetched however.
             assert result._metadata.returns_rows
 
-        elif not result._metadata.returns_rows:
-            # no results, get rowcount
-            # (which requires open cursor on some drivers)
-            if self._rowcount is None:
-                self._rowcount = self.cursor.rowcount
-            result._soft_close()
         elif self.isupdate or self.isdelete:
             if self._rowcount is None:
                 self._rowcount = self.cursor.rowcount

sqlalchemy/ext/mutable.py

@@ -840,6 +840,12 @@ class MutableDict(Mutable, Dict[_KT, _VT]):
         dict.update(self, *a, **kw)
         self.changed()
 
+    def __ior__(  # type: ignore[override,misc]
+        self, other: Any
+    ) -> MutableDict[_KT, _VT]:
+        self.update(other)
+        return self
+
     if TYPE_CHECKING:
 
         @overload
@@ -949,6 +955,11 @@ class MutableList(Mutable, List[_T]):
         self.extend(x)
         return self
 
+    def __imul__(self, n: SupportsIndex) -> MutableList[_T]:
+        list.__imul__(self, n)
+        self.changed()
+        return self
+
     def insert(self, i: SupportsIndex, x: _T) -> None:
         list.insert(self, i, x)
         self.changed()

sqlalchemy/orm/__init__.py

@@ -37,6 +37,7 @@ from ._orm_constructors import outerjoin as outerjoin
 from ._orm_constructors import query_expression as query_expression
 from ._orm_constructors import relationship as relationship
 from ._orm_constructors import synonym as synonym
+from ._orm_constructors import unmapped_column as unmapped_column
 from ._orm_constructors import with_loader_criteria as with_loader_criteria
 from ._orm_constructors import with_polymorphic as with_polymorphic
 from .attributes import AttributeEventToken as AttributeEventToken
@@ -51,6 +52,7 @@ from .base import NotExtension as NotExtension
 from .base import ORMDescriptor as ORMDescriptor
 from .base import PassiveFlag as PassiveFlag
 from .base import SQLORMExpression as SQLORMExpression
+from .base import Unmapped as Unmapped
 from .base import WriteOnlyMapped as WriteOnlyMapped
 from .context import FromStatement as FromStatement
 from .context import QueryContext as QueryContext

sqlalchemy/orm/_orm_constructors.py

@@ -29,6 +29,7 @@ from .descriptor_props import Synonym
 from .interfaces import _AttributeOptions
 from .properties import MappedColumn
 from .properties import MappedSQLExpression
+from .properties import UnmappedColumn
 from .query import AliasOption
 from .relationships import _RelationshipArgumentType
 from .relationships import _RelationshipBackPopulatesArgument
@@ -395,6 +396,139 @@ def mapped_column(
     )
 
 
+def unmapped_column(
+    __name_pos: Optional[
+        Union[str, _TypeEngineArgument[Any], SchemaEventTarget]
+    ] = None,
+    __type_pos: Optional[
+        Union[_TypeEngineArgument[Any], SchemaEventTarget]
+    ] = None,
+    /,
+    *args: SchemaEventTarget,
+    init: Literal[False] = False,
+    nullable: Optional[
+        Union[bool, Literal[SchemaConst.NULL_UNSPECIFIED]]
+    ] = SchemaConst.NULL_UNSPECIFIED,
+    primary_key: Optional[bool] = False,
+    autoincrement: _AutoIncrementType = "auto",
+    use_existing_column: bool = False,
+    name: Optional[str] = None,
+    type_: Optional[_TypeEngineArgument[Any]] = None,
+    index: Optional[bool] = None,
+    unique: Optional[bool] = None,
+    info: Optional[_InfoType] = None,
+    default: Optional[Any] = _NoArg.NO_ARG,
+    insert_default: Optional[Any] = _NoArg.NO_ARG,
+    onupdate: Optional[Any] = None,
+    server_default: Optional[_ServerDefaultArgument] = None,
+    server_onupdate: Optional[_ServerOnUpdateArgument] = None,
+    quote: Optional[bool] = None,
+    system: bool = False,
+    comment: Optional[str] = None,
+    sort_order: Union[_NoArg, int] = _NoArg.NO_ARG,
+    **kw: Any,
+) -> UnmappedColumn[Any]:
+    r"""declare a :class:`_schema.Column` that is part of the
+    :class:`_schema.Table` for a :ref:`Declarative Table
+    <orm_declarative_table>` mapping, but which is not mapped by the ORM.
+
+    :func:`_orm.unmapped_column` is used with the :class:`_orm.Unmapped`
+    annotation::
+
+        class User(Base):
+            __tablename__ = "user"
+
+            id: Mapped[int] = mapped_column(primary_key=True)
+            name: Mapped[str]
+
+            legacy_name: Unmapped[str | None] = unmapped_column()
+
+    The resulting :class:`_schema.Column` is added to the
+    :class:`_schema.Table` in the same way as one produced by
+    :func:`_orm.mapped_column`, deriving its type and nullability from the
+    annotation, so that the column is present in DDL as well as for schema
+    comparison tools such as Alembic autogenerate.  However, the column is
+    excluded from the mapping, the attribute is removed from the class, and
+    when using :ref:`orm_declarative_native_dataclasses` it is not part of
+    the dataclass.
+
+    A bare ``Unmapped[]`` annotation with no right-hand side is equivalent
+    to ``unmapped_column()`` with no arguments; however, see the note at
+    :class:`_orm.Unmapped` regarding typing tools and dataclasses.
+
+    As the attribute is not part of the Python model, ORM and dataclass
+    oriented arguments of :func:`_orm.mapped_column`, such as
+    ``default_factory`` and ``deferred``, are not part of
+    :func:`_orm.unmapped_column`.
+
+    .. versionadded:: 2.1.5
+
+    .. seealso::
+
+        :ref:`orm_declarative_unmapped_column`
+
+    :param __name: String name to give to the :class:`_schema.Column`;
+     defaults to the attribute name.
+    :param __type: :class:`_types.TypeEngine` type or instance for the
+     :class:`_schema.Column`; if omitted, it is derived from the
+     annotation, or from a :class:`_schema.ForeignKey` if present.
+    :param \*args: Additional positional arguments such as
+     :class:`_schema.ForeignKey` and :class:`_schema.CheckConstraint`,
+     passed through to the :class:`_schema.Column`.
+    :param init: Always ``False``; this parameter is present so that
+     :pep:`681` typing tools omit the attribute from the ``__init__()``
+     method of :ref:`ORM mapped dataclasses
+     <orm_declarative_native_dataclasses>`.
+    :param nullable: whether the column is "NULL" or "NOT NULL"; if omitted,
+     derived from the annotation as with :func:`_orm.mapped_column`.
+    :param primary_key: indicates the :class:`_schema.Column` is part of the
+     table's primary key.  As the mapper requires that its primary key
+     columns be mapped, the columns that the mapper should use for the
+     identity of the class must then be indicated using the
+     :paramref:`_orm.Mapper.primary_key` parameter; see
+     :ref:`orm_declarative_unmapped_column` for an example.
+    :param autoincrement: Passed directly to the
+     :paramref:`_schema.Column.autoincrement` parameter.
+    :param use_existing_column: see
+     :paramref:`_orm.mapped_column.use_existing_column`.
+    :param default: Passed directly to the :paramref:`_schema.Column.default`
+     parameter.  As the attribute is not part of a dataclass, this is
+     strictly a Core column default.
+    :param insert_default: synonym for
+     :paramref:`_orm.unmapped_column.default`.
+    :param sort_order: see :paramref:`_orm.mapped_column.sort_order`.
+    :param \**kw: All remaining keyword arguments are passed through to the
+     constructor for the :class:`_schema.Column`, including dialect-specific
+     arguments.
+
+    """
+
+    return UnmappedColumn(
+        __name_pos,
+        __type_pos,
+        *args,
+        name=name,
+        type_=type_,
+        default=default,
+        insert_default=insert_default,
+        index=index,
+        unique=unique,
+        info=info,
+        nullable=nullable,
+        primary_key=primary_key,
+        autoincrement=autoincrement,
+        onupdate=onupdate,
+        server_default=server_default,
+        server_onupdate=server_onupdate,
+        use_existing_column=use_existing_column,
+        quote=quote,
+        comment=comment,
+        system=system,
+        sort_order=sort_order,
+        **kw,
+    )
+
+
 def orm_insert_sentinel(
     name: Optional[str] = None,
     type_: Optional[_TypeEngineArgument[Any]] = None,

sqlalchemy/orm/base.py

@@ -881,6 +881,60 @@ class _DeclarativeMapped(Mapped[_T_co], _MappedAttribute[_T_co]):
         return NotImplemented
 
 
+class Unmapped(_MappedAnnotationBase[_T_co]):
+    """Represent a database column that is part of the mapped
+    :class:`_schema.Table`, but is not mapped by the ORM.
+
+    The :class:`_orm.Unmapped` type annotation is used in an
+    :ref:`Annotated Declarative Table <orm_declarative_mapped_column>`
+    mapping, in conjunction with the :func:`_orm.unmapped_column`
+    construct, to indicate a column that should be present in the
+    :class:`_schema.Table` generated for the class, while not being part
+    of the Python model at all.  The type and nullability of the
+    :class:`_schema.Column` are derived from the annotation in the same
+    way as for :class:`_orm.Mapped`.
+
+    E.g.::
+
+        class User(Base):
+            __tablename__ = "user"
+
+            id: Mapped[int] = mapped_column(primary_key=True)
+            name: Mapped[str]
+
+            legacy_name: Unmapped[str | None] = unmapped_column()
+
+    The ``legacy_name`` column is part of ``User.__table__``, but there is
+    no ``User.legacy_name`` attribute, and when using
+    :ref:`orm_declarative_native_dataclasses`, it is not part of the
+    dataclass.
+
+    A bare ``Unmapped[]`` annotation with no right-hand side is equivalent to
+    ``unmapped_column()`` with no arguments.  When using
+    :ref:`orm_declarative_native_dataclasses`, the attribute is omitted from
+    the dataclass and its ``__init__()`` method in both cases; however,
+    :pep:`681` typing tools are only able to determine this when
+    :func:`_orm.unmapped_column` is present, and otherwise see the attribute
+    as a required ``__init__()`` argument, so it should always be included
+    in that case.
+
+    .. versionadded:: 2.1.5
+
+    .. seealso::
+
+        :ref:`orm_declarative_unmapped_column`
+
+        :func:`_orm.unmapped_column`
+
+    """
+
+    __slots__ = ()
+
+
+def _is_unmapped_container(mapped_container: Optional[type]) -> bool:
+    return mapped_container is Unmapped
+
+
 class DynamicMapped(_MappedAnnotationBase[_T_co]):
     """Represent the ORM mapped attribute type for a "dynamic" relationship.