U
|
¸ý°d_½ ã @ s¸ d Z ddlmZ ddlZddlZddlZddlmZ ddlmZ ddlmZ ddlm Z ddlm
|
Z
|
dd lm Z dd
|
lm Z dd lm Z dd lmZ dd lmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ 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# dd l m$Z$ dd!l m%Z% dd"l m&Z& dd#l m'Z' dd$l m(Z( dd%l m)Z) dd&l m*Z* d'd(lm+Z+ d'dlmZ, d'd)lm-Z- d'd*lm.Z. d'd+l/m0Z0 d'd,l/m1Z1 d'd-l/m2Z2 d'd.l3m4Z4 d'd/l3m5Z5 d'd0l6m7Z7 d'd1l8m9Z9 d'd2l:m;Z; d'd3l<m=Z= d'd4l>m?Z? d'd5l>m@Z@ ejrØdd6lAmBZB dd7lAmCZC dd8lAmDZD dd9lAmEZE dd:lAmFZF dd;lGmHZH dd<l mIZI dd=lJmKZK dd>lJmLZL dd?lJmMZM dd@lNmOZO ddAlPmQZQ ddBlRmSZS ddClTmUZU ddDlmVZV ddElWmXZX ddFlYmZZZ ddGl[m\Z\ ddHl]m^Z^ ddIl.m_Z_ ddJl.m`Z` d'dKlambZb d'dLlcmdZd d'dMlcmeZe d'dNlcmfZf d'dOlcmgZg d'dPl8mhZh d'dQlimjZj d'dRl>mkZk eedSf ZledTedUZmedVdWdUZnG dXdY dYe1joZpG dZd[ d[e1jqe1jrem ZsG d\d] d]esem ZtG d^d_ d_e1juZvG d`da dae@ZwG dbdc dcZxG ddde deeZyeye4jze4jze4jze4jze4jze4jzZ{eydfe4jze4jze4jze4jze4jzZ|G dgdh dhZ}G didj dje}e em Z~e-jG dkdl dle7e}e em e"e.jZe-jG dmdn dne*em e em e9ZG dodp dpeem ZG dqdr dre5ZG dsdt dte7eZ
G dudv dve
ZG dwdx dxe
ZG dydz dzeZe.jd{d|dd}G d~d deZG dd dZdS )zî
|
|
Contains various base classes used throughout the ORM.
|
|
Defines some key base classes prominent within the internals.
|
|
This module and the classes within are mostly private, though some attributes
|
are exposed when inspecting mappings.
|
|
é )Ú annotationsN)ÚAny)ÚCallable)Úcast)ÚClassVar)ÚDict)ÚGeneric)ÚIterator)ÚList)Ú
|
NamedTuple)ÚNoReturn)ÚOptional)ÚSequence)ÚSet)ÚTuple)ÚType)Ú TYPE_CHECKING)ÚTypeVar)ÚUnioné )Úexc)Ú path_registry)Ú_MappedAttribute)Ú EXT_CONTINUE)ÚEXT_SKIP)ÚEXT_STOP)ÚInspectionAttr)ÚInspectionAttrInfo)Ú
|
MANYTOMANY)Ú MANYTOONE)ÚNO_KEY)ÚNO_VALUE)Ú NotExtension)Ú ONETOMANY)ÚRelationshipDirection)ÚSQLORMOperationsé )Ú ColumnElement)Ú
|
inspection)Úutil)Ú operators)Úroles)Úvisitors)Ú_NoArg)ÚExecutableOption)Ú HasCacheKey)ÚColumnOperators)ÚColumn)Ú
|
TypeEngine)ÚRODescriptorReference)Ú TypedDict)Ú _EntityType)Ú_IdentityKeyType)Ú _InstanceDict)Ú_InternalEntityType)Ú_ORMAdapterProto)ÚInstrumentedAttribute)ÚMapped)Ú _MapperEntity)ÚORMCompileState)Ú QueryContext)Ú RegistryType)Ú_ClassScanMapperConfig)Ú_PopulatorDict)ÚMapper)ÚAbstractEntityRegistry)ÚQuery)ÚSession)Ú InstanceState)Ú _LoadElement)Ú AliasedInsp)Ú
|
ORMAdapter)ÚResult)Ú_ColumnExpressionArgument)Ú_ColumnsClauseArgument)Ú_DMLColumnArgument)Ú _InfoType)Ú OperatorType)Ú_TraverseInternalsType)Ú_AnnotationScanType.Ú_T)ÚboundÚ_TLSúType[LoaderStrategy]c @ s e Zd ZdZdZdS )ÚORMStatementRole© z?Executable SQL or text() construct, including ORM aware objectsN©Ú__name__Ú
|
__module__Ú __qualname__Ú __slots__Z
|
_role_namerW rW rW úPd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\sqlalchemy/orm/interfaces.pyrV q s ÿrV c @ s e Zd ZdZdZdS )ÚORMColumnsClauseRolerW z7ORM mapped entity, aliased entity, or Column expressionNrX rW rW rW r] r^ x s r^ c @ s e Zd ZdZdZdS )ÚORMEntityColumnsClauseRolerW z ORM mapped or aliased entityNrX rW rW rW r] r_ s r_ c @ s e Zd ZdZdZdS )ÚORMFromClauseRolerW z5ORM mapped entity, aliased entity, or FROM expressionNrX rW rW rW r] r` s r` c @ s6 e Zd ZU ded< ded< ded< ded< d ed
|
< d S ) ÚORMColumnDescriptionÚstrÚnamez!Union[Type[Any], TypeEngine[Any]]ÚtypeÚboolÚaliasedz_ColumnsClauseArgument[Any]Úexprz%Optional[_ColumnsClauseArgument[Any]]ÚentityN)rY rZ r[ Ú__annotations__rW rW rW r] ra s
|
|
ra c @ sP e Zd ZdZddddZdddd d
|
d d d d dd
|
ddZd
|
dddddZdS )Ú_IntrospectsAnnotationsrW r ©Úreturnc C s t d| j ddS )zrreturn a copy of this object to use in declarative when the
|
object is found inside of an Annotated object.z Use of the z> construct inside of an Annotated object is not yet supported.N)ÚNotImplementedErrorÚ __class__©ÚselfrW rW r] Úfound_in_pep593_annotated s ÿz1_IntrospectsAnnotations.found_in_pep593_annotatedr@ r? z Type[Any]ú Optional[str]rb zOptional[Type[Mapped[Any]]]z Optional[_AnnotationScanType]re ÚNone)
|
Ú decl_scanÚregistryÚclsÚoriginating_moduleÚkeyÚmapped_containerÚ
|
annotationÚextracted_mapped_annotationÚis_dataclass_fieldrl c
|
|
C s dS )zyPerform class-specific initializaton at early declarative scanning
|
time.
|
|
.. versionadded:: 2.0
|
|
NrW )
|
rp rt ru rv rw rx ry rz r{ r| rW rW r] Údeclarative_scan s z(_IntrospectsAnnotations.declarative_scanr )rx rv rl c C s( t d|j d| d| jj d¡d S )Nz4Python typing annotation is required for attribute "Ú.z " when primary argument(s) for "z#" construct are None or not present)Úsa_excÚ ArgumentErrorrY rn )rp rx rv rW rW r] Ú_raise_for_required² s ÿz+_IntrospectsAnnotations._raise_for_requiredN)rY rZ r[ r\ rq r} r rW rW rW r] rj s rj c @ sj e Zd ZU dZded< ded< ded< ded< ded < ded
|
< d d d dZeddddddddZdS )Ú_AttributeOptionszÀdefine Python-local attribute behavior options common to all
|
:class:`.MapperProperty` objects.
|
|
Currently this includes dataclass-generation arguments.
|
|
.. versionadded:: 2.0
|
|
zUnion[_NoArg, bool]Údataclasses_initÚdataclasses_reprzUnion[_NoArg, Any]Údataclasses_defaultz Union[_NoArg, Callable[[], Any]]Údataclasses_default_factoryÚdataclasses_compareÚdataclasses_kw_onlyr rk c C s i }| j tjk r| j |d< | jtjk r0| j|d< | jtjk rF| j|d< | jtjk r\| j|d< | jtjk rr| j|d< | jtjk r| j|d< tj f |S )z<Return a ``dataclasses.Field`` object given these arguments.Údefault_factoryÚdefaultÚinitÚreprÚcompareZkw_only)
|
r r- ÚNO_ARGr
r r r r Ú dataclassesÚfield)rp ÚkwrW rW r] Ú_as_dataclass_fieldË s
|
|
|
|
|
|
z%_AttributeOptions._as_dataclass_fieldrb rQ ú Optional[Any]rR z_Union[Tuple[str, _AnnotationScanType], Tuple[str, _AnnotationScanType, dataclasses.Field[Any]]])rx rz ry Úelemrl c C sT t |tr |j ¡ }|||fS |tjk r2|||fS |dk rHdsPtdn||fS dS )z®given attribute key, annotation, and value from a class, return
|
the argument tuple we would pass to dataclasses.make_dataclass()
|
for this attribute.
|
|
NFz/Mapped[] received without a mapping declaration)Ú
|
isinstanceÚ_DCAttributeOptionsÚ_attribute_optionsr r- r ÚAssertionError)rv rx rz ry r Zdc_fieldrW rW r] Ú!_get_arguments_for_make_dataclassÞ s
|
|
|
|
|
z3_AttributeOptions._get_arguments_for_make_dataclassN)rY rZ r[ Ú__doc__ri r Ú classmethodr rW rW rW r] r º s
|
r Fc @ s& e Zd ZU dZdZded< ded< dS )r aw mixin for descriptors or configurational objects that include dataclass
|
field options.
|
|
This includes :class:`.MapperProperty`, :class:`._MapsColumn` within
|
the ORM, but also includes :class:`.AssociationProxy` within ext.
|
Can in theory be used for other descriptors that serve a similar role
|
as association proxy. (*maybe* hybrids, not sure yet.)
|
|
rW r r re Ú_has_dataclass_argumentsN)rY rZ r[ r r\ ri rW rW rW r] r s
|
|
r c @ s8 e Zd ZdZdZeddddZedddd Zd
|
S ) Ú _MapsColumnszinterface for declarative-capable construct that delivers one or more
|
Column objects to the declarative process to be part of a Table.
|
rW z Optional[MapperProperty[_T]]rk c C s
|
t dS )zAreturn a MapperProperty to be assigned to the declarative mappingN©rm ro rW rW r] Úmapper_property_to_assign8 s z&_MapsColumns.mapper_property_to_assignz List[Tuple[Column[_T], int]]c C s
|
t dS )zfA list of Column objects that should be declaratively added to the
|
new Table object.
|
|
Nr ro rW rW r] Úcolumns_to_assign= s z _MapsColumns.columns_to_assignN)rY rZ r[ r r\ Úpropertyr r rW rW rW r] r 1 s r c
|
@ sr e Zd ZU dZdZdejjfdejjfgZ de
|
d< e s:dZ dZ d e
|
d
|
< d e
|
d< d e
|
d< d Zde
|
d< de
|
d< de
|
d< ddddZdddddd d d d Zdddd d dd!d d"d#d$ZdHd d%d&d'd(d)d*d+d,Zd dd d-d.d/Zd d d0d1d2ZdId3dd d4d5d6Zd dd7d8Zed9dd:d;Zd dd<d=Zd d d0d>d?Zd@d%d&d%d&ddAdBd dC dDdEZd ddFdGZ dS )JÚMapperPropertya Represent a particular class attribute mapped by :class:`_orm.Mapper`.
|
|
The most common occurrences of :class:`.MapperProperty` are the
|
mapped :class:`_schema.Column`, which is represented in a mapping as
|
an instance of :class:`.ColumnProperty`,
|
and a reference to another class produced by :func:`_orm.relationship`,
|
represented in the mapping as an instance of
|
:class:`.Relationship`.
|
|
)Ú_configure_startedÚ_configure_finishedr r Úparentrx ÚinfoÚdocr¥ rx rP Ú_cache_key_traversalNTúPropComparator[_T]Ú
|
comparatorrb ú Mapper[Any]Fre Z_links_to_entityrr r§ rN r¦ rk c C s i S )aì Info dictionary associated with the object, allowing user-defined
|
data to be associated with this :class:`.InspectionAttr`.
|
|
The dictionary is generated when first accessed. Alternatively,
|
it can be specified as a constructor argument to the
|
:func:`.column_property`, :func:`_orm.relationship`, or
|
:func:`.composite`
|
functions.
|
|
.. seealso::
|
|
:attr:`.QueryableAttribute.info`
|
|
:attr:`.SchemaItem.info`
|
|
rW ro rW rW r] Ú_memoized_attr_info¢ s z"MapperProperty._memoized_attr_infor= r< rC úOptional[ORMAdapter]r rs ©ÚcontextÚ query_entityÚpathÚadapterÚkwargsrl c K s dS )a Called by Query for the purposes of constructing a SQL statement.
|
|
Each MapperProperty associated with the target mapper processes the
|
statement referenced by the query context, adding columns and/or
|
criterion as appropriate.
|
|
NrW )rp r¯ r° r± r² r³ rW rW r] Úsetupµ s zMapperProperty.setupú Result[Any]rA ©r¯ r° r± ÚmapperÚresultr² Ú
|
populatorsrl c C s dS )zcProduce row processing functions and append to the given
|
set of populators lists.
|
|
NrW )rp r¯ r° r± r· r¸ r² r¹ rW rW r] Úcreate_row_processorÅ s
|
z#MapperProperty.create_row_processorzInstanceState[Any]r7 zSet[InstanceState[Any]]z.Optional[Callable[[InstanceState[Any]], bool]]zGIterator[Tuple[object, Mapper[Any], InstanceState[Any], _InstanceDict]])Útype_ÚstateÚdict_Úvisited_statesÚhalt_onrl c C s t dS )a Iterate through instances related to the given instance for
|
a particular 'cascade', starting with this MapperProperty.
|
|
Return an iterator3-tuples (instance, mapper, state).
|
|
Note that the 'cascade' collection on this MapperProperty is
|
checked first for the given type before cascade_iterator is called.
|
|
This method typically only applies to Relationship.
|
|
rW )Úiter)rp r» r¼ r½ r¾ r¿ rW rW r] Úcascade_iteratorÔ s z MapperProperty.cascade_iterator)r¥ r rl c C s
|
|| _ dS )z¹Set the parent mapper that references this MapperProperty.
|
|
This method is overridden by some subclasses to perform extra
|
setup when the mapper is first known.
|
|
N)r¥ )rp r¥ r rW rW r] Ú
|
set_parentì s zMapperProperty.set_parent©r· rl c C s dS )aI Hook called by the Mapper to the property to initiate
|
instrumentation of the class attribute managed by this
|
MapperProperty.
|
|
The MapperProperty here will typically call out to the
|
attributes module to set up an InstrumentedAttribute.
|
|
This step is the first of two steps to set up an InstrumentedAttribute,
|
and is called early in the mapper setup process.
|
|
The second step is typically the init_class_attribute step,
|
called from StrategizedProperty via the post_instrument_class()
|
hook. This step assigns additional state to the InstrumentedAttribute
|
(specifically the "impl") which has been determined after the
|
MapperProperty has determined what kind of persistence
|
management it needs to do (e.g. scalar, object, collection, etc).
|
|
NrW ©rp r· rW rW r] Úinstrument_classõ s z MapperProperty.instrument_classzOptional[_AttributeOptions])Úattribute_optionsÚ _assume_readonly_dc_attributesrl c C sD d| _ d| _|rt}nt}|r4||kr4d| _|| _n d| _|| _d S )NFT)r£ r¤ Ú#_DEFAULT_READONLY_ATTRIBUTE_OPTIONSÚ_DEFAULT_ATTRIBUTE_OPTIONSr r )rp rÆ rÇ Z default_attrsrW rW r] Ú__init__ s zMapperProperty.__init__c C s d| _ | ¡ d| _dS )z¦Called after all mappers are created to assemble
|
relationships between mappers and perform other post-mapper-creation
|
initialization steps.
|
|
|
TN)r£ Údo_initr¤ ro rW rW r] r s zMapperProperty.initzInstrumentedAttribute[_T]c C s t | jj| jS )a® Return the class-bound descriptor corresponding to this
|
:class:`.MapperProperty`.
|
|
This is basically a ``getattr()`` call::
|
|
return getattr(self.parent.class_, self.key)
|
|
I.e. if this :class:`.MapperProperty` were named ``addresses``,
|
and the class to which it is mapped is ``User``, this sequence
|
is possible::
|
|
>>> from sqlalchemy import inspect
|
>>> mapper = inspect(User)
|
>>> addresses_property = mapper.attrs.addresses
|
>>> addresses_property.class_attribute is User.addresses
|
True
|
>>> User.addresses.property is addresses_property
|
True
|
|
|
)Úgetattrr¥ Úclass_rx ro rW rW r] Úclass_attribute( s z MapperProperty.class_attributec C s dS )zºPerform subclass-specific initialization post-mapper-creation
|
steps.
|
|
This is a template method called by the ``MapperProperty``
|
object's init() method.
|
|
NrW ro rW rW r] rË B s zMapperProperty.do_initc C s dS )a Perform instrumentation adjustments that need to occur
|
after init() has completed.
|
|
The given Mapper is the Mapper invoking the operation, which
|
may not be the same Mapper as self.parent in an inheritance
|
scenario; however, Mapper will always at least be a sub-mapper of
|
self.parent.
|
|
This method is typically used by StrategizedProperty, which delegates
|
it to LoaderStrategy.init_class_attribute() to perform final setup
|
on the class-bound InstrumentedAttribute.
|
|
NrW rÄ rW rW r] Úpost_instrument_classK s z$MapperProperty.post_instrument_classrE zDict[Any, object]z#Dict[_IdentityKeyType[Any], object]) ÚsessionÚ source_stateÚ source_dictÚ
|
dest_stateÚ dest_dictÚloadÚ
|
_recursiveÚ_resolve_conflict_maprl c C s dS )zoMerge the attribute represented by this ``MapperProperty``
|
from source to destination object.
|
|
NrW ) rp rÐ rÑ rÒ rÓ rÔ rÕ rÖ r× rW rW r] ÚmergeZ s zMapperProperty.mergec C s d| j jt| t| ddf S )Nz<%s at 0x%x; %s>rx zno key)rn rY ÚidrÌ ro rW rW r] Ú__repr__j s
|
|
ýzMapperProperty.__repr__)N)NF) rY rZ r[ r r\ r, ZExtendedInternalTraversalZdp_has_cache_keyZ dp_stringr¨ ri r ZcascadeZ is_propertyZ_is_relationshipr¬ r´ rº rÁ r rÅ rÊ r r¡ rÎ rË rÏ rØ rÚ rW rW rW r] r¢ O s@
|
|
|
þ ú ý r¢ c @ sº e Zd ZU dZdZdZded< ded< ded < dJd ddd d dZej d dddZ
|
ddddZ dddddZ ddd d d Z ejd dd d!ZdKd"dd#d$d%d&Zejd'dd(d)Zejd*dd+d,Zeddddd-d.d/Zeddddd0d1d2Zedddd3d4d5ZeejeZeejeZeejeZ e j rnd6ddd#d7d8d9Z d6ddd#d7d:d;Z d<dd=d>d?Z!d@dAdBdCdDZ"dLd"ddEd$dFdGZ#dMd"ddEd$dHdIZ$d
|
S )NÚPropComparatoraÊ Defines SQL operations for ORM mapped attributes.
|
|
SQLAlchemy allows for operators to
|
be redefined at both the Core and ORM level. :class:`.PropComparator`
|
is the base class of operator redefinition for ORM-level operations,
|
including those of :class:`.ColumnProperty`,
|
:class:`.Relationship`, and :class:`.Composite`.
|
|
User-defined subclasses of :class:`.PropComparator` may be created. The
|
built-in Python comparison and math operator methods, such as
|
:meth:`.operators.ColumnOperators.__eq__`,
|
:meth:`.operators.ColumnOperators.__lt__`, and
|
:meth:`.operators.ColumnOperators.__add__`, can be overridden to provide
|
new operator behavior. The custom :class:`.PropComparator` is passed to
|
the :class:`.MapperProperty` instance via the ``comparator_factory``
|
argument. In each case,
|
the appropriate subclass of :class:`.PropComparator` should be used::
|
|
# definition of custom PropComparator subclasses
|
|
from sqlalchemy.orm.properties import \
|
ColumnProperty,\
|
Composite,\
|
Relationship
|
|
class MyColumnComparator(ColumnProperty.Comparator):
|
def __eq__(self, other):
|
return self.__clause_element__() == other
|
|
class MyRelationshipComparator(Relationship.Comparator):
|
def any(self, expression):
|
"define the 'any' operation"
|
# ...
|
|
class MyCompositeComparator(Composite.Comparator):
|
def __gt__(self, other):
|
"redefine the 'greater than' operation"
|
|
return sql.and_(*[a>b for a, b in
|
zip(self.__clause_element__().clauses,
|
other.__composite_values__())])
|
|
|
# application of custom PropComparator subclasses
|
|
from sqlalchemy.orm import column_property, relationship, composite
|
from sqlalchemy import Column, String
|
|
class SomeMappedClass(Base):
|
some_column = column_property(Column("some_column", String),
|
comparator_factory=MyColumnComparator)
|
|
some_relationship = relationship(SomeOtherClass,
|
comparator_factory=MyRelationshipComparator)
|
|
some_composite = composite(
|
Column("a", String), Column("b", String),
|
comparator_factory=MyCompositeComparator
|
)
|
|
Note that for column-level operator redefinition, it's usually
|
simpler to define the operators at the Core level, using the
|
:attr:`.TypeEngine.comparator_factory` attribute. See
|
:ref:`types_operators` for more detail.
|
|
.. seealso::
|
|
:class:`.ColumnProperty.Comparator`
|
|
:class:`.Relationship.Comparator`
|
|
:class:`.Composite.Comparator`
|
|
:class:`.ColumnOperators`
|
|
:ref:`types_operators`
|
|
:attr:`.TypeEngine.comparator_factory`
|
|
©ÚpropÚ _parententityÚ_adapt_to_entityZorm_prop_comparatorz_InternalEntityType[Any]rÞ zOptional[AliasedInsp[Any]]rß z)RODescriptorReference[MapperProperty[_T]]rÝ NzMapperProperty[_T])rÝ Ú parentmapperÚadapt_to_entityc C s || _ |p || _|| _d S ©NrÜ )rp rÝ rà rá rW rW r] rÊ Ì s
|
zPropComparator.__init__rk c C s | j S )zÜReturn the :class:`.MapperProperty` associated with this
|
:class:`.PropComparator`.
|
|
|
Return values here will commonly be instances of
|
:class:`.ColumnProperty` or :class:`.Relationship`.
|
|
|
)rÝ ro rW rW r] r¡ Ö s zPropComparator.propertyzroles.ColumnsClauseRolec C s t d| d S )Nz%rr ro rW rW r] Ú__clause_element__ã s z!PropComparator.__clause_element__r z(Sequence[Tuple[_DMLColumnArgument, Any]])Úvaluerl c C s t d| ¡ |fgS )zËReceive a SQL expression that represents a value in the SET
|
clause of an UPDATE statement.
|
|
Return a tuple that can be passed to a :class:`_expression.Update`
|
construct.
|
|
rM )r rã )rp rä rW rW r] Ú_bulk_update_tuplesæ s z"PropComparator._bulk_update_tupleszAliasedInsp[Any]r© )rá rl c C s | | j| j|¡S )zReturn a copy of this PropComparator which will use the given
|
:class:`.AliasedInsp` to produce corresponding expressions.
|
)rn rÝ rÞ )rp rá rW rW r] rá ó s z PropComparator.adapt_to_entityr« c C s | j jS )zZlegacy; this is renamed to _parententity to be
|
compatible with QueryableAttribute.)rÞ r· ro rW rW r] Ú _parentmapperû s z PropComparator._parentmapperz)Optional[_ColumnExpressionArgument[bool]]zColumnElement[Any])Ú criterionr³ rl c K s | j jj|f|S râ )rÝ rª Ú_criterion_exists©rp rç r³ rW rW r] rè s z PropComparator._criterion_existszOptional[_ORMAdapterProto]c C s | j dkrdS | j jS dS )zrProduce a callable that adapts column expressions
|
to suit an aliased version of this comparator.
|
|
N)rß Z_orm_adapt_elementro rW rW r] r² s
|
zPropComparator.adapterrN c C s | j jS râ )rÝ r¦ ro rW rW r] r¦ s zPropComparator.info)ÚaÚbr³ rl c K s | j |f|S râ )Úany)rê rë r³ rW rW r] Ú_any_op s zPropComparator._any_op)ÚleftÚotherr³ rl c K s | j |f|S râ )Úhas)rî rï r³ rW rW r] Ú_has_op s zPropComparator._has_op)rê rÍ rl c C s
|
| |¡S râ )Úof_type)rê rÍ rW rW r] Ú _of_type_op s zPropComparator._of_type_oprO )Úoprï r³ rl c O s d S râ rW ©rp rô rï r³ rW rW r] Úoperate) s zPropComparator.operatec K s d S râ rW rõ rW rW r] Úreverse_operate. s z PropComparator.reverse_operatez_EntityType[Any])rÍ rl c C s | tj|¡S )a Redefine this object in terms of a polymorphic subclass,
|
:func:`_orm.with_polymorphic` construct, or :func:`_orm.aliased`
|
construct.
|
|
Returns a new PropComparator from which further criterion can be
|
evaluated.
|
|
e.g.::
|
|
query.join(Company.employees.of_type(Engineer)).\
|
filter(Engineer.name=='foo')
|
|
:param \class_: a class or mapper indicating that criterion will be
|
against this specific subclass.
|
|
.. seealso::
|
|
:ref:`orm_queryguide_joining_relationships_aliased` - in the
|
:ref:`queryguide_toplevel`
|
|
:ref:`inheritance_of_type`
|
|
)rö rÛ Ú
|
of_type_op)rp rÍ rW rW r] rò 3 s zPropComparator.of_typez _ColumnExpressionArgument[bool]zPropComparator[bool])Úcriteriarl c G s | j tjf| S )a? Add additional criteria to the ON clause that's represented by this
|
relationship attribute.
|
|
E.g.::
|
|
|
stmt = select(User).join(
|
User.addresses.and_(Address.email_address != 'foo')
|
)
|
|
stmt = select(User).options(
|
joinedload(User.addresses.and_(Address.email_address != 'foo'))
|
)
|
|
.. versionadded:: 1.4
|
|
.. seealso::
|
|
:ref:`orm_queryguide_join_on_augmented`
|
|
:ref:`loader_option_criteria`
|
|
:func:`.with_loader_criteria`
|
|
)rö r* Úand_)rp rù rW rW r] rú N s zPropComparator.and_zColumnElement[bool]c K s | j tj|f|S )a Return a SQL expression representing true if this element
|
references a member which meets the given criterion.
|
|
The usual implementation of ``any()`` is
|
:meth:`.Relationship.Comparator.any`.
|
|
:param criterion: an optional ClauseElement formulated against the
|
member class' table or attributes.
|
|
:param \**kwargs: key/value pairs corresponding to member class
|
attribute names which will be compared via equality to the
|
corresponding values.
|
|
)rö rÛ Úany_opré rW rW r] rì l s ÿÿzPropComparator.anyc K s | j tj|f|S )a Return a SQL expression representing true if this element
|
references a member which meets the given criterion.
|
|
The usual implementation of ``has()`` is
|
:meth:`.Relationship.Comparator.has`.
|
|
:param criterion: an optional ClauseElement formulated against the
|
member class' table or attributes.
|
|
:param \**kwargs: key/value pairs corresponding to member class
|
attribute names which will be compared via equality to the
|
corresponding values.
|
|
)rö rÛ Úhas_opré rW rW r] rð s ÿÿzPropComparator.has)N)N)N)N)%rY rZ r[ r r\ Z__visit_name__ri rÊ r) Znon_memoized_propertyr¡ rã rå rá Zro_non_memoized_propertyræ rè r² r¦ Ú staticmethodrí rñ ró r r* rO rû rü rø Útypingr rö r÷ rò rú rì rð rW rW rW r] rÛ r sN
|
P ü
|
þ
|
þ þrÛ c @ sþ e Zd ZU dZdZdZded< ded< ded < d
|
d d d Zdd ddZddddddZ dddddZ
|
dddd d d d d d!Z dddd"d#d d$d d%d&d'Z d d d(d)Z d"d d*d+d,Ze e¡Zd-ed.< ed d/d0d1d2Zed3d d4d5d6d7Zd8S )9ÚStrategizedPropertya A MapperProperty which uses selectable strategies to affect
|
loading behavior.
|
|
There is a single strategy selected by default. Alternate
|
strategies can be selected at Query time through the usage of
|
``StrategizedOption`` objects via the Query.options() method.
|
|
The mechanics of StrategizedProperty are used for every Query
|
invocation for every mapped attribute participating in that Query,
|
to determine first how the attribute will be rendered in SQL
|
and secondly how the attribute will retrieve a value from a result
|
row and apply it to a mapped object. The routines here are very
|
performance-critical.
|
|
)Ú _strategiesÚstrategyZ_wildcard_tokenÚ_default_path_loader_keyÚ strategy_keyTz ClassVar[str]Ústrategy_wildcard_keyÚ _StrategyKeyr z"Dict[_StrategyKey, LoaderStrategy]r z
|
Tuple[str]rk c C s | j dtj fS )Nú:)r r Z_WILDCARD_TOKENro rW rW r] Ú _memoized_attr__wildcard_token¼ s ÿz2StrategizedProperty._memoized_attr__wildcard_tokenzTuple[str, Tuple[str]]c C s d| j dtj ffS )NÚloaderr )r r Z_DEFAULT_TOKENro rW rW r] Ú'_memoized_attr__default_path_loader_keyÁ s þz;StrategizedProperty._memoized_attr__default_path_loader_keyr= rC úOptional[_LoadElement])r¯ r± rl c C s> d }|| }|j |j|jfD ] }||jkr |j| } q:q |S râ )Z _loader_keyZ_wildcard_path_loader_keyr Ú
|
attributes)rp r¯ r± rÕ Ú search_pathZpath_keyrW rW r] Ú_get_context_loaderÉ s ý
|
|
z'StrategizedProperty._get_context_loaderÚLoaderStrategy)rx rl c C sJ z | j | W S tk
|
r Y nX | j| f| }|| | | j |< }|S râ )r ÚKeyErrorÚ_strategy_lookup)rp rx rv r rW rW r] Ú _get_strategyå s z!StrategizedProperty._get_strategyr< r r rs r® c K sD | ||¡}|r$|jr$| |j¡}n| j}|j|||||f| d S râ )r r r Ú setup_query)rp r¯ r° r± r² r³ r ÚstratrW rW r] r´ ó s
|
ÿÿzStrategizedProperty.setupr« rµ rA r¶ c
|
|
C sF | ||¡}|r$|jr$| |j¡} n| j} | ||||||||¡ d S râ )r r r rº )
|
rp r¯ r° r± r· r¸ r² r¹ r r rW rW r] rº s
|
|
øz(StrategizedProperty.create_row_processorc C s i | _ | | j¡| _d S râ )r r r r ro rW rW r] rË s zStrategizedProperty.do_initrà c C s& | j js"|j | j¡s"| j |¡ d S râ )r¥ Z non_primaryZ class_managerZ_attr_has_implrx r Úinit_class_attributerÄ rW rW r] rÏ " s
|
ÿ þz)StrategizedProperty.post_instrument_classz\collections.defaultdict[Type[MapperProperty[Any]], Dict[_StrategyKey, Type[LoaderStrategy]]]Ú_all_strategieszCallable[[_TLS], _TLS])r rl c s ddd fdd }|S )NrT )Údec_clsrl c s> d| j krg | _tt ¡ }| j |< | j |¡ | S )NÚ_strategy_keys)Ú__dict__r ÚtupleÚsortedÚitemsr Úappend)r rx ©rv r rW r] Údecorate/ s
|
z2StrategizedProperty.strategy_for.<locals>.decoraterW )rv r r rW r r] Ú strategy_for- s
|
z StrategizedProperty.strategy_forúMapperProperty[Any]rU )Úrequesting_propertyrx rl c G s¨ |j j | jD ]N}|| jkrtr.t|ts.t| j| }z|| W S tk
|
rZ Y qX q| j ¡ D ] \}}||krh|}|| } qqhd }d }t
|
| ||||¡d S râ ) r¥ Z_with_polymorphic_mappersÚ__mro__r r Ú
|
issubclassr¢ r r r Úorm_excZLoaderStrategyException) rv r! rx Zprop_clsZ
|
strategiesZ property_typeZstratsZintended_property_typeZactual_strategyrW rW r] r ; s0
|
|
|
ûz$StrategizedProperty._strategy_lookupN)rY rZ r[ r r\ Z inherit_cacheri r r r r r´ rº rË rÏ Ú collectionsÚ defaultdictÚdictr r r r rW rW rW r] rÿ s(
|
þ
|
rÿ c @ sB e Zd ZdZdZdZdZdZdZdZ dZ
|
dZ dd d dddZ dS ) Ú ORMOptiona´ Base class for option objects that are passed to ORM queries.
|
|
These options may be consumed by :meth:`.Query.options`,
|
:meth:`.Select.options`, or in a more general sense by any
|
:meth:`.Executable.options` method. They are interpreted at
|
statement compile time or execution time in modern use. The
|
deprecated :class:`.MapperOption` is consumed at ORM query construction
|
time.
|
|
.. versionadded:: 1.4
|
|
rW Fr> )r¯ Ú uncached_optrl c C s |dk r |S | S dS )aÊ adapt this option to the "uncached" version of itself in a
|
loader strategy context.
|
|
given "self" which is an option from a cached query, as well as the
|
corresponding option from the uncached version of the same query,
|
return the option we should use in a new query, in the context of a
|
loader strategy being asked to load related rows on behalf of that
|
cached query, which is assumed to be building a new query based on
|
entities passed to us from the cached query.
|
|
Currently this routine chooses between "self" and "uncached" without
|
manufacturing anything new. If the option is itself a loader strategy
|
option which has a path, that path needs to match to the entities being
|
passed to us by the cached query, so the :class:`_orm.Load` subclass
|
overrides this to return "self". For all other options, we return the
|
uncached form which may have changing state, such as a
|
with_loader_criteria() option which will very often have new state.
|
|
This routine could in the future involve
|
generating a new option based on both inputs if use cases arise,
|
such as if with_loader_criteria() needed to match up to
|
``AliasedClass`` instances given in the parent query.
|
|
However, longer term it might be better to restructure things such that
|
``AliasedClass`` entities are always matched up on their cache key,
|
instead of identity, in things like paths and such, so that this whole
|
issue of "the uncached option does not match the entities" goes away.
|
However this would make ``PathRegistry`` more complicated and difficult
|
to debug as well as potentially less performant in that it would be
|
hashing enormous cache keys rather than a simple AliasedInsp. UNLESS,
|
we could get cache keys overall to be reliably hashed into something
|
like an md5 key.
|
|
.. versionadded:: 1.4.41
|
|
NrW )rp r¯ r) rW rW r] Ú'_adapt_cached_option_to_uncached_option s 'z1ORMOption._adapt_cached_option_to_uncached_optionN) rY rZ r[ r r\ Ú_is_legacy_optionÚpropagate_to_loadersZ_is_coreÚ_is_user_definedÚ_is_compile_stateÚ_is_criteria_optionZ_is_strategy_optionr* rW rW rW r] r( ] s r( c @ s: e Zd ZdZdZdZdddddZdd dd
|
d d Zd S )ÚCompileStateOptionaÎ base for :class:`.ORMOption` classes that affect the compilation of
|
a SQL query and therefore need to be part of the cache key.
|
|
.. note:: :class:`.CompileStateOption` is generally non-public and
|
should not be used as a base class for user-defined options; instead,
|
use :class:`.UserDefinedOption`, which is easier to use as it does not
|
interact with ORM compilation internals or caching.
|
|
:class:`.CompileStateOption` defines an internal attribute
|
``_is_compile_state=True`` which has the effect of the ORM compilation
|
routines for SELECT and other statements will call upon these options when
|
a SQL string is being compiled. As such, these classes implement
|
:class:`.HasCacheKey` and need to provide robust ``_cache_key_traversal``
|
structures.
|
|
The :class:`.CompileStateOption` class is used to implement the ORM
|
:class:`.LoaderOption` and :class:`.CriteriaOption` classes.
|
|
.. versionadded:: 1.4.28
|
|
|
rW Tr= rs )Ú compile_staterl c C s dS )zòApply a modification to a given :class:`.ORMCompileState`.
|
|
This method is part of the implementation of a particular
|
:class:`.CompileStateOption` and is only invoked internally
|
when an ORM query is compiled.
|
|
NrW )rp r1 rW rW r] Úprocess_compile_stateÉ s z(CompileStateOption.process_compile_stateúSequence[_MapperEntity]©r1 Úmapper_entitiesrl c C s dS )aq Apply a modification to a given :class:`.ORMCompileState`,
|
given entities that were replaced by with_only_columns() or
|
with_entities().
|
|
This method is part of the implementation of a particular
|
:class:`.CompileStateOption` and is only invoked internally
|
when an ORM query is compiled.
|
|
.. versionadded:: 1.4.19
|
|
NrW ©rp r1 r5 rW rW r] Ú'process_compile_state_replaced_entitiesÒ s z:CompileStateOption.process_compile_state_replaced_entitiesN)rY rZ r[ r r\ r. r2 r7 rW rW rW r] r0 s
|
r0 c @ s& e Zd ZdZdZddddddZd S )
|
Ú LoaderOptionzhDescribe a loader modification to an ORM statement at compilation time.
|
|
.. versionadded:: 1.4
|
|
rW r= r3 rs r4 c C s | |¡ d S râ )r2 r6 rW rW r] r7 í s z4LoaderOption.process_compile_state_replaced_entitiesN)rY rZ r[ r r\ r7 rW rW rW r] r8 ä s r8 c @ s( e Zd ZdZdZdZdddddZd S )
|
ÚCriteriaOptionztDescribe a WHERE criteria modification to an ORM statement at
|
compilation time.
|
|
.. versionadded:: 1.4
|
|
rW TzDict[str, Any]rs )r rl c C s dS )z_update additional entity criteria options in the given
|
attributes dictionary.
|
|
NrW )rp r rW rW r] Úget_global_criteria s z"CriteriaOption.get_global_criteriaN)rY rZ r[ r r\ r/ r: rW rW rW r] r9 õ s r9 c @ s0 e Zd ZdZdZdZdZdZd ddddZdS )
|
ÚUserDefinedOptionz~Base class for a user-defined option that can be consumed from the
|
:meth:`.SessionEvents.do_orm_execute` event hook.
|
|
©ÚpayloadFTNr c C s
|
|| _ d S râ r< )rp r= rW rW r] rÊ s zUserDefinedOption.__init__)N) rY rZ r[ r r\ r+ r- r, rÊ rW rW rW r] r; s r; z1.4aK The :class:`.MapperOption class is deprecated and will be removed in a future release. For modifications to queries on a per-execution basis, use the :class:`.UserDefinedOption` class to establish state within a :class:`.Query` or other Core statement, then use the :meth:`.SessionEvents.before_orm_execute` hook to consume them.)Ú constructorc @ s< e Zd ZdZdZdZdZddddd Zdddd
|
d Zd S ) Ú MapperOptionz"Describe a modification to a QueryrW TFz
|
Query[Any]rs )Úqueryrl c C s dS )z8Apply a modification to the given :class:`_query.Query`.NrW ©rp r@ rW rW r] Ú process_query7 s zMapperOption.process_queryc C s | |¡ dS )ao same as process_query(), except that this option may not
|
apply to the given query.
|
|
This is typically applied during a lazy load or scalar refresh
|
operation to propagate options stated in the original Query to the
|
new Query being used for the load. It occurs for those options that
|
specify propagate_to_loaders=True.
|
|
N)rB rA rW rW r] Úprocess_query_conditionally: s z(MapperOption.process_query_conditionallyN) rY rZ r[ r r\ r+ r, rB rC rW rW rW r] r? s r? c
|
@ s e Zd ZU dZdZded< ddddd Zd
|
d d d dZddddddd dddZddddd
|
dddd d dd Z d d d d Z
|
d!S )"r aÈ Describe the loading behavior of a StrategizedProperty object.
|
|
The ``LoaderStrategy`` interacts with the querying process in three
|
ways:
|
|
* it controls the configuration of the ``InstrumentedAttribute``
|
placed on a class to handle the behavior of the attribute. this
|
may involve setting up class-level callable functions to fire
|
off a select operation when the attribute is first accessed
|
(i.e. a lazy load)
|
|
* it processes the ``QueryContext`` at statement construction time,
|
where it can modify the SQL statement that is being produced.
|
For example, simple column attributes will add their represented
|
column to the list of selected columns, a joined eager loader
|
may establish join clauses to add to the statement.
|
|
* It produces "row processor" functions at result fetching time.
|
These "row processor" functions populate a particular attribute
|
on a particular mapped instance.
|
|
)Úparent_propertyÚis_class_levelr¥ rx r Ú strategy_optsz ClassVar[List[_StrategyKey]]r r r )r¥ r c C s4 || _ d| _| j j| _| j j| _|| _t|| _d S )NF)rD rE r¥ rx r r' rF )rp r¥ r rW rW r] rÊ k s
|
|
zLoaderStrategy.__init__r« rs rà c C s d S râ rW rÄ rW rW r] r u s z#LoaderStrategy.init_class_attributer= r< rC r
|
r r )r1 r° r± Úloadoptr² r³ rl c K s dS )zïEstablish column and other state for a given QueryContext.
|
|
This method fulfills the contract specified by MapperProperty.setup().
|
|
StrategizedProperty delegates its setup() method
|
directly to this method.
|
|
NrW )rp r1 r° r± rG r² r³ rW rW r] r x s zLoaderStrategy.setup_queryrµ rA ) r¯ r° r± rG r· r¸ r² r¹ rl c C s dS )a Establish row processing functions for a given QueryContext.
|
|
This method fulfills the contract specified by
|
MapperProperty.create_row_processor().
|
|
StrategizedProperty delegates its create_row_processor() method
|
directly to this method.
|
|
NrW ) rp r¯ r° r± rG r· r¸ r² r¹ rW rW r] rº s z#LoaderStrategy.create_row_processorrb rk c C s
|
t | jS râ )rb rD ro rW rW r] Ú__str__ s zLoaderStrategy.__str__N) rY rZ r[ r r\ ri rÊ r r rº rH rW rW rW r] r H s
|
|
r )r Ú
|
__future__r r% r rþ r r r r r r r r
|
r r r r r r r r r r Ú r r$ r Úbaser r r r r r r r r r! r" r# r$ r% r' r r( r) Zsqlr* r+ r, Zsql.baser- r. Z sql.cache_keyr/ Z sql.operatorsr0 Z
|
sql.schemar1 Z sql.type_apir2 Z util.typingr3 r4 Ú_typingr5 r6 r7 r8 r9 r r: r; r¯ r< r= r> Zdecl_apir? Z decl_baser@ ZloadingrA r· rB rC r@ rD rÐ rE r¼ rF Zstrategy_optionsrG rH rI Z engine.resultrJ Z sql._typingrK rL rM rN rO Z sql.visitorsrP rQ r rR rT Z StatementRolerV ZColumnsClauseRoleZTypedColumnsClauseRoler^ r_ ZStrictFromClauseRoler` ra rj r r rÉ rÈ r r Z_self_inspectsZ MemoizedSlotsr¢ rÛ rÿ r( r0 r8 r9 r; Zdeprecated_clsr? r rW rW rW r] Ú<module> s
|
ÿ
|
'Mú ú
|
|
û $ , AP7ø
|
|
