SQLAlchemy 2.1.0rc2__py3-none-any.whl → 2.1.2__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.2"
 
 
 def __go(lcls: Any) -> None:

sqlalchemy/dialects/mssql/base.py

@@ -3315,6 +3315,27 @@ class MSDialect(default._BackendsMultiReflection, default.DefaultDialect):
         finally:
             cursor.close()
 
+    def min_year_for_type(self, typeobj):
+        typeobj = sqltypes.to_instance(typeobj)
+
+        if isinstance(typeobj, SMALLDATETIME):
+            return 1900
+        elif isinstance(typeobj, (DATETIME2, DATETIMEOFFSET)):
+            return datetime.MINYEAR
+        elif isinstance(typeobj, sqltypes.DateTime):
+            # DateTime renders DATETIMEOFFSET with timezone=True,
+            # else DATETIME
+            return datetime.MINYEAR if typeobj.timezone else 1753
+        elif (
+            isinstance(typeobj, sqltypes.Date)
+            and not isinstance(typeobj, sqltypes.DATE)
+            and self.server_version_info < MS_2008_VERSION
+        ):
+            # Date renders DATETIME before SQL Server 2008
+            return 1753
+        else:
+            return datetime.MINYEAR
+
     def initialize(self, connection):
         super().initialize(connection)
         self._setup_version_attributes()

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/mssql/pyodbc.py

@@ -489,15 +489,12 @@ class _ODBCDateTimeBindProcessor:
             else:
                 # for DATETIMEOFFSET or DateTime(timezone=True)
                 #
-                # Convert to string format required by T-SQL
-                dto_string = value.strftime("%Y-%m-%d %H:%M:%S.%f %z")
-                # offset needs a colon, e.g., -0700 -> -07:00
-                # "UTC offset in the form (+-)HHMM[SS[.ffffff]]"
-                # backend currently rejects seconds / fractional seconds
-                dto_string = re.sub(
-                    r"([\+\-]\d{2})([\d\.]+)$", r"\1:\2", dto_string
-                )
-                return dto_string
+                # Convert to string format required by T-SQL.  isoformat()
+                # zero-pads the year, which strftime("%Y") does not do on
+                # all platforms, and renders the offset with a colon,
+                # e.g. -07:00.  backend currently rejects seconds /
+                # fractional seconds in the offset
+                return value.isoformat(sep=" ", timespec="microseconds")
 
         return process
 

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,
             },
         ),
         (
@@ -4808,8 +4846,12 @@ class PGDialect(default._BackendsMultiReflection, default.DefaultDialect):
             )
             .outerjoin(
                 pg_catalog.pg_description,
-                pg_catalog.pg_description.c.objoid
-                == pg_catalog.pg_constraint.c.oid,
+                sql.and_(
+                    pg_catalog.pg_description.c.objoid
+                    == pg_catalog.pg_constraint.c.oid,
+                    pg_catalog.pg_description.c.classoid
+                    == sql.func.cast("pg_catalog.pg_constraint", REGCLASS),
+                ),
             )
             .where(
                 pg_catalog.pg_constraint.c.contype == bindparam("contype"),
@@ -5001,8 +5043,12 @@ class PGDialect(default._BackendsMultiReflection, default.DefaultDialect):
             )
             .outerjoin(
                 pg_catalog.pg_description,
-                pg_catalog.pg_description.c.objoid
-                == pg_catalog.pg_constraint.c.oid,
+                sql.and_(
+                    pg_catalog.pg_description.c.objoid
+                    == pg_catalog.pg_constraint.c.oid,
+                    pg_catalog.pg_description.c.classoid
+                    == sql.func.cast("pg_catalog.pg_constraint", REGCLASS),
+                ),
             )
             .order_by(
                 pg_catalog.pg_class.c.relname,
@@ -5269,6 +5315,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 +5522,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
 
@@ -5590,8 +5640,12 @@ class PGDialect(default._BackendsMultiReflection, default.DefaultDialect):
             )
             .outerjoin(
                 pg_catalog.pg_description,
-                pg_catalog.pg_description.c.objoid
-                == pg_catalog.pg_constraint.c.oid,
+                sql.and_(
+                    pg_catalog.pg_description.c.objoid
+                    == pg_catalog.pg_constraint.c.oid,
+                    pg_catalog.pg_description.c.classoid
+                    == sql.func.cast("pg_catalog.pg_constraint", REGCLASS),
+                ),
             )
             .order_by(
                 pg_catalog.pg_class.c.relname,

sqlalchemy/engine/_row_cy.py

@@ -69,7 +69,7 @@ class BaseRow:
             (
                 _apply_processors(processors, data)
                 if processors is not None
-                else data if isinstance(data, tuple) else tuple(data)
+                else data if type(data) is tuple else tuple(data)
             ),
         )
 

