--- /dev/null
+.. change::
+ :tags: bug, orm
+ :tickets: 9628
+
+ Fixed bug in ORM Declarative Dataclasses where the
+ :func:`_orm.queryable_attribute` and :func:`_orm.column_property`
+ constructs, which are documented as read-only constructs in the context of
+ a Declarative mapping, could not be used with a
+ :class:`_orm.MappedAsDataclass` class without adding ``init=False``, which
+ in the case of :func:`_orm.queryable_attribute` was not possible as no
+ ``init`` parameter was included. These constructs have been modified from a
+ dataclass perspective to be assumed to be "read only", setting
+ ``init=False`` by default and no longer including them in the pep-681
+ constructor. The dataclass parameters for :func:`_orm.column_property`
+ ``init``, ``default``, ``default_factory``, ``kw_only`` are now deprecated;
+ these fields don't apply to :func:`_orm.column_property` as used in a
+ Declarative dataclasses configuration where the construct would be
+ read-only. Also added read-specific parameter
+ :paramref:`_orm.queryable_attribute.compare` to
+ :func:`_orm.queryable_attribute`; :paramref:`_orm.queryable_attribute.repr`
+ was already present.
+
+
+
+.. change::
+ :tags: bug, orm
+
+ Added missing :paramref:`_orm.mapped_column.active_history` parameter
+ to :func:`_orm.mapped_column` construct.
.. _orm_imperative_table_column_options:
-Applying Load, Persistence and Mapping Options for Mapped Table Columns
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Applying Load, Persistence and Mapping Options for Imperative Table Columns
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
The section :ref:`orm_declarative_column_options` reviewed how to set load
and persistence options when using the :func:`_orm.mapped_column` construct
from mypy.nodes import ARG_POS
from mypy.nodes import CallExpr
from mypy.nodes import ClassDef
+from mypy.nodes import Decorator
from mypy.nodes import Expression
from mypy.nodes import FuncDef
from mypy.nodes import MemberExpr
def type_id_for_callee(callee: Expression) -> Optional[int]:
if isinstance(callee, (MemberExpr, NameExpr)):
- if isinstance(callee.node, OverloadedFuncDef):
+ if isinstance(callee.node, Decorator) and isinstance(
+ callee.node.func, FuncDef
+ ):
+ if callee.node.func.type and isinstance(
+ callee.node.func.type, CallableType
+ ):
+ ret_type = get_proper_type(callee.node.func.type.ret_type)
+
+ if isinstance(ret_type, Instance):
+ return type_id_for_fullname(ret_type.type.fullname)
+
+ return None
+
+ elif isinstance(callee.node, OverloadedFuncDef):
if (
callee.node.impl
and callee.node.impl.type
insert_default: Optional[Any] = _NoArg.NO_ARG,
server_default: Optional[_ServerDefaultType] = None,
server_onupdate: Optional[FetchedValue] = None,
+ active_history: bool = False,
quote: Optional[bool] = None,
system: bool = False,
comment: Optional[str] = None,
.. versionadded:: 2.0.4
+ :param active_history=False:
+
+ When ``True``, indicates that the "previous" value for a
+ scalar attribute should be loaded when replaced, if not
+ already loaded. Normally, history tracking logic for
+ simple non-primary-key scalar values only needs to be
+ aware of the "new" value in order to perform a flush. This
+ flag is available for applications that make use of
+ :func:`.attributes.get_history` or :meth:`.Session.is_modified`
+ which also need to know the "previous" value of the attribute.
+
+ .. versionadded:: 2.0.10
+
+
:param init: Specific to :ref:`orm_declarative_native_dataclasses`,
specifies if the mapped attribute should be part of the ``__init__()``
method as generated by the dataclass process.
index=index,
unique=unique,
info=info,
+ active_history=active_history,
nullable=nullable,
onupdate=onupdate,
primary_key=primary_key,
)
+@util.deprecated_params(
+ **{
+ arg: (
+ "2.0",
+ f"The :paramref:`_orm.column_property.{arg}` parameter is "
+ "deprecated for :func:`_orm.column_property`. This parameter "
+ "applies to a writeable-attribute in a Declarative Dataclasses "
+ "configuration only, and :func:`_orm.column_property` is treated "
+ "as a read-only attribute in this context.",
+ )
+ for arg in ("init", "kw_only", "default", "default_factory")
+ }
+)
def column_property(
column: _ORMColumnExprArgument[_T],
*additional_columns: _ORMColumnExprArgument[Any],
deferred: bool = False,
raiseload: bool = False,
comparator_factory: Optional[Type[PropComparator[_T]]] = None,
- init: Union[_NoArg, bool] = _NoArg.NO_ARG,
+ init: Union[_NoArg, bool] = _NoArg.NO_ARG, # noqa: A002
repr: Union[_NoArg, bool] = _NoArg.NO_ARG, # noqa: A002
default: Optional[Any] = _NoArg.NO_ARG,
default_factory: Union[_NoArg, Callable[[], _T]] = _NoArg.NO_ARG,
) -> MappedSQLExpression[_T]:
r"""Provide a column-level property for use with a mapping.
- Column-based properties can normally be applied to the mapper's
- ``properties`` dictionary using the :class:`_schema.Column`
- element directly.
- Use this function when the given column is not directly present within
- the mapper's selectable; examples include SQL expressions, functions,
- and scalar SELECT queries.
+ With Declarative mappings, :func:`_orm.column_property` is used to
+ map read-only SQL expressions to a mapped class.
+
+ When using Imperative mappings, :func:`_orm.column_property` also
+ takes on the role of mapping table columns with additional features.
+ When using fully Declarative mappings, the :func:`_orm.mapped_column`
+ construct should be used for this purpose.
+
+ With Declarative Dataclass mappings, :func:`_orm.column_property`
+ is considered to be **read only**, and will not be included in the
+ Dataclass ``__init__()`` constructor.
The :func:`_orm.column_property` function returns an instance of
:class:`.ColumnProperty`.
- Columns that aren't present in the mapper's selectable won't be
- persisted by the mapper and are effectively "read-only" attributes.
+ .. seealso::
+
+ :ref:`mapper_column_property_sql_expressions` - general use of
+ :func:`_orm.column_property` to map SQL expressions
+
+ :ref:`orm_imperative_table_column_options` - usage of
+ :func:`_orm.column_property` with Imperative Table mappings to apply
+ additional options to a plain :class:`_schema.Column` object
:param \*cols:
- list of Column objects to be mapped.
+ list of Column objects to be mapped.
:param active_history=False:
- When ``True``, indicates that the "previous" value for a
- scalar attribute should be loaded when replaced, if not
- already loaded. Normally, history tracking logic for
- simple non-primary-key scalar values only needs to be
- aware of the "new" value in order to perform a flush. This
- flag is available for applications that make use of
- :func:`.attributes.get_history` or :meth:`.Session.is_modified`
- which also need to know
- the "previous" value of the attribute.
+
+ Used only for Imperative Table mappings, or legacy-style Declarative
+ mappings (i.e. which have not been upgraded to
+ :func:`_orm.mapped_column`), for column-based attributes that are
+ expected to be writeable; use :func:`_orm.mapped_column` with
+ :paramref:`_orm.mapped_column.active_history` for Declarative mappings.
+ See that parameter for functional details.
:param comparator_factory: a class which extends
- :class:`.ColumnProperty.Comparator` which provides custom SQL
- clause generation for comparison operations.
+ :class:`.ColumnProperty.Comparator` which provides custom SQL
+ clause generation for comparison operations.
:param group:
a group name for this property when marked as deferred.
:param deferred:
- when True, the column property is "deferred", meaning that
- it does not load immediately, and is instead loaded when the
- attribute is first accessed on an instance. See also
- :func:`~sqlalchemy.orm.deferred`.
+ when True, the column property is "deferred", meaning that
+ it does not load immediately, and is instead loaded when the
+ attribute is first accessed on an instance. See also
+ :func:`~sqlalchemy.orm.deferred`.
:param doc:
- optional string that will be applied as the doc on the
- class-bound descriptor.
+ optional string that will be applied as the doc on the
+ class-bound descriptor.
:param expire_on_flush=True:
Disable expiry on flush. A column_property() which refers
:ref:`orm_queryguide_deferred_raiseload`
- .. seealso::
+ :param init:
+
+ :param default:
- :ref:`column_property_options` - to map columns while including
- mapping options
+ :param default_factory:
- :ref:`mapper_column_property_sql_expressions` - to map SQL
- expressions
+ :param kw_only:
"""
return MappedSQLExpression(
column,
*additional_columns,
attribute_options=_AttributeOptions(
- init, repr, default, default_factory, compare, kw_only
+ False if init is _NoArg.NO_ARG else init,
+ repr,
+ default,
+ default_factory,
+ compare,
+ kw_only,
),
group=group,
deferred=deferred,
expire_on_flush=expire_on_flush,
info=info,
doc=doc,
+ _assume_readonly_dc_attributes=True,
)
default_expr: _ORMColumnExprArgument[_T] = sql.null(),
*,
repr: Union[_NoArg, bool] = _NoArg.NO_ARG, # noqa: A002
+ compare: Union[_NoArg, bool] = _NoArg.NO_ARG, # noqa: A002
expire_on_flush: bool = True,
info: Optional[_InfoType] = None,
doc: Optional[str] = None,
prop = MappedSQLExpression(
default_expr,
attribute_options=_AttributeOptions(
- _NoArg.NO_ARG,
+ False,
repr,
_NoArg.NO_ARG,
_NoArg.NO_ARG,
- _NoArg.NO_ARG,
+ compare,
_NoArg.NO_ARG,
),
expire_on_flush=expire_on_flush,
info=info,
doc=doc,
+ _assume_readonly_dc_attributes=True,
)
prop.strategy_key = (("query_expression", True),)
from . import instrumentation
from . import interfaces
from . import mapperlib
-from ._orm_constructors import column_property
from ._orm_constructors import composite
from ._orm_constructors import deferred
from ._orm_constructors import mapped_column
-from ._orm_constructors import query_expression
from ._orm_constructors import relationship
from ._orm_constructors import synonym
from .attributes import InstrumentedAttribute
from .descriptor_props import Synonym
from .descriptor_props import Synonym as _orm_synonym
from .mapper import Mapper
-from .properties import ColumnProperty
from .properties import MappedColumn
from .relationships import RelationshipProperty
from .state import InstanceState
MappedColumn,
RelationshipProperty,
Composite,
- ColumnProperty,
Synonym,
mapped_column,
relationship,
composite,
- column_property,
synonym,
deferred,
- query_expression,
),
)
class DCTransformDeclarative(DeclarativeAttributeIntercept):
MappedColumn,
RelationshipProperty,
Composite,
- ColumnProperty,
Synonym,
mapped_column,
relationship,
composite,
- column_property,
synonym,
deferred,
- query_expression,
),
)
@overload
_NoArg.NO_ARG,
)
+_DEFAULT_READONLY_ATTRIBUTE_OPTIONS = _AttributeOptions(
+ False,
+ _NoArg.NO_ARG,
+ _NoArg.NO_ARG,
+ _NoArg.NO_ARG,
+ _NoArg.NO_ARG,
+ _NoArg.NO_ARG,
+)
+
class _DCAttributeOptions:
"""mixin for descriptors or configurational objects that include dataclass
"""
def __init__(
- self, attribute_options: Optional[_AttributeOptions] = None
+ self,
+ attribute_options: Optional[_AttributeOptions] = None,
+ _assume_readonly_dc_attributes: bool = False,
) -> None:
self._configure_started = False
self._configure_finished = False
- if (
- attribute_options
- and attribute_options != _DEFAULT_ATTRIBUTE_OPTIONS
- ):
+
+ if _assume_readonly_dc_attributes:
+ default_attrs = _DEFAULT_READONLY_ATTRIBUTE_OPTIONS
+ else:
+ default_attrs = _DEFAULT_ATTRIBUTE_OPTIONS
+
+ if attribute_options and attribute_options != default_attrs:
self._has_dataclass_arguments = True
self._attribute_options = attribute_options
else:
self._has_dataclass_arguments = False
- self._attribute_options = _DEFAULT_ATTRIBUTE_OPTIONS
+ self._attribute_options = default_attrs
def init(self) -> None:
"""Called after all mappers are created to assemble
info: Optional[_InfoType] = None,
doc: Optional[str] = None,
_instrument: bool = True,
+ _assume_readonly_dc_attributes: bool = False,
):
- super().__init__(attribute_options=attribute_options)
+ super().__init__(
+ attribute_options=attribute_options,
+ _assume_readonly_dc_attributes=_assume_readonly_dc_attributes,
+ )
columns = (column,) + additional_columns
self.columns = [
coercions.expect(roles.LabeledColumnExprRole, c) for c in columns
"deferred",
"deferred_group",
"deferred_raiseload",
+ "active_history",
"_attribute_options",
"_has_dataclass_arguments",
"_use_existing_column",
self.deferred = bool(
self.deferred_group or self.deferred_raiseload
)
-
+ self.active_history = kw.pop("active_history", False)
self._sort_order = kw.pop("sort_order", 0)
self.column = cast("Column[_T]", Column(*arg, **kw))
self.foreign_keys = self.column.foreign_keys
new.deferred_group = self.deferred_group
new.deferred_raiseload = self.deferred_raiseload
new.foreign_keys = new.column.foreign_keys
+ new.active_history = self.active_history
new._has_nullable = self._has_nullable
new._attribute_options = self._attribute_options
new._has_insert_default = self._has_insert_default
@property
def mapper_property_to_assign(self) -> Optional[MapperProperty[_T]]:
- if self.deferred:
+ if self.deferred or self.active_history:
return ColumnProperty(
self.column,
- deferred=True,
+ deferred=self.deferred,
group=self.deferred_group,
raiseload=self.deferred_raiseload,
attribute_options=self._attribute_options,
+ active_history=self.active_history,
)
else:
return None
class _NoArg(Enum):
NO_ARG = 0
+ def __repr__(self):
+ return f"_NoArg.{self.name}"
+
NO_ARG = _NoArg.NO_ARG
check_defaults: Union[Set[str], Tuple[()]]
if spec.defaults is not None:
+
defaults = dict(
zip(
spec.args[(len(spec.args) - len(spec.defaults)) :],
)
check_defaults = set(defaults).intersection(messages)
check_kw = set(messages).difference(defaults)
+ elif spec.kwonlydefaults is not None:
+
+ defaults = spec.kwonlydefaults
+ check_defaults = set(defaults).intersection(messages)
+ check_kw = set(messages).difference(defaults)
else:
check_defaults = ()
check_kw = set(messages)
"""
% metadata
)
+
+ mod = sys.modules[fn.__module__]
+ env.update(vars(mod))
env.update({targ_name: target, fn_name: fn, "__name__": fn.__module__})
decorated = cast(
--- /dev/null
+from __future__ import annotations
+
+from typing import Optional
+
+from sqlalchemy.orm import column_property
+from sqlalchemy.orm import DeclarativeBase
+from sqlalchemy.orm import Mapped
+from sqlalchemy.orm import mapped_column
+from sqlalchemy.orm import MappedAsDataclass
+from sqlalchemy.orm import query_expression
+
+
+class Base(DeclarativeBase):
+ pass
+
+
+class TestInitialSupport(Base):
+ __tablename__ = "a"
+
+ id: Mapped[int] = mapped_column(primary_key=True, init=False)
+ data: Mapped[str]
+ x: Mapped[Optional[int]] = mapped_column(default=None)
+ y: Mapped[Optional[int]] = mapped_column(kw_only=True)
+
+
+tis = TestInitialSupport(data="some data", y=5)
+
+# EXPECTED_TYPE: str
+reveal_type(tis.data)
+
+# EXPECTED_RE_TYPE: .*Union\[builtins.int, None\]
+reveal_type(tis.y)
+
+tis.data = "some other data"
+
+
+class TestTicket9628(MappedAsDataclass, Base):
+ __tablename__ = "ticket_9628"
+
+ id: Mapped[int] = mapped_column(primary_key=True, init=False)
+ data: Mapped[str] = mapped_column()
+
+ d2: Mapped[str] = column_property(data + "Asdf")
+ d3: Mapped[str] = query_expression(data + "Asdf")
+
+
+# d2 and d3 are not required, as these have init=False. We omit
+# them from dataclass transforms entirely as these are never intended
+# to be writeable fields in a 2.0 declarative mapping
+t9628 = TestTicket9628(data="asf")
+++ /dev/null
-from __future__ import annotations
-
-from typing import Optional
-
-from sqlalchemy.orm import DeclarativeBase
-from sqlalchemy.orm import Mapped
-from sqlalchemy.orm import mapped_column
-from sqlalchemy.orm import MappedAsDataclass
-
-
-class Base(MappedAsDataclass, DeclarativeBase):
- pass
-
-
-class A(Base):
- __tablename__ = "a"
-
- id: Mapped[int] = mapped_column(primary_key=True, init=False)
- data: Mapped[str]
- x: Mapped[Optional[int]] = mapped_column(default=None)
- y: Mapped[Optional[int]] = mapped_column(kw_only=True)
-
-
-a1 = A(data="some data", y=5)
-
-# EXPECTED_TYPE: str
-reveal_type(a1.data)
-
-# EXPECTED_RE_TYPE: .*Union\[builtins.int, None\]
-reveal_type(a1.y)
-
-a1.data = "some other data"
sess.expunge_all()
eq_(sess.query(User).all(), [User(name="u1", a="a", b="b")])
+ def test_active_history_columns(self):
+ class Foo(Base):
+ __tablename__ = "foo"
+
+ id = Column(
+ Integer, primary_key=True, test_needs_autoincrement=True
+ )
+ a = column_property(Column(String), active_history=True)
+ b = mapped_column(String, active_history=True)
+ c = column_property(Column(String))
+ d = mapped_column(String)
+
+ self.assert_compile(
+ select(Foo), "SELECT foo.id, foo.a, foo.b, foo.c, foo.d FROM foo"
+ )
+ eq_(Foo.a.impl.active_history, True)
+ eq_(Foo.b.impl.active_history, True)
+ eq_(Foo.c.impl.active_history, False)
+ eq_(Foo.d.impl.active_history, False)
+
def test_column_properties(self):
class Address(Base, fixtures.ComparableEntity):
from sqlalchemy.orm import mapped_column
from sqlalchemy.orm import MappedAsDataclass
from sqlalchemy.orm import MappedColumn
+from sqlalchemy.orm import query_expression
from sqlalchemy.orm import registry
from sqlalchemy.orm import registry as _RegistryType
from sqlalchemy.orm import relationship
from sqlalchemy.orm import Session
from sqlalchemy.orm import synonym
+from sqlalchemy.sql.base import _NoArg
from sqlalchemy.testing import AssertsCompiledSQL
from sqlalchemy.testing import eq_
from sqlalchemy.testing import eq_regex
else:
return args, args
- @testing.fixture(
- params=["mapped_column", "synonym", "deferred", "column_property"]
- )
+ @testing.fixture(params=["mapped_column", "synonym", "deferred"])
def mapped_expr_constructor(self, request):
name = request.param
yield synonym("some_int", default=7, init=True)
elif name == "deferred":
yield deferred(Column(Integer), default=7, init=True)
- elif name == "column_property":
- yield column_property(Column(Integer), default=7, init=True)
def test_attrs_rejected_if_not_a_dc(
self, mapped_expr_constructor, decl_base: Type[DeclarativeBase]
@testing.combinations(
mapped_column,
lambda **kw: synonym("some_int", **kw),
- lambda **kw: column_property(Column(Integer), **kw),
lambda **kw: deferred(Column(Integer), **kw),
lambda **kw: composite("foo", **kw),
lambda **kw: relationship("Foo", **kw),
prop = construct(**kw)
eq_(prop._attribute_options, exp)
+ @testing.variation("use_arguments", [True, False])
+ @testing.combinations(
+ lambda **kw: column_property(Column(Integer), **kw),
+ lambda **kw: query_expression(**kw),
+ argnames="construct",
+ )
+ def test_ro_attribute_options(self, use_arguments, construct):
+ if use_arguments:
+ kw = {
+ "repr": False,
+ "compare": True,
+ }
+ exp = interfaces._AttributeOptions(
+ False, False, _NoArg.NO_ARG, _NoArg.NO_ARG, True, _NoArg.NO_ARG
+ )
+ else:
+ kw = {}
+ exp = interfaces._DEFAULT_READONLY_ATTRIBUTE_OPTIONS
+
+ prop = construct(**kw)
+ eq_(prop._attribute_options, exp)
+
class MixinColumnTest(fixtures.TestBase, testing.AssertsCompiledSQL):
"""tests for #8718"""
"state='NY', zip_='12345'))",
)
eq_(repr(u2), "mymodule.User(name='u2', address=None)")
+
+
+class ReadOnlyAttrTest(fixtures.TestBase, testing.AssertsCompiledSQL):
+ """tests related to #9628"""
+
+ __dialect__ = "default"
+
+ @testing.combinations(
+ (query_expression,), (column_property,), argnames="construct"
+ )
+ def test_default_behavior(
+ self, dc_decl_base: Type[MappedAsDataclass], construct
+ ):
+ class MyClass(dc_decl_base):
+ __tablename__ = "a"
+
+ id: Mapped[int] = mapped_column(primary_key=True, init=False)
+ data: Mapped[str] = mapped_column()
+
+ const: Mapped[str] = construct(data + "asdf")
+
+ m1 = MyClass(data="foo")
+ eq_(m1, MyClass(data="foo"))
+ ne_(m1, MyClass(data="bar"))
+
+ eq_regex(
+ repr(m1),
+ r".*MyClass\(id=None, data='foo', const=None\)",
+ )
+
+ @testing.combinations(
+ (query_expression,), (column_property,), argnames="construct"
+ )
+ def test_no_repr_behavior(
+ self, dc_decl_base: Type[MappedAsDataclass], construct
+ ):
+ class MyClass(dc_decl_base):
+ __tablename__ = "a"
+
+ id: Mapped[int] = mapped_column(primary_key=True, init=False)
+ data: Mapped[str] = mapped_column()
+
+ const: Mapped[str] = construct(data + "asdf", repr=False)
+
+ m1 = MyClass(data="foo")
+
+ eq_regex(
+ repr(m1),
+ r".*MyClass\(id=None, data='foo'\)",
+ )
+
+ @testing.combinations(
+ (query_expression,), (column_property,), argnames="construct"
+ )
+ def test_enable_compare(
+ self, dc_decl_base: Type[MappedAsDataclass], construct
+ ):
+ class MyClass(dc_decl_base):
+ __tablename__ = "a"
+
+ id: Mapped[int] = mapped_column(primary_key=True, init=False)
+ data: Mapped[str] = mapped_column()
+
+ const: Mapped[str] = construct(data + "asdf", compare=True)
+
+ m1 = MyClass(data="foo")
+ eq_(m1, MyClass(data="foo"))
+ ne_(m1, MyClass(data="bar"))
+
+ m2 = MyClass(data="foo")
+ m2.const = "some const"
+ ne_(m2, MyClass(data="foo"))
+ m3 = MyClass(data="foo")
+ m3.const = "some const"
+ eq_(m2, m3)
+from __future__ import annotations
+
+from typing import Union
+
import sqlalchemy as sa
from sqlalchemy import ForeignKey
from sqlalchemy import func
],
)
- @testing.combinations(True, False, None, "deferred_parameter")
- def test_group_defer_newstyle(self, deferred_parameter):
+ @testing.combinations(True, False, None, argnames="deferred_parameter")
+ def test_group_defer_newstyle(self, deferred_parameter: Union[bool, None]):
class Base(DeclarativeBase):
pass
import sqlalchemy as sa
from sqlalchemy import cast
+from sqlalchemy import column
from sqlalchemy import desc
from sqlalchemy import event
from sqlalchemy import exc as sa_exc
from sqlalchemy.orm import foreign
from sqlalchemy.orm import instrumentation
from sqlalchemy.orm import joinedload
+from sqlalchemy.orm import Mapped
+from sqlalchemy.orm import mapped_column
from sqlalchemy.orm import relationship
from sqlalchemy.orm import scoped_session
from sqlalchemy.orm import Session
from sqlalchemy.testing import eq_
from sqlalchemy.testing import eq_ignore_whitespace
from sqlalchemy.testing import expect_deprecated
+from sqlalchemy.testing import expect_raises_message
from sqlalchemy.testing import fixtures
from sqlalchemy.testing import is_
from sqlalchemy.testing import is_true
is_(EvaluatorCompiler, _EvaluatorCompiler)
+ @testing.combinations(
+ ("init", True),
+ ("kw_only", True, testing.requires.python310),
+ ("default", 5),
+ ("default_factory", lambda: 10),
+ argnames="paramname, value",
+ )
+ def test_column_property_dc_attributes(self, paramname, value):
+ with expect_deprecated(
+ rf"The column_property.{paramname} parameter is deprecated "
+ r"for column_property\(\)",
+ raise_on_any_unexpected=True,
+ ):
+ column_property(column("q"), **{paramname: value})
+
+ @testing.requires.python310
+ def test_column_property_dc_attributes_still_function(self, dc_decl_base):
+ with expect_deprecated(
+ r"The column_property.init parameter is deprecated "
+ r"for column_property\(\)",
+ r"The column_property.default parameter is deprecated "
+ r"for column_property\(\)",
+ r"The column_property.default_factory parameter is deprecated "
+ r"for column_property\(\)",
+ r"The column_property.kw_only parameter is deprecated "
+ r"for column_property\(\)",
+ raise_on_any_unexpected=True,
+ ):
+
+ class MyClass(dc_decl_base):
+ __tablename__ = "a"
+
+ id: Mapped[int] = mapped_column(primary_key=True, init=False)
+ data: Mapped[str] = mapped_column()
+
+ const1: Mapped[str] = column_property(
+ data + "asdf", init=True, default="foobar"
+ )
+ const2: Mapped[str] = column_property(
+ data + "asdf",
+ init=True,
+ default_factory=lambda: "factory_foo",
+ )
+ const3: Mapped[str] = column_property(
+ data + "asdf", init=True, kw_only=True
+ )
+
+ m1 = MyClass(data="d1", const3="c3")
+ eq_(m1.const1, "foobar")
+ eq_(m1.const2, "factory_foo")
+ eq_(m1.const3, "c3")
+
+ with expect_raises_message(
+ TypeError, "missing 1 required keyword-only argument: 'const3'"
+ ):
+ MyClass(data="d1")
+
class DeprecatedQueryTest(_fixtures.FixtureTest, AssertsCompiledSQL):
__dialect__ = "default"
projects / thirdparty / sqlalchemy / sqlalchemy.git / commitdiff
