U
|
¸ý°d%Ó ã @ s d Z ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z dd lm
|
Z
|
dd
|
lm Z dd lm Z dd lm Z dd lmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddl m Z ddl m Z ddl m Z ddl!m"Z" dd l!m#Z# dd l!m$Z$ dd l!m%Z% dd l!m&Z& erÆdd l'm(Z( dd!l)m*Z* dd"lm+Z+ dd#l m,Z, dd$l m-Z- dd%l m.Z. dd&l m/Z/ dd'l0m1Z1 e$d(Z2ed)Z3ed*ed+Z4ed,ed+Z5ed-ed.d/Z6ed0ed.d1Z7G d2d3 d3eZ8G d4d5 d5e%e6 Z9G d6d7 d7e%e7 Z:G d8d9 d9e%e7 Z;G d:d; d;e%e6 Z<G d<d= d=e%e4 Z=G d>d? d?e%e4 Z>G d@dA dAee4 Z?G dBdC dCej@ee2e3f ZAd*d*dDdEdFZBG dGdH dHej@ee4 ZCG dIdJ dJejDe4 ZEG dKdL dLeEe4 ZFdMS )Naou Define attributes on ORM-mapped classes that have "hybrid" behavior.
|
|
"hybrid" means the attribute has distinct behaviors defined at the
|
class level and at the instance level.
|
|
The :mod:`~sqlalchemy.ext.hybrid` extension provides a special form of
|
method decorator and has minimal dependencies on the rest of SQLAlchemy.
|
Its basic theory of operation can work with any descriptor-based expression
|
system.
|
|
Consider a mapping ``Interval``, representing integer ``start`` and ``end``
|
values. We can define higher level functions on mapped classes that produce SQL
|
expressions at the class level, and Python expression evaluation at the
|
instance level. Below, each function decorated with :class:`.hybrid_method` or
|
:class:`.hybrid_property` may receive ``self`` as an instance of the class, or
|
may receive the class directly, depending on context::
|
|
from __future__ import annotations
|
|
from sqlalchemy.ext.hybrid import hybrid_method
|
from sqlalchemy.ext.hybrid import hybrid_property
|
from sqlalchemy.orm import DeclarativeBase
|
from sqlalchemy.orm import Mapped
|
from sqlalchemy.orm import mapped_column
|
|
|
class Base(DeclarativeBase):
|
pass
|
|
class Interval(Base):
|
__tablename__ = 'interval'
|
|
id: Mapped[int] = mapped_column(primary_key=True)
|
start: Mapped[int]
|
end: Mapped[int]
|
|
def __init__(self, start: int, end: int):
|
self.start = start
|
self.end = end
|
|
@hybrid_property
|
def length(self) -> int:
|
return self.end - self.start
|
|
@hybrid_method
|
def contains(self, point: int) -> bool:
|
return (self.start <= point) & (point <= self.end)
|
|
@hybrid_method
|
def intersects(self, other: Interval) -> bool:
|
return self.contains(other.start) | self.contains(other.end)
|
|
|
Above, the ``length`` property returns the difference between the
|
``end`` and ``start`` attributes. With an instance of ``Interval``,
|
this subtraction occurs in Python, using normal Python descriptor
|
mechanics::
|
|
>>> i1 = Interval(5, 10)
|
>>> i1.length
|
5
|
|
When dealing with the ``Interval`` class itself, the :class:`.hybrid_property`
|
descriptor evaluates the function body given the ``Interval`` class as
|
the argument, which when evaluated with SQLAlchemy expression mechanics
|
returns a new SQL expression:
|
|
.. sourcecode:: pycon+sql
|
|
>>> from sqlalchemy import select
|
>>> print(select(Interval.length))
|
{printsql}SELECT interval."end" - interval.start AS length
|
FROM interval{stop}
|
|
|
>>> print(select(Interval).filter(Interval.length > 10))
|
{printsql}SELECT interval.id, interval.start, interval."end"
|
FROM interval
|
WHERE interval."end" - interval.start > :param_1
|
|
Filtering methods such as :meth:`.Select.filter_by` are supported
|
with hybrid attributes as well:
|
|
.. sourcecode:: pycon+sql
|
|
>>> print(select(Interval).filter_by(length=5))
|
{printsql}SELECT interval.id, interval.start, interval."end"
|
FROM interval
|
WHERE interval."end" - interval.start = :param_1
|
|
The ``Interval`` class example also illustrates two methods,
|
``contains()`` and ``intersects()``, decorated with
|
:class:`.hybrid_method`. This decorator applies the same idea to
|
methods that :class:`.hybrid_property` applies to attributes. The
|
methods return boolean values, and take advantage of the Python ``|``
|
and ``&`` bitwise operators to produce equivalent instance-level and
|
SQL expression-level boolean behavior:
|
|
.. sourcecode:: pycon+sql
|
|
>>> i1.contains(6)
|
True
|
>>> i1.contains(15)
|
False
|
>>> i1.intersects(Interval(7, 18))
|
True
|
>>> i1.intersects(Interval(25, 29))
|
False
|
|
>>> print(select(Interval).filter(Interval.contains(15)))
|
{printsql}SELECT interval.id, interval.start, interval."end"
|
FROM interval
|
WHERE interval.start <= :start_1 AND interval."end" > :end_1{stop}
|
|
>>> ia = aliased(Interval)
|
>>> print(select(Interval, ia).filter(Interval.intersects(ia)))
|
{printsql}SELECT interval.id, interval.start,
|
interval."end", interval_1.id AS interval_1_id,
|
interval_1.start AS interval_1_start, interval_1."end" AS interval_1_end
|
FROM interval, interval AS interval_1
|
WHERE interval.start <= interval_1.start
|
AND interval."end" > interval_1.start
|
OR interval.start <= interval_1."end"
|
AND interval."end" > interval_1."end"{stop}
|
|
.. _hybrid_distinct_expression:
|
|
Defining Expression Behavior Distinct from Attribute Behavior
|
--------------------------------------------------------------
|
|
In the previous section, our usage of the ``&`` and ``|`` bitwise operators
|
within the ``Interval.contains`` and ``Interval.intersects`` methods was
|
fortunate, considering our functions operated on two boolean values to return a
|
new one. In many cases, the construction of an in-Python function and a
|
SQLAlchemy SQL expression have enough differences that two separate Python
|
expressions should be defined. The :mod:`~sqlalchemy.ext.hybrid` decorator
|
defines a **modifier** :meth:`.hybrid_property.expression` for this purpose. As an
|
example we'll define the radius of the interval, which requires the usage of
|
the absolute value function::
|
|
from sqlalchemy import ColumnElement
|
from sqlalchemy import Float
|
from sqlalchemy import func
|
from sqlalchemy import type_coerce
|
|
class Interval(Base):
|
# ...
|
|
@hybrid_property
|
def radius(self) -> float:
|
return abs(self.length) / 2
|
|
@radius.inplace.expression
|
@classmethod
|
def _radius_expression(cls) -> ColumnElement[float]:
|
return type_coerce(func.abs(cls.length) / 2, Float)
|
|
In the above example, the :class:`.hybrid_property` first assigned to the
|
name ``Interval.radius`` is amended by a subsequent method called
|
``Interval._radius_expression``, using the decorator
|
``@radius.inplace.expression``, which chains together two modifiers
|
:attr:`.hybrid_property.inplace` and :attr:`.hybrid_property.expression`.
|
The use of :attr:`.hybrid_property.inplace` indicates that the
|
:meth:`.hybrid_property.expression` modifier should mutate the
|
existing hybrid object at ``Interval.radius`` in place, without creating a
|
new object. Notes on this modifier and its
|
rationale are discussed in the next section :ref:`hybrid_pep484_naming`.
|
The use of ``@classmethod`` is optional, and is strictly to give typing
|
tools a hint that ``cls`` in this case is expected to be the ``Interval``
|
class, and not an instance of ``Interval``.
|
|
.. note:: :attr:`.hybrid_property.inplace` as well as the use of ``@classmethod``
|
for proper typing support are available as of SQLAlchemy 2.0.4, and will
|
not work in earlier versions.
|
|
With ``Interval.radius`` now including an expression element, the SQL
|
function ``ABS()`` is returned when accessing ``Interval.radius``
|
at the class level:
|
|
.. sourcecode:: pycon+sql
|
|
>>> from sqlalchemy import select
|
>>> print(select(Interval).filter(Interval.radius > 5))
|
{printsql}SELECT interval.id, interval.start, interval."end"
|
FROM interval
|
WHERE abs(interval."end" - interval.start) / :abs_1 > :param_1
|
|
|
.. _hybrid_pep484_naming:
|
|
Using ``inplace`` to create pep-484 compliant hybrid properties
|
---------------------------------------------------------------
|
|
In the previous section, a :class:`.hybrid_property` decorator is illustrated
|
which includes two separate method-level functions being decorated, both
|
to produce a single object attribute referred towards as ``Interval.radius``.
|
There are actually several different modifiers we can use for
|
:class:`.hybrid_property` including :meth:`.hybrid_property.expression`,
|
:meth:`.hybrid_property.setter` and :meth:`.hybrid_property.update_expression`.
|
|
SQLAlchemy's :class:`.hybrid_property` decorator intends that adding on these
|
methods may be done in the identical manner as Python's built-in
|
``@property`` decorator, where idiomatic use is to continue to redefine the
|
attribute repeatedly, using the **same attribute name** each time, as in the
|
example below that illustrates the use of :meth:`.hybrid_property.setter` and
|
:meth:`.hybrid_property.expression` for the ``Interval.radius`` descriptor::
|
|
# correct use, however is not accepted by pep-484 tooling
|
|
class Interval(Base):
|
# ...
|
|
@hybrid_property
|
def radius(self):
|
return abs(self.length) / 2
|
|
@radius.setter
|
def radius(self, value):
|
self.length = value * 2
|
|
@radius.expression
|
def radius(cls):
|
return type_coerce(func.abs(cls.length) / 2, Float)
|
|
Above, there are three ``Interval.radius`` methods, but as each are decorated,
|
first by the :class:`.hybrid_property` decorator and then by the
|
``@radius`` name itself, the end effect is that ``Interval.radius`` is
|
a single attribute with three different functions contained within it.
|
This style of use is taken from `Python's documented use of @property
|
<https://docs.python.org/3/library/functions.html#property>`_.
|
It is important to note that the way both ``@property`` as well as
|
:class:`.hybrid_property` work, a **copy of the descriptor is made each time**.
|
That is, each call to ``@radius.expression``, ``@radius.setter`` etc.
|
make a new object entirely. This allows the attribute to be re-defined in
|
subclasses without issue (see :ref:`hybrid_reuse_subclass` later in this
|
section for how this is used).
|
|
However, the above approach is not compatible with typing tools such as
|
mypy and pyright. Python's own ``@property`` decorator does not have this
|
limitation only because
|
`these tools hardcode the behavior of @property
|
<https://github.com/python/typing/discussions/1102>`_, meaning this syntax
|
is not available to SQLAlchemy under :pep:`484` compliance.
|
|
In order to produce a reasonable syntax while remaining typing compliant,
|
the :attr:`.hybrid_property.inplace` decorator allows the same
|
decorator to be re-used with different method names, while still producing
|
a single decorator under one name::
|
|
# correct use which is also accepted by pep-484 tooling
|
|
class Interval(Base):
|
# ...
|
|
@hybrid_property
|
def radius(self) -> float:
|
return abs(self.length) / 2
|
|
@radius.inplace.setter
|
def _radius_setter(self, value: float) -> None:
|
# for example only
|
self.length = value * 2
|
|
@radius.inplace.expression
|
@classmethod
|
def _radius_expression(cls) -> ColumnElement[float]:
|
return type_coerce(func.abs(cls.length) / 2, Float)
|
|
Using :attr:`.hybrid_property.inplace` further qualifies the use of the
|
decorator that a new copy should not be made, thereby maintaining the
|
``Interval.radius`` name while allowing additional methods
|
``Interval._radius_setter`` and ``Interval._radius_expression`` to be
|
differently named.
|
|
|
.. versionadded:: 2.0.4 Added :attr:`.hybrid_property.inplace` to allow
|
less verbose construction of composite :class:`.hybrid_property` objects
|
while not having to use repeated method names. Additionally allowed the
|
use of ``@classmethod`` within :attr:`.hybrid_property.expression`,
|
:attr:`.hybrid_property.update_expression`, and
|
:attr:`.hybrid_property.comparator` to allow typing tools to identify
|
``cls`` as a class and not an instance in the method signature.
|
|
|
Defining Setters
|
----------------
|
|
The :meth:`.hybrid_property.setter` modifier allows the construction of a
|
custom setter method, that can modify values on the object::
|
|
class Interval(Base):
|
# ...
|
|
@hybrid_property
|
def length(self) -> int:
|
return self.end - self.start
|
|
@length.inplace.setter
|
def _length_setter(self, value: int) -> None:
|
self.end = self.start + value
|
|
The ``length(self, value)`` method is now called upon set::
|
|
>>> i1 = Interval(5, 10)
|
>>> i1.length
|
5
|
>>> i1.length = 12
|
>>> i1.end
|
17
|
|
.. _hybrid_bulk_update:
|
|
Allowing Bulk ORM Update
|
------------------------
|
|
A hybrid can define a custom "UPDATE" handler for when using
|
ORM-enabled updates, allowing the hybrid to be used in the
|
SET clause of the update.
|
|
Normally, when using a hybrid with :func:`_sql.update`, the SQL
|
expression is used as the column that's the target of the SET. If our
|
``Interval`` class had a hybrid ``start_point`` that linked to
|
``Interval.start``, this could be substituted directly::
|
|
from sqlalchemy import update
|
stmt = update(Interval).values({Interval.start_point: 10})
|
|
However, when using a composite hybrid like ``Interval.length``, this
|
hybrid represents more than one column. We can set up a handler that will
|
accommodate a value passed in the VALUES expression which can affect
|
this, using the :meth:`.hybrid_property.update_expression` decorator.
|
A handler that works similarly to our setter would be::
|
|
from typing import List, Tuple, Any
|
|
class Interval(Base):
|
# ...
|
|
@hybrid_property
|
def length(self) -> int:
|
return self.end - self.start
|
|
@length.inplace.setter
|
def _length_setter(self, value: int) -> None:
|
self.end = self.start + value
|
|
@length.inplace.update_expression
|
def _length_update_expression(cls, value: Any) -> List[Tuple[Any, Any]]:
|
return [
|
(cls.end, cls.start + value)
|
]
|
|
Above, if we use ``Interval.length`` in an UPDATE expression, we get
|
a hybrid SET expression:
|
|
.. sourcecode:: pycon+sql
|
|
|
>>> from sqlalchemy import update
|
>>> print(update(Interval).values({Interval.length: 25}))
|
{printsql}UPDATE interval SET "end"=(interval.start + :start_1)
|
|
This SET expression is accommodated by the ORM automatically.
|
|
.. seealso::
|
|
:ref:`orm_expression_update_delete` - includes background on ORM-enabled
|
UPDATE statements
|
|
|
Working with Relationships
|
--------------------------
|
|
There's no essential difference when creating hybrids that work with
|
related objects as opposed to column-based data. The need for distinct
|
expressions tends to be greater. The two variants we'll illustrate
|
are the "join-dependent" hybrid, and the "correlated subquery" hybrid.
|
|
Join-Dependent Relationship Hybrid
|
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
|
Consider the following declarative
|
mapping which relates a ``User`` to a ``SavingsAccount``::
|
|
from __future__ import annotations
|
|
from decimal import Decimal
|
from typing import cast
|
from typing import List
|
from typing import Optional
|
|
from sqlalchemy import ForeignKey
|
from sqlalchemy import Numeric
|
from sqlalchemy import String
|
from sqlalchemy import SQLColumnExpression
|
from sqlalchemy.ext.hybrid import hybrid_property
|
from sqlalchemy.orm import DeclarativeBase
|
from sqlalchemy.orm import Mapped
|
from sqlalchemy.orm import mapped_column
|
from sqlalchemy.orm import relationship
|
|
|
class Base(DeclarativeBase):
|
pass
|
|
|
class SavingsAccount(Base):
|
__tablename__ = 'account'
|
id: Mapped[int] = mapped_column(primary_key=True)
|
user_id: Mapped[int] = mapped_column(ForeignKey('user.id'))
|
balance: Mapped[Decimal] = mapped_column(Numeric(15, 5))
|
|
owner: Mapped[User] = relationship(back_populates="accounts")
|
|
class User(Base):
|
__tablename__ = 'user'
|
id: Mapped[int] = mapped_column(primary_key=True)
|
name: Mapped[str] = mapped_column(String(100))
|
|
accounts: Mapped[List[SavingsAccount]] = relationship(
|
back_populates="owner", lazy="selectin"
|
)
|
|
@hybrid_property
|
def balance(self) -> Optional[Decimal]:
|
if self.accounts:
|
return self.accounts[0].balance
|
else:
|
return None
|
|
@balance.inplace.setter
|
def _balance_setter(self, value: Optional[Decimal]) -> None:
|
assert value is not None
|
|
if not self.accounts:
|
account = SavingsAccount(owner=self)
|
else:
|
account = self.accounts[0]
|
account.balance = value
|
|
@balance.inplace.expression
|
@classmethod
|
def _balance_expression(cls) -> SQLColumnExpression[Optional[Decimal]]:
|
return cast("SQLColumnExpression[Optional[Decimal]]", SavingsAccount.balance)
|
|
The above hybrid property ``balance`` works with the first
|
``SavingsAccount`` entry in the list of accounts for this user. The
|
in-Python getter/setter methods can treat ``accounts`` as a Python
|
list available on ``self``.
|
|
.. tip:: The ``User.balance`` getter in the above example accesses the
|
``self.acccounts`` collection, which will normally be loaded via the
|
:func:`.selectinload` loader strategy configured on the ``User.balance``
|
:func:`_orm.relationship`. The default loader strategy when not otherwise
|
stated on :func:`_orm.relationship` is :func:`.lazyload`, which emits SQL on
|
demand. When using asyncio, on-demand loaders such as :func:`.lazyload` are
|
not supported, so care should be taken to ensure the ``self.accounts``
|
collection is accessible to this hybrid accessor when using asyncio.
|
|
At the expression level, it's expected that the ``User`` class will
|
be used in an appropriate context such that an appropriate join to
|
``SavingsAccount`` will be present:
|
|
.. sourcecode:: pycon+sql
|
|
>>> from sqlalchemy import select
|
>>> print(select(User, User.balance).
|
... join(User.accounts).filter(User.balance > 5000))
|
{printsql}SELECT "user".id AS user_id, "user".name AS user_name,
|
account.balance AS account_balance
|
FROM "user" JOIN account ON "user".id = account.user_id
|
WHERE account.balance > :balance_1
|
|
Note however, that while the instance level accessors need to worry
|
about whether ``self.accounts`` is even present, this issue expresses
|
itself differently at the SQL expression level, where we basically
|
would use an outer join:
|
|
.. sourcecode:: pycon+sql
|
|
>>> from sqlalchemy import select
|
>>> from sqlalchemy import or_
|
>>> print (select(User, User.balance).outerjoin(User.accounts).
|
... filter(or_(User.balance < 5000, User.balance == None)))
|
{printsql}SELECT "user".id AS user_id, "user".name AS user_name,
|
account.balance AS account_balance
|
FROM "user" LEFT OUTER JOIN account ON "user".id = account.user_id
|
WHERE account.balance < :balance_1 OR account.balance IS NULL
|
|
Correlated Subquery Relationship Hybrid
|
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
|
We can, of course, forego being dependent on the enclosing query's usage
|
of joins in favor of the correlated subquery, which can portably be packed
|
into a single column expression. A correlated subquery is more portable, but
|
often performs more poorly at the SQL level. Using the same technique
|
illustrated at :ref:`mapper_column_property_sql_expressions`,
|
we can adjust our ``SavingsAccount`` example to aggregate the balances for
|
*all* accounts, and use a correlated subquery for the column expression::
|
|
from __future__ import annotations
|
|
from decimal import Decimal
|
from typing import List
|
|
from sqlalchemy import ForeignKey
|
from sqlalchemy import func
|
from sqlalchemy import Numeric
|
from sqlalchemy import select
|
from sqlalchemy import SQLColumnExpression
|
from sqlalchemy import String
|
from sqlalchemy.ext.hybrid import hybrid_property
|
from sqlalchemy.orm import DeclarativeBase
|
from sqlalchemy.orm import Mapped
|
from sqlalchemy.orm import mapped_column
|
from sqlalchemy.orm import relationship
|
|
|
class Base(DeclarativeBase):
|
pass
|
|
|
class SavingsAccount(Base):
|
__tablename__ = 'account'
|
id: Mapped[int] = mapped_column(primary_key=True)
|
user_id: Mapped[int] = mapped_column(ForeignKey('user.id'))
|
balance: Mapped[Decimal] = mapped_column(Numeric(15, 5))
|
|
owner: Mapped[User] = relationship(back_populates="accounts")
|
|
class User(Base):
|
__tablename__ = 'user'
|
id: Mapped[int] = mapped_column(primary_key=True)
|
name: Mapped[str] = mapped_column(String(100))
|
|
accounts: Mapped[List[SavingsAccount]] = relationship(
|
back_populates="owner", lazy="selectin"
|
)
|
|
@hybrid_property
|
def balance(self) -> Decimal:
|
return sum((acc.balance for acc in self.accounts), start=Decimal("0"))
|
|
@balance.inplace.expression
|
@classmethod
|
def _balance_expression(cls) -> SQLColumnExpression[Decimal]:
|
return (
|
select(func.sum(SavingsAccount.balance))
|
.where(SavingsAccount.user_id == cls.id)
|
.label("total_balance")
|
)
|
|
|
The above recipe will give us the ``balance`` column which renders
|
a correlated SELECT:
|
|
.. sourcecode:: pycon+sql
|
|
>>> from sqlalchemy import select
|
>>> print(select(User).filter(User.balance > 400))
|
{printsql}SELECT "user".id, "user".name
|
FROM "user"
|
WHERE (
|
SELECT sum(account.balance) AS sum_1 FROM account
|
WHERE account.user_id = "user".id
|
) > :param_1
|
|
|
.. _hybrid_custom_comparators:
|
|
Building Custom Comparators
|
---------------------------
|
|
The hybrid property also includes a helper that allows construction of
|
custom comparators. A comparator object allows one to customize the
|
behavior of each SQLAlchemy expression operator individually. They
|
are useful when creating custom types that have some highly
|
idiosyncratic behavior on the SQL side.
|
|
.. note:: The :meth:`.hybrid_property.comparator` decorator introduced
|
in this section **replaces** the use of the
|
:meth:`.hybrid_property.expression` decorator.
|
They cannot be used together.
|
|
The example class below allows case-insensitive comparisons on the attribute
|
named ``word_insensitive``::
|
|
from __future__ import annotations
|
|
from typing import Any
|
|
from sqlalchemy import ColumnElement
|
from sqlalchemy import func
|
from sqlalchemy.ext.hybrid import Comparator
|
from sqlalchemy.ext.hybrid import hybrid_property
|
from sqlalchemy.orm import DeclarativeBase
|
from sqlalchemy.orm import Mapped
|
from sqlalchemy.orm import mapped_column
|
|
class Base(DeclarativeBase):
|
pass
|
|
|
class CaseInsensitiveComparator(Comparator[str]):
|
def __eq__(self, other: Any) -> ColumnElement[bool]: # type: ignore[override] # noqa: E501
|
return func.lower(self.__clause_element__()) == func.lower(other)
|
|
class SearchWord(Base):
|
__tablename__ = 'searchword'
|
|
id: Mapped[int] = mapped_column(primary_key=True)
|
word: Mapped[str]
|
|
@hybrid_property
|
def word_insensitive(self) -> str:
|
return self.word.lower()
|
|
@word_insensitive.inplace.comparator
|
@classmethod
|
def _word_insensitive_comparator(cls) -> CaseInsensitiveComparator:
|
return CaseInsensitiveComparator(cls.word)
|
|
Above, SQL expressions against ``word_insensitive`` will apply the ``LOWER()``
|
SQL function to both sides:
|
|
.. sourcecode:: pycon+sql
|
|
>>> from sqlalchemy import select
|
>>> print(select(SearchWord).filter_by(word_insensitive="Trucks"))
|
{printsql}SELECT searchword.id, searchword.word
|
FROM searchword
|
WHERE lower(searchword.word) = lower(:lower_1)
|
|
|
The ``CaseInsensitiveComparator`` above implements part of the
|
:class:`.ColumnOperators` interface. A "coercion" operation like
|
lowercasing can be applied to all comparison operations (i.e. ``eq``,
|
``lt``, ``gt``, etc.) using :meth:`.Operators.operate`::
|
|
class CaseInsensitiveComparator(Comparator):
|
def operate(self, op, other, **kwargs):
|
return op(
|
func.lower(self.__clause_element__()),
|
func.lower(other),
|
**kwargs,
|
)
|
|
.. _hybrid_reuse_subclass:
|
|
Reusing Hybrid Properties across Subclasses
|
-------------------------------------------
|
|
A hybrid can be referred to from a superclass, to allow modifying
|
methods like :meth:`.hybrid_property.getter`, :meth:`.hybrid_property.setter`
|
to be used to redefine those methods on a subclass. This is similar to
|
how the standard Python ``@property`` object works::
|
|
class FirstNameOnly(Base):
|
# ...
|
|
first_name: Mapped[str]
|
|
@hybrid_property
|
def name(self) -> str:
|
return self.first_name
|
|
@name.inplace.setter
|
def _name_setter(self, value: str) -> None:
|
self.first_name = value
|
|
class FirstNameLastName(FirstNameOnly):
|
# ...
|
|
last_name: Mapped[str]
|
|
# 'inplace' is not used here; calling getter creates a copy
|
# of FirstNameOnly.name that is local to FirstNameLastName
|
@FirstNameOnly.name.getter
|
def name(self) -> str:
|
return self.first_name + ' ' + self.last_name
|
|
@name.inplace.setter
|
def _name_setter(self, value: str) -> None:
|
self.first_name, self.last_name = value.split(' ', 1)
|
|
Above, the ``FirstNameLastName`` class refers to the hybrid from
|
``FirstNameOnly.name`` to repurpose its getter and setter for the subclass.
|
|
When overriding :meth:`.hybrid_property.expression` and
|
:meth:`.hybrid_property.comparator` alone as the first reference to the
|
superclass, these names conflict with the same-named accessors on the class-
|
level :class:`.QueryableAttribute` object returned at the class level. To
|
override these methods when referring directly to the parent class descriptor,
|
add the special qualifier :attr:`.hybrid_property.overrides`, which will de-
|
reference the instrumented attribute back to the hybrid object::
|
|
class FirstNameLastName(FirstNameOnly):
|
# ...
|
|
last_name: Mapped[str]
|
|
@FirstNameOnly.name.overrides.expression
|
@classmethod
|
def name(cls):
|
return func.concat(cls.first_name, ' ', cls.last_name)
|
|
|
Hybrid Value Objects
|
--------------------
|
|
Note in our previous example, if we were to compare the ``word_insensitive``
|
attribute of a ``SearchWord`` instance to a plain Python string, the plain
|
Python string would not be coerced to lower case - the
|
``CaseInsensitiveComparator`` we built, being returned by
|
``@word_insensitive.comparator``, only applies to the SQL side.
|
|
A more comprehensive form of the custom comparator is to construct a *Hybrid
|
Value Object*. This technique applies the target value or expression to a value
|
object which is then returned by the accessor in all cases. The value object
|
allows control of all operations upon the value as well as how compared values
|
are treated, both on the SQL expression side as well as the Python value side.
|
Replacing the previous ``CaseInsensitiveComparator`` class with a new
|
``CaseInsensitiveWord`` class::
|
|
class CaseInsensitiveWord(Comparator):
|
"Hybrid value representing a lower case representation of a word."
|
|
def __init__(self, word):
|
if isinstance(word, basestring):
|
self.word = word.lower()
|
elif isinstance(word, CaseInsensitiveWord):
|
self.word = word.word
|
else:
|
self.word = func.lower(word)
|
|
def operate(self, op, other, **kwargs):
|
if not isinstance(other, CaseInsensitiveWord):
|
other = CaseInsensitiveWord(other)
|
return op(self.word, other.word, **kwargs)
|
|
def __clause_element__(self):
|
return self.word
|
|
def __str__(self):
|
return self.word
|
|
key = 'word'
|
"Label to apply to Query tuple results"
|
|
Above, the ``CaseInsensitiveWord`` object represents ``self.word``, which may
|
be a SQL function, or may be a Python native. By overriding ``operate()`` and
|
``__clause_element__()`` to work in terms of ``self.word``, all comparison
|
operations will work against the "converted" form of ``word``, whether it be
|
SQL side or Python side. Our ``SearchWord`` class can now deliver the
|
``CaseInsensitiveWord`` object unconditionally from a single hybrid call::
|
|
class SearchWord(Base):
|
__tablename__ = 'searchword'
|
id: Mapped[int] = mapped_column(primary_key=True)
|
word: Mapped[str]
|
|
@hybrid_property
|
def word_insensitive(self) -> CaseInsensitiveWord:
|
return CaseInsensitiveWord(self.word)
|
|
The ``word_insensitive`` attribute now has case-insensitive comparison behavior
|
universally, including SQL expression vs. Python expression (note the Python
|
value is converted to lower case on the Python side here):
|
|
.. sourcecode:: pycon+sql
|
|
>>> print(select(SearchWord).filter_by(word_insensitive="Trucks"))
|
{printsql}SELECT searchword.id AS searchword_id, searchword.word AS searchword_word
|
FROM searchword
|
WHERE lower(searchword.word) = :lower_1
|
|
SQL expression versus SQL expression:
|
|
.. sourcecode:: pycon+sql
|
|
>>> from sqlalchemy.orm import aliased
|
>>> sw1 = aliased(SearchWord)
|
>>> sw2 = aliased(SearchWord)
|
>>> print(
|
... select(sw1.word_insensitive, sw2.word_insensitive).filter(
|
... sw1.word_insensitive > sw2.word_insensitive
|
... )
|
... )
|
{printsql}SELECT lower(searchword_1.word) AS lower_1,
|
lower(searchword_2.word) AS lower_2
|
FROM searchword AS searchword_1, searchword AS searchword_2
|
WHERE lower(searchword_1.word) > lower(searchword_2.word)
|
|
Python only expression::
|
|
>>> ws1 = SearchWord(word="SomeWord")
|
>>> ws1.word_insensitive == "sOmEwOrD"
|
True
|
>>> ws1.word_insensitive == "XOmEwOrX"
|
False
|
>>> print(ws1.word_insensitive)
|
someword
|
|
The Hybrid Value pattern is very useful for any kind of value that may have
|
multiple representations, such as timestamps, time deltas, units of
|
measurement, currencies and encrypted passwords.
|
|
.. seealso::
|
|
`Hybrids and Value Agnostic Types
|
<https://techspot.zzzeek.org/2011/10/21/hybrids-and-value-agnostic-types/>`_
|
- on the techspot.zzzeek.org blog
|
|
`Value Agnostic Types, Part II
|
<https://techspot.zzzeek.org/2011/10/29/value-agnostic-types-part-ii/>`_ -
|
on the techspot.zzzeek.org blog
|
|
|
é )Ú annotations)ÚAny)ÚCallable)Úcast)ÚGeneric)ÚList)ÚOptional)Úoverload)ÚSequence)ÚTuple)ÚType)Ú TYPE_CHECKING)ÚTypeVar)ÚUnioné )Úutil)Ú
|
attributes)ÚInspectionAttrExtensionType)Ú
|
interfaces)Ú ORMDescriptor)ÚQueryableAttribute)Úroles)Úis_has_clause_element)Ú ColumnElement)ÚSQLCoreOperations)Ú Concatenate)ÚLiteral)Ú ParamSpec)ÚProtocol)ÚSelf)ÚMapperProperty)Ú AliasedInsp)ÚSQLColumnExpression)Ú_ColumnExpressionArgument)Ú_DMLColumnArgument)Ú_HasClauseElement)Ú _InfoType)Ú OperatorTypeÚ_PÚ_RÚ_T)ÚboundÚ_TEÚ_T_coT)r+ Ú covariantÚ_T_con)r+ Ú contravariantc @ s e Zd ZdZdZdS )ÚHybridExtensionTypeÚ HYBRID_METHODÚHYBRID_PROPERTYN)Ú__name__Ú
|
__module__Ú __qualname__r2 r3 © r7 r7 úLd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\sqlalchemy/ext/hybrid.pyr1 n s r1 c @ s e Zd ZdddddZdS )Ú_HybridGetterTyper r- )ÚselfÚreturnc C s d S ©Nr7 )Úsr: r7 r7 r8 Ú__call__ s z_HybridGetterType.__call__N©r4 r5 r6 r> r7 r7 r7 r8 r9 s r9 c @ s e Zd ZddddddZdS )Ú_HybridSetterTyper r/ ÚNone)r: Úvaluer; c C s d S r< r7 )r= r: rB r7 r7 r8 r> s z_HybridSetterType.__call__Nr? r7 r7 r7 r8 r@ s r@ c @ s e Zd ZddddddZdS )Ú_HybridUpdaterTyper z0Union[_T_con, _ColumnExpressionArgument[_T_con]]z$List[Tuple[_DMLColumnArgument, Any]])ÚclsrB r; c C s d S r< r7 )r= rD rB r7 r7 r8 r> s z_HybridUpdaterType.__call__Nr? r7 r7 r7 r8 rC s rC c @ s e Zd ZdddddZdS )Ú_HybridDeleterTyper rA ©Úinstancer; c C s d S r< r7 ©r: rG r7 r7 r8 r> s z_HybridDeleterType.__call__Nr? r7 r7 r7 r8 rE s rE c @ s e Zd ZdddddZdS )Ú_HybridExprCallableTyper ú1Union[_HasClauseElement, SQLColumnExpression[_T]]©rD r; c C s d S r< r7 ©r: rD r7 r7 r8 r> ¤ s z _HybridExprCallableType.__call__Nr? r7 r7 r7 r8 rI £ s rI c @ s e Zd ZdddddZdS )Ú _HybridComparatorCallableTyper úComparator[_T]rK c C s d S r< r7 rL r7 r7 r8 r> « s z&_HybridComparatorCallableType.__call__Nr? r7 r7 r7 r8 rM ª s rM c @ sf e Zd ZdZerbdddddZdddd d
|
Zd dd d dZeddddZ dddddZ
|
dS )Ú_HybridClassLevelAccessorzfDescribe the object returned by a hybrid_property() when
|
called as a class-level descriptor.
|
|
ú_HybridGetterType[_T]úhybrid_property[_T]©Úfgetr; c C s d S r< r7 ©r: rS r7 r7 r8 Úgetter· s z _HybridClassLevelAccessor.getterú_HybridSetterType[_T]©Úfsetr; c C s d S r< r7 ©r: rX r7 r7 r8 Úsetterº s z _HybridClassLevelAccessor.setterú_HybridDeleterType[_T]©Úfdelr; c C s d S r< r7 ©r: r] r7 r7 r8 Údeleter½ s z!_HybridClassLevelAccessor.deleter©r; c C s d S r< r7 ©r: r7 r7 r8 Ú overridesÀ s z#_HybridClassLevelAccessor.overridesú_HybridUpdaterType[_T]©Úmethr; c C s d S r< r7 ©r: re r7 r7 r8 Úupdate_expressionÄ s z+_HybridClassLevelAccessor.update_expressionN) r4 r5 r6 Ú__doc__r rU rZ r_ Úpropertyrb rg r7 r7 r7 r8 rO ¯ s rO c @ s e Zd ZdZdZejZd dddddZe d d
|
d d Z
|
e d dddddZ e ddddddZ ddddddZ dddd d Z dS ) Ú hybrid_methodzzA decorator which allows definition of a Python object method with both
|
instance-level and class-level behavior.
|
|
TNz"Callable[Concatenate[Any, _P], _R]z?Optional[Callable[Concatenate[Any, _P], SQLCoreOperations[_R]]])ÚfuncÚexprc C s( || _ |dk r| |¡ n
|
| |¡ dS )aÑ Create a new :class:`.hybrid_method`.
|
|
Usage is typically via decorator::
|
|
from sqlalchemy.ext.hybrid import hybrid_method
|
|
class SomeClass:
|
@hybrid_method
|
def value(self, x, y):
|
return self._value + x + y
|
|
@value.expression
|
@classmethod
|
def value(cls, x, y):
|
return func.some_function(cls._value, x, y)
|
|
N)rk Ú
|
expression)r: rk rl r7 r7 r8 Ú__init__Ó s zhybrid_method.__init__r r` c C s | S )af Return the inplace mutator for this :class:`.hybrid_method`.
|
|
The :class:`.hybrid_method` class already performs "in place" mutation
|
when the :meth:`.hybrid_method.expression` decorator is called,
|
so this attribute returns Self.
|
|
.. versionadded:: 2.0.4
|
|
.. seealso::
|
|
:ref:`hybrid_pep484_naming`
|
|
r7 ra r7 r7 r8 Úinplaceñ s zhybrid_method.inplaceú Literal[None]ú Type[object]z#Callable[_P, SQLCoreOperations[_R]]©rG Úownerr; c C s d S r< r7 ©r: rG rs r7 r7 r8 Ú__get__ s zhybrid_method.__get__ÚobjectzCallable[_P, _R]c C s d S r< r7 rt r7 r7 r8 ru s úOptional[object]z<Union[Callable[_P, _R], Callable[_P, SQLCoreOperations[_R]]]c C s( |d kr| j ||¡S | j ||¡S d S r< )rl ru rk rt r7 r7 r8 ru s z5Callable[Concatenate[Any, _P], SQLCoreOperations[_R]]zhybrid_method[_P, _R]©rl r; c C s || _ | j js| jj| j _| S )zUProvide a modifying decorator that defines a
|
SQL-expression producing method.)rl rh rk ©r: rl r7 r7 r8 rm s zhybrid_method.expression)N)r4 r5 r6 rh Ú is_attributer1 r2 Úextension_typern ri ro r ru rm r7 r7 r7 r8 rj Ê s û rj rd c C s t | tr| jS | S d S r< )Ú
|
isinstanceÚ classmethodÚ__func__)re r7 r7 r8 Ú_unwrap_classmethod" s
|
r c @ s e Zd ZU dZdZejZded< dPdddd d
|
d d d dZ e
|
ddddddZ e
|
ddddddZ e
|
ddddddZ dd d dd dZ ddd d d!d"Z dd d#d$d%Z dd&d'd(d)Zedd*d+d,ZG d-d. d.ee Zed/d*d0d1Zdd&d2d3d4Zd5d&d6d7d8Zd9d&d:d;d<Zd=d&d>d?d@ZdAd&dBdCdDZdEd&dFdGdHZej dId*dJdKZ d=dId>dLdMZ ddIdBdNdOZ dS )QÚhybrid_propertyzwA decorator which allows definition of a Python descriptor with both
|
instance-level and class-level behavior.
|
|
TÚstrr4 NrP z Optional[_HybridSetterType[_T]]z Optional[_HybridDeleterType[_T]]z%Optional[_HybridExprCallableType[_T]]zOptional[Comparator[_T]]z Optional[_HybridUpdaterType[_T]])rS rX r] rl Úcustom_comparatorÚ update_exprc C s@ || _ || _|| _t|| _t|| _t|| _t | |¡ dS )a Create a new :class:`.hybrid_property`.
|
|
Usage is typically via decorator::
|
|
from sqlalchemy.ext.hybrid import hybrid_property
|
|
class SomeClass:
|
@hybrid_property
|
def value(self):
|
return self._value
|
|
@value.setter
|
def value(self, value):
|
self._value = value
|
|
N) rS rX r] r rl r r r Úupdate_wrapper)r: rS rX r] rl r r r7 r7 r8 rn 4 s
|
|
|
zhybrid_property.__init__r rp r rr c C s d S r< r7 rt r7 r7 r8 ru U s zhybrid_property.__get__rq ú _HybridClassLevelAccessor[_T]c C s d S r< r7 rt r7 r7 r8 ru Y s rv r* c C s d S r< r7 rt r7 r7 r8 ru _ s rw zOptional[Type[object]]z=Union[hybrid_property[_T], _HybridClassLevelAccessor[_T], _T]c C s, |d kr | S |d kr | |¡S | |¡S d S r< )Ú_expr_comparatorrS rt r7 r7 r8 ru c s
|
|
rA )rG rB r; c C s" | j d krtd| ||¡ d S )Nzcan't set attribute)rX ÚAttributeError)r: rG rB r7 r7 r8 Ú__set__m s
|
zhybrid_property.__set__rF c C s | j d krtd| |¡ d S )Nzcan't delete attribute)r] r rH r7 r7 r8 Ú
|
__delete__r s
|
zhybrid_property.__delete__rQ ©Úkwr; c K s. dd | j ¡ D }|jf | t| f |S )Nc S s i | ]\}}| d ¡s||qS )Ú_)Ú
|
startswith)Ú.0ÚkeyrB r7 r7 r8 Ú
|
<dictcomp>x s
|
þ z)hybrid_property._copy.<locals>.<dictcomp>)Ú__dict__ÚitemsÚupdateÚtype)r: r Údefaultsr7 r7 r8 Ú_copyw s
|
þ zhybrid_property._copyr` c C s | S )a Prefix for a method that is overriding an existing attribute.
|
|
The :attr:`.hybrid_property.overrides` accessor just returns
|
this hybrid object, which when called at the class level from
|
a parent class, will de-reference the "instrumented attribute"
|
normally returned at this level, and allow modifying decorators
|
like :meth:`.hybrid_property.expression` and
|
:meth:`.hybrid_property.comparator`
|
to be used without conflicting with the same-named attributes
|
normally present on the :class:`.QueryableAttribute`::
|
|
class SuperClass:
|
# ...
|
|
@hybrid_property
|
def foobar(self):
|
return self._foobar
|
|
class SubClass(SuperClass):
|
# ...
|
|
@SuperClass.foobar.overrides.expression
|
def foobar(cls):
|
return func.subfoobar(self._foobar)
|
|
.. versionadded:: 1.2
|
|
.. seealso::
|
|
:ref:`hybrid_reuse_subclass`
|
|
r7 ra r7 r7 r8 rb s "zhybrid_property.overridesc @ s e Zd ZdZdZddddZddddd Zd
|
dd d d ZdddddZdddddZ dddddZ
|
dddd d Z d dd d d!Z d"S )#zhybrid_property._InPlacezQA builder helper for .hybrid_property.
|
|
.. versionadded:: 2.0.4
|
|
©Úattrzhybrid_property[_TE]c C s
|
|| _ d S r< r )r: r r7 r7 r8 rn s z!hybrid_property._InPlace.__init__r r c K s* | ¡ D ]\}}t| j|t| q| jS r< )r Úsetattrr r )r: r ÚkÚvr7 r7 r8 Ú_set° s z hybrid_property._InPlace._setz_HybridGetterType[_TE]rR c C s | j |dS )N©rS ©r rT r7 r7 r8 rU µ s z hybrid_property._InPlace.getterz_HybridSetterType[_TE]rW c C s | j |dS )N©rX r rY r7 r7 r8 rZ ¸ s z hybrid_property._InPlace.setterz_HybridDeleterType[_TE]r\ c C s | j |dS )N©r] r r^ r7 r7 r8 r_ » s z hybrid_property._InPlace.deleterz _HybridExprCallableType[_TE]rx c C s | j |dS )N©rl r ry r7 r7 r8 rm À s z#hybrid_property._InPlace.expressionz"_HybridComparatorCallableType[_TE]©Ú
|
comparatorr; c C s | j |dS )N©r r ©r: r£ r7 r7 r8 r£ Å s z#hybrid_property._InPlace.comparatorz_HybridUpdaterType[_TE]rd c C s | j |dS )N©r r rf r7 r7 r8 rg Ê s z*hybrid_property._InPlace.update_expressionN) r4 r5 r6 rh Ú __slots__rn r rU rZ r_ rm r£ rg r7 r7 r7 r8 Ú_InPlace¤ s r¨ z _InPlace[_T]c C s
|
t | ¡S )a Return the inplace mutator for this :class:`.hybrid_property`.
|
|
This is to allow in-place mutation of the hybrid, allowing the first
|
hybrid method of a certain name to be re-used in order to add
|
more methods without having to name those methods the same, e.g.::
|
|
class Interval(Base):
|
# ...
|
|
@hybrid_property
|
def radius(self) -> float:
|
return abs(self.length) / 2
|
|
@radius.inplace.setter
|
def _radius_setter(self, value: float) -> None:
|
self.length = value * 2
|
|
@radius.inplace.expression
|
def _radius_expression(cls) -> ColumnElement[float]:
|
return type_coerce(func.abs(cls.length) / 2, Float)
|
|
.. versionadded:: 2.0.4
|
|
.. seealso::
|
|
:ref:`hybrid_pep484_naming`
|
|
)r r¨ ra r7 r7 r8 ro Ï s zhybrid_property.inplacerR c C s | j |dS )zdProvide a modifying decorator that defines a getter method.
|
|
.. versionadded:: 1.2
|
|
r ©r rT r7 r7 r8 rU ï s zhybrid_property.getterrV rW c C s | j |dS )z;Provide a modifying decorator that defines a setter method.r r© rY r7 r7 r8 rZ ø s zhybrid_property.setterr[ r\ c C s | j |dS )z=Provide a modifying decorator that defines a deletion method.r r© r^ r7 r7 r8 r_ ý s zhybrid_property.deleterz_HybridExprCallableType[_T]rx c C s | j |dS )a! Provide a modifying decorator that defines a SQL-expression
|
producing method.
|
|
When a hybrid is invoked at the class level, the SQL expression given
|
here is wrapped inside of a specialized :class:`.QueryableAttribute`,
|
which is the same kind of object used by the ORM to represent other
|
mapped attributes. The reason for this is so that other class-level
|
attributes such as docstrings and a reference to the hybrid itself may
|
be maintained within the structure that's returned, without any
|
modifications to the original SQL expression passed in.
|
|
.. note::
|
|
When referring to a hybrid property from an owning class (e.g.
|
``SomeClass.some_hybrid``), an instance of
|
:class:`.QueryableAttribute` is returned, representing the
|
expression or comparator object as well as this hybrid object.
|
However, that object itself has accessors called ``expression`` and
|
``comparator``; so when attempting to override these decorators on a
|
subclass, it may be necessary to qualify it using the
|
:attr:`.hybrid_property.overrides` modifier first. See that
|
modifier for details.
|
|
.. seealso::
|
|
:ref:`hybrid_distinct_expression`
|
|
r¡ r© ry r7 r7 r8 rm s zhybrid_property.expressionz!_HybridComparatorCallableType[_T]r¢ c C s | j |dS )a/ Provide a modifying decorator that defines a custom
|
comparator producing method.
|
|
The return value of the decorated method should be an instance of
|
:class:`~.hybrid.Comparator`.
|
|
.. note:: The :meth:`.hybrid_property.comparator` decorator
|
**replaces** the use of the :meth:`.hybrid_property.expression`
|
decorator. They cannot be used together.
|
|
When a hybrid is invoked at the class level, the
|
:class:`~.hybrid.Comparator` object given here is wrapped inside of a
|
specialized :class:`.QueryableAttribute`, which is the same kind of
|
object used by the ORM to represent other mapped attributes. The
|
reason for this is so that other class-level attributes such as
|
docstrings and a reference to the hybrid itself may be maintained
|
within the structure that's returned, without any modifications to the
|
original comparator object passed in.
|
|
.. note::
|
|
When referring to a hybrid property from an owning class (e.g.
|
``SomeClass.some_hybrid``), an instance of
|
:class:`.QueryableAttribute` is returned, representing the
|
expression or comparator object as this hybrid object. However,
|
that object itself has accessors called ``expression`` and
|
``comparator``; so when attempting to override these decorators on a
|
subclass, it may be necessary to qualify it using the
|
:attr:`.hybrid_property.overrides` modifier first. See that
|
modifier for details.
|
|
r¤ r© r¥ r7 r7 r8 r£ $ s #zhybrid_property.comparatorrc rd c C s | j |dS )aM Provide a modifying decorator that defines an UPDATE tuple
|
producing method.
|
|
The method accepts a single value, which is the value to be
|
rendered into the SET clause of an UPDATE statement. The method
|
should then process this value into individual column expressions
|
that fit into the ultimate SET clause, and return them as a
|
sequence of 2-tuples. Each tuple
|
contains a column expression as the key and a value to be rendered.
|
|
E.g.::
|
|
class Person(Base):
|
# ...
|
|
first_name = Column(String)
|
last_name = Column(String)
|
|
@hybrid_property
|
def fullname(self):
|
return first_name + " " + last_name
|
|
@fullname.update_expression
|
def fullname(cls, value):
|
fname, lname = value.split(" ", 1)
|
return [
|
(cls.first_name, fname),
|
(cls.last_name, lname)
|
]
|
|
.. versionadded:: 1.2
|
|
r¦ r© rf r7 r7 r8 rg I s $z!hybrid_property.update_expressionz.Callable[[Any], _HybridClassLevelAccessor[_T]]c C sF | j d k r| | j ¡S | jd k r,| | j¡S | ttt | j¡S d S r< )r Ú_get_comparatorrl Ú _get_exprr rI r* rS ra r7 r7 r8 r o s
|
|
|
z hybrid_property._expr_comparatorc s, ddd fdd }t | ¡ |¡S )Nr zExprComparator[_T]rK c s t | | S r< )ÚExprComparator)rD ©rl r: r7 r8 Ú_expr} s z(hybrid_property._get_expr.<locals>._expr)r r rª )r: rl r® r7 r r8 r« z s zhybrid_property._get_exprc s& t ¡ddd fdd }|S )Nrq r
)rs r; c s\ | j D ]*}j|jkr|jj krj} q8qtj}td| | | jpTjdS )Nr
)Údoc)Ú__mro__r4 r r Z_UNKNOWN_ATTR_KEYr rh )rs ÚlookupÚname©r£ Z
|
proxy_attrr: r7 r8 Úexpr_comparator s
|
|
ûþz8hybrid_property._get_comparator.<locals>.expr_comparator)r Zcreate_proxied_attribute)r: r£ r´ r7 r³ r8 rª s
|
z hybrid_property._get_comparator)NNNNN) r4 r5 r6 rh rz r1 r3 r{ Ú__annotations__rn r ru r r r ri rb r r, r¨ ro rU rZ r_ rm r£ rg r Zmemoized_propertyr r« rª r7 r7 r7 r8 r ) sF
|
ù!
|
#+ "%&
|
|
r c @ sP e Zd ZdZddddZdddd Zejd
|
dd d Zd ddddZ dS )Ú
|
ComparatorzA helper class that allows easy construction of custom
|
:class:`~.orm.interfaces.PropComparator`
|
classes for usage with hybrids.rJ ©rm c C s
|
|| _ d S r< r· )r: rm r7 r7 r8 rn « s zComparator.__init__zroles.ColumnsClauseRoler` c C sD | j }t|r| ¡ }ntr*t|ts*t|}tr@t|ts@t|S r< )rm r Ú__clause_element__r r| r ÚAssertionError)r: rl Zret_exprr7 r7 r8 r¸ ° s
|
z Comparator.__clause_element__z interfaces.MapperProperty[_T]c C s
|
t d S r< )ÚNotImplementedErrorra r7 r7 r8 ri À s zComparator.propertyzAliasedInsp[Any]rN )Úadapt_to_entityr; c C s | S r< r7 )r: r» r7 r7 r8 r» Ä s zComparator.adapt_to_entityN)
|
r4 r5 r6 rh rn r¸ r Únon_memoized_propertyri r» r7 r7 r7 r8 r¶ ¦ s r¶ c @ s e Zd ZddddddZddd d
|
d Zejd d ddZdddddZej dd ddZ
|
dddddddZ dddddd d Z d S ) r¬ z Type[Any]rJ rQ ©rD rm Úhybridc C s || _ || _|| _d S r< r½ )r: rD rm r¾ r7 r7 r8 rn Ì s zExprComparator.__init__r r )r r; c C s t | j|S r< )Úgetattrrm )r: r r7 r7 r8 Ú __getattr__Ö s zExprComparator.__getattr__r& r` c C s | j jS r< )r¾ Úinfora r7 r7 r8 rÁ Ù s zExprComparator.infoz(Sequence[Tuple[_DMLColumnArgument, Any]])rB r; c C sF t | jtjr| j |¡S | jjd k r6| j | j|¡S | j|fgS d S r< )r| rm r r Ú_bulk_update_tuplesr¾ r rD )r: rB r7 r7 r8 rÂ Ý s
|
z"ExprComparator._bulk_update_tupleszMapperProperty[_T]c C s | j jS r< )rm ri ra r7 r7 r8 ri ç s zExprComparator.propertyr' zColumnElement[Any])ÚopÚotherÚkwargsr; c O s || j f||S r< r· ©r: rà rÄ rÅ r7 r7 r8 Úoperateî s zExprComparator.operatec K s ||| j f|S r< r· rÆ r7 r7 r8 Úreverse_operateó s z ExprComparator.reverse_operateN) r4 r5 r6 rn rÀ r Zro_non_memoized_propertyrÁ r r¼ ri rÇ rÈ r7 r7 r7 r8 r¬ Ë s
|
|
r¬ N)Grh Ú
|
__future__r Útypingr r r r r r r r
|
r r r r r Ú r Zormr r r r Zorm.attributesr Zsqlr Z sql._typingr Z sql.elementsr r Z util.typingr r r r r Zorm.interfacesr Zorm.utilr! r" r# r$ r% r& Z sql.operatorsr' r( r) r* r, r- r/ r1 r9 r@ rC rE rI rM rO ZInspectionAttrInforj r r ZPropComparatorr¶ r¬ r7 r7 r7 r8 Ú<module> s : X %
|