sqlalchemy/engine/default.py

@@ -16,6 +16,7 @@ as the base class for their own corresponding classes.
 
 from __future__ import annotations
 
+import datetime
 import functools
 import operator
 import random
@@ -829,6 +830,17 @@ class DefaultDialect(Dialect):
         """
         return type_api.adapt_type(typeobj, self.colspecs)
 
+    def min_year_for_type(self, typeobj: TypeEngine[Any]) -> int:
+        """Return the earliest year the database accepts for the given
+        date or datetime type.
+
+        The default implementation returns ``datetime.MINYEAR``.
+
+        .. versionadded:: 2.0.55
+
+        """
+        return datetime.MINYEAR
+
     def has_index(self, connection, table_name, index_name, schema=None, **kw):
         if not self.has_table(connection, table_name, schema=schema, **kw):
             return False

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
@@ -1454,6 +1465,23 @@ class Dialect(EventTarget):
 
         raise NotImplementedError()
 
+    def min_year_for_type(self, typeobj: TypeEngine[Any]) -> int:
+        """Return the earliest year the database accepts for the given
+        date or datetime type.
+
+        The type may be a generic type such as :class:`.DateTime`, in
+        which case the limit is that of the database type the dialect
+        renders for it.  Dialects whose date or datetime types don't
+        accept all years from ``datetime.MINYEAR`` forward override this
+        method; e.g. SQL Server's ``DATETIME`` type, which the dialect
+        renders for :class:`.DateTime`, accepts years from 1753 forward.
+
+        .. versionadded:: 2.0.55
+
+        """
+
+        raise NotImplementedError()
+
     def initialize(self, connection: Connection) -> None:
         """Called during strategized creation of the dialect with a
         connection.
@@ -3426,7 +3454,8 @@ class ExceptionContext:
 
     """
 
-    __slots__ = ()
+    if not TYPE_CHECKING:
+        __slots__ = ()
 
     dialect: Dialect
     """The :class:`_engine.Dialect` in use.

sqlalchemy/ext/asyncio/base.py

@@ -8,6 +8,7 @@
 from __future__ import annotations
 
 import abc
+import asyncio
 import functools
 from typing import Any
 from typing import AsyncGenerator
@@ -15,6 +16,7 @@ from typing import AsyncIterator
 from typing import Awaitable
 from typing import Callable
 from typing import ClassVar
+from typing import Coroutine
 from typing import Dict
 from typing import Generator
 from typing import Generic
@@ -37,6 +39,35 @@ _T_co = TypeVar("_T_co", bound=Any, covariant=True)
 _PT = TypeVar("_PT", bound=Any)
 
 
+async def _run_to_completion(coro: Coroutine[Any, Any, _T]) -> _T:
+    """Run ``coro`` in a task of its own and wait for it to complete, even
+    if the calling task is cancelled meanwhile.
+
+    Used for cleanup, such as the ``close()`` performed by an async context
+    manager on exit, that must not be abandoned partway through.  A
+    cancellation received while waiting is re-raised once ``coro`` has
+    completed, so that the caller does not return before its cleanup has
+    finished; were it to return early, the cleanup would carry on in the
+    background, where for example it could return a connection into a pool
+    that the application has meanwhile disposed of.
+
+    """
+    task = asyncio.create_task(coro)
+    cancelled = None
+    while True:
+        try:
+            result = await asyncio.shield(task)
+        except asyncio.CancelledError as err:
+            if task.done():
+                raise
+            cancelled = err
+        else:
+            break
+    if cancelled is not None:
+        raise cancelled
+    return result
+
+
 class ReversibleProxy(Generic[_PT]):
     _proxy_objects: ClassVar[
         Dict[weakref.ref[Any], weakref.ref[ReversibleProxy[Any]]]

sqlalchemy/ext/asyncio/engine.py

@@ -6,7 +6,6 @@
 # the MIT License: https://www.opensource.org/licenses/mit-license.php
 from __future__ import annotations
 
-import asyncio
 import contextlib
 from typing import Any
 from typing import AsyncIterator
@@ -24,6 +23,7 @@ from typing import TypeVar
 from typing import Union
 
 from . import exc as async_exc
+from .base import _run_to_completion
 from .base import asyncstartablecontext
 from .base import GeneratorStartableContext
 from .base import ProxyComparable
@@ -606,8 +606,7 @@ class AsyncConnection(  # type: ignore[misc]
         except GeneratorExit:
             pass
         else:
-            task = asyncio.create_task(ar.close())
-            await asyncio.shield(task)
+            await _run_to_completion(ar.close())
 
     @overload
     async def execute(
@@ -913,8 +912,7 @@ class AsyncConnection(  # type: ignore[misc]
         return self.start().__await__()
 
     async def __aexit__(self, type_: Any, value: Any, traceback: Any) -> None:
-        task = asyncio.create_task(self.close())
-        await asyncio.shield(task)
+        await _run_to_completion(self.close())
 
     # START PROXY METHODS AsyncConnection
 

sqlalchemy/ext/asyncio/session.py

@@ -6,7 +6,6 @@
 # the MIT License: https://www.opensource.org/licenses/mit-license.php
 from __future__ import annotations
 
-import asyncio
 from typing import Any
 from typing import Awaitable
 from typing import Callable
@@ -30,6 +29,7 @@ from typing import Union
 
 from . import engine
 from . import exc as async_exc
+from .base import _run_to_completion
 from .base import ReversibleProxy
 from .base import StartableContext
 from .result import _ensure_sync_result
@@ -1375,8 +1375,7 @@ class AsyncSession(ReversibleProxy[Session]):
         return self
 
     async def __aexit__(self, type_: Any, value: Any, traceback: Any) -> None:
-        task = asyncio.create_task(self.close())
-        await asyncio.shield(task)
+        await _run_to_completion(self.close())
 
     def _maker_context_manager(self: _AS) -> _AsyncSessionContextManager[_AS]:
         return _AsyncSessionContextManager(self)
@@ -2121,8 +2120,7 @@ class _AsyncSessionContextManager(Generic[_AS]):
             await self.trans.__aexit__(type_, value, traceback)
             await self.async_session.__aexit__(type_, value, traceback)
 
-        task = asyncio.create_task(go())
-        await asyncio.shield(task)
+        await _run_to_completion(go())
 
 
 class AsyncSessionTransaction(

sqlalchemy/ext/automap.py

@@ -1661,11 +1661,11 @@ def _m2m_relationship(
             overlaps=overlaps,
             secondary=table,
             primaryjoin=and_(
-                fk.column == fk.parent for fk in m2m_const[0].elements
-            ),  # type: ignore [arg-type]
+                *(fk.column == fk.parent for fk in m2m_const[0].elements)
+            ),
             secondaryjoin=and_(
-                fk.column == fk.parent for fk in m2m_const[1].elements
-            ),  # type: ignore [arg-type]
+                *(fk.column == fk.parent for fk in m2m_const[1].elements)
+            ),
             backref=backref_obj,
             collection_class=collection_class,
         )
@@ -1687,11 +1687,11 @@ def _m2m_relationship(
             overlaps=overlaps,
             secondary=table,
             primaryjoin=and_(
-                fk.column == fk.parent for fk in m2m_const[1].elements
-            ),  # type: ignore [arg-type]
+                *(fk.column == fk.parent for fk in m2m_const[1].elements)
+            ),
             secondaryjoin=and_(
-                fk.column == fk.parent for fk in m2m_const[0].elements
-            ),  # type: ignore [arg-type]
+                *(fk.column == fk.parent for fk in m2m_const[0].elements)
+            ),
             back_populates=relationship_name,
             collection_class=collection_class,
         )

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):