U
|
¸ý°dÈ@ ã @ s d dl mZ d dlZd dlZd dlZd dlZd dlZd dlmZ d dlmZ d dlm Z d dlm
|
Z
|
d dlm Z d dlm Z d d lm Z d d
|
lmZ d d lmZ d d lmZ d d lmZ d dlmZ d dlmZ d dlmZ d dlmZ d dlmZ d dlmZ d dlmZ d dlZddlmZ ddlm Z 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& 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"m0Z0 dd*l"m1Z1 dd+l2m3Z3 dd,l2m4Z4 dd-l2m5Z5 dd.l2m6Z6 dd/l2m7Z7 dd0l8m9Z9 d1d2lm:Z: d1dlm Z; d1d3lm<Z< d1d4lm=Z= d1d5lm>Z> d1d6l?m@Z@ d1d7l=mAZA d1d8l=mBZB d1d9l=mCZC d1d:l=mDZD d1d5l=m>ZE d1d;l=mFZF d1d<lGmHZH d1d=lImJZJ d1d>lKmLZL d1d?lMmNZN d1d@lMmOZO d1dAlPmQZQ d1dBlPmRZR d1dClSmTZT d1dDlUmVZV d1dElWmXZY d1dFlWmZZ[ d1dGlWm\Z] d1dHlWm^Z^ d1dIlWm_Z_ d1dJlWm`Z` d1dKlWmaZa ejr ddLl mbZb ddMl mcZc ddNl mdZd ddOl meZe ddPlfmgZg ddQlfmhZh ddRlimjZj ddSlkmlZl ddTlmmnZn d1dUlompZp d1dVlomqZq d1dWlGmrZr d1dXlGmsZs d1dYlGmtZt d1dZlGmuZu d1d[lGmvZv d1d\lGmwZw d1d]lImxZx d1d^lKmyZy d1d_lPmzZz d1d`lSm{Z{ d1dalSm|Z| d1dblSm}Z} d1dclSm~Z~ d1ddlSmZ d1delmZ d1dflWmZ d1dglWmZ edhediZe
djZejeje> dke+i¡dlZG dmdn dne`Ze
|
eeeYZXG dodp dpe`Ze
|
eee[ZZG dqdr dre`Ze
|
eee]Z\G dsdt dte e Zdudv ZdØdydzZdÙdddd{d|d}d~ddddddZG d
d dejZG dd deEjZG dd deEjZG dd de<jd e5e Ze<jG dd de6e e7eNe)eVe<jd e e ZG dd dZG dd de3Ze< e¡dd e< e¡dddddZeee Z e< e ¡dddddZ¡e<jG dd de5e eJeOe<jd e)Z¢dÚd dd d¡d¢d£Z£d d d¤d¥d¦Z¤d d d¤d§d¨Z¥G d©dª dªeBj¦Z§dÛd«d¬dd®d¯d°d±Z¨d«d²d³d´dµZ©d«d²d³d¶d·Zªd¸d¸d²d¹dºd»Z«d¸d¸d²d¹d¼d½Z¬d¸d¾d²d¿dÀdÁZdÂdÃdÃdÄdÅdÆZ®dÇdÈdÈd²dÉdÊdËZ¯G dÌdÍ dÍe°Z±dÎdÎdÎdÏdÐdÑZ²dÜdÒdÓdÎdÎdÈd²d²d²d²dÔdÕ
|
dÖd×Z³dS )Ýé )Ú annotationsN)Ú AbstractSet)ÚAny)ÚCallable)Úcast)ÚDict)Ú FrozenSet)ÚGeneric)ÚIterable)ÚIterator)ÚList)ÚMatch)ÚOptional)ÚSequence)ÚTuple)ÚType)Ú TYPE_CHECKING)ÚTypeVar)ÚUnioné )Ú
|
attributes)Úexc)Ú_O)Úinsp_is_aliased_class)Úinsp_is_mapper)Úprop_is_relationship)Ú_class_to_mapper)Ú_MappedAnnotationBase)Ú
|
_never_set)Ú _none_set)Ú attribute_str)Ú class_mapper)ÚInspectionAttr)Ú instance_str)ÚMapped)Ú object_mapper)Ú object_state)Úopt_manager_of_class)Ústate_attribute_str)Ústate_class_str)Ú state_str)ÚCriteriaOption)ÚMapperProperty)ÚORMColumnsClauseRole)ÚORMEntityColumnsClauseRole)ÚORMFromClauseRole)Ú PathRegistryé )Úevent)Ú
|
inspection)Úsql)Úutil©Ú result_tuple)Ú coercions)Ú
|
expression)Úlambdas)Úroles)Úvisitors)Ú is_selectable)ÚSupportsCloneAnnotations)ÚColumnCollection)Ú HasCacheKey)ÚMemoizedHasCacheKey)Ú ColumnElement)ÚKeyedColumnElement)Ú
|
FromClause)Ú MemoizedSlots)Úde_stringify_annotation)Úde_stringify_union_elements)Úeval_name_only)Úis_origin_of_cls)ÚLiteral)ÚProtocol)Útyping_get_origin)Ú _EntityType)Ú_IdentityKeyType)Ú_InternalEntityType)Ú _ORMCOLEXPR)Ú _MapperEntity)ÚORMCompileState)ÚMapper)ÚQuery)ÚRelationshipProperty)ÚRow)Ú
|
RowMapping)Ú_CE)Ú_ColumnExpressionArgument)Ú_EquivalentColumnMap)Ú_FromClauseArgument)Ú_OnClauseArgument)Ú_PropagateAttrsType)Ú_SA)ÚReadOnlyColumnCollection)Ú BindParameter)Ú_ColumnsClauseElement)ÚAlias)ÚSelect)Ú
|
Selectable)ÚSubquery)Úanon_map)Ú_AnnotationScanType)ÚArgsTypeProcotolÚ_T)Úbound)Údeleteú delete-orphanÚallÚmergeÚexpungeú save-updateúrefresh-expireÚnoner$ )Zlocals_c @ s, e Zd Zdddddddddd d
|
d ZdS ) Ú_DeStringifyAnnotationNF)Ústr_cleanup_fnÚinclude_genericú Type[Any]rg Ústrú#Optional[Callable[[str, str], str]]Úbool)ÚclsÚ
|
annotationÚoriginating_modulert ru Úreturnc C s d S ©N© )Úselfrz r{ r| rt ru r r úJd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\sqlalchemy/orm/util.pyÚ__call__ s z _DeStringifyAnnotation.__call__©Ú__name__Ú
|
__module__Ú __qualname__r r r r r rs s ùrs c @ s( e Zd Zdddddddddd ZdS )
|
Ú_DeStringifyUnionElementsN©rt rv rh rw rx )rz r{ r| rt r} c C s d S r~ r )r rz r{ r| rt r r r r § s z"_DeStringifyUnionElements.__call__r r r r r r ¦ s úr c @ s e Zd ZddddddZdS )Ú _EvalNameOnlyrw r )ÚnameÚ module_namer} c C s d S r~ r )r r r r r r r ¹ s z_EvalNameOnly.__call__Nr r r r r r ¸ s r c s e Zd ZU dZe dddg¡ZeZdddddgZdZ d e
|
d
|
< d e
|
d < d e
|
d < d e
|
d< d e
|
d< d e
|
d < dd d fdd Z dd Z e dd Z ZS )ÚCascadeOptionszHKeeps track of the options sent to
|
:paramref:`.relationship.cascade`rm rr rl ro rq rn )Ú save_updaterk Úrefresh_expirern ro Ú delete_orphanry r rk r r z#Optional[Union[Iterable[str], str]])Ú
|
value_listr} c
|
sì t |ts|d kr | |¡S t|}| | j¡rZt dd dd t | | j¡D ¡ ¡d|krn|
|
| j ¡ d|kr~| ¡ | d¡ t | |¡}d|k|_d|k|_d |k|_d
|
|k|_d |k|_d |k|_|jrè|jsèt d ¡ |S )Nz Invalid cascade option(s): %sú, c S s g | ] }t |qS r )Úrepr©Ú.0Úxr r r Ú
|
<listcomp>å s ÿz*CascadeOptions.__new__.<locals>.<listcomp>rm rr rp rk rq rn ro rl z5The 'delete-orphan' cascade option requires 'delete'.)Ú
|
isinstancerw Ú from_stringÚsetÚ
|
differenceÚ_allowed_cascadesÚsa_excÚ ArgumentErrorÚjoinÚsortedÚupdateÚ_add_w_all_cascadesÚclearÚdiscardÚsuperÚ__new__r rk r rn ro r r5 Úwarn)rz r Úvaluesr ©Ú __class__r r r¥ Û s@
|
|
ÿþÿÿÿ
|
|
|
|
|
|
|
ÿzCascadeOptions.__new__c C s dd dd t| D ¡ S )NzCascadeOptions(%r)ú,c S s g | ]}|qS r r r r r r r s z+CascadeOptions.__repr__.<locals>.<listcomp>)r r ©r r r r Ú__repr__ s zCascadeOptions.__repr__c C s" dd t d|pd¡D }| |S )Nc S s g | ] }|r|qS r r )r Úcr r r r s z.CascadeOptions.from_string.<locals>.<listcomp>z\s*,\s*Ú )ÚreÚsplit)rz Úargr§ r r r r s zCascadeOptions.from_string)r r
r Ú__doc__Ú all_cascadesr r¡ r Z_viewonly_cascadesÚ __slots__Ú__annotations__r¥ r¬ Ú classmethodr Ú __classcell__r r r¨ r r À s"
|
ÿ 'r c sê sfdd |r^ fdd} fdd} fdd} fd d
|
}n6 fd d} fd d} fd d}t j| d|ddd t j| d|dd t j| d|ddd |ræt j| d|ddd dS )zNRuns a validation method on an attribute value to be set or
|
appended.
|
c s | j j}|j|k S r~ )ÚmanagerÚimpl)ÚstateÚ initiatorr¹ )Úkeyr r Údetect_is_backref s z,_validator_events.<locals>.detect_is_backrefc s4 |j tjk r,s | |s,| ¡ |dS |S d S ©NF©Úopr ZOP_BULK_REPLACEÚobj©rº Úvaluer» ©r½ Úinclude_backrefsr¼ Ú validatorr r Úappend s ÿÿz!_validator_events.<locals>.appendc s8 s| |s4| ¡ fdd|D |d d
< d S )Nc s g | ]} |d qS )Fr ©r rà ©r¼ rÁ rÆ r r r # s ú7_validator_events.<locals>.bulk_set.<locals>.<listcomp>©rÁ ©rº r§ r» rÄ rË r Úbulk_set s
|
ÿz#_validator_events.<locals>.bulk_setc s( s | |s | ¡ |dS |S d S r¾ rË ©rº rà Zoldvaluer» rÄ r r Úset_' s z _validator_events.<locals>.set_c s$ s | |s | ¡ |d d S )NTrË r rÄ r r Úremove- s z!_validator_events.<locals>.removec s2 |j tjk r*s | |s*| ¡ |S |S d S r~ r¿ r rÄ r r rÇ 3 s ÿÿc s8 s| |s4| ¡ fdd|D |d d
< d S )Nc s g | ]} |qS r r rÈ rÉ r r r > s rÊ rË rÌ rÄ rË r rÍ ; s c s& s | |s | ¡ |S |S d S r~ rË rÎ rÄ r r rÏ @ s rÇ T)ÚrawÚretvalZ bulk_replace)rÑ r rÐ N)r2 Úlisten) Údescr¼ rÆ Zinclude_removesrÅ rÇ rÍ rÏ rÐ r rÄ r Ú_validator_events s rÕ Úp_unionTc
|
|
s6 t ¡ }i i | D ]|}| | tjtjdd| |< i }jD ]B}|j|krdt d||f ¡|
|
|j¡ |||j< |j |j< qD|< q fddg }| ¡ D ]v\} |dk rþ| tjfdd|D t t | ¡¡ |¡g ¡¡ q®| tjfd d|D ¡¡ q®tj| |¡S )
|
a0 Create a ``UNION`` statement used by a polymorphic mapper.
|
|
See :ref:`concrete_inheritance` for an example of how
|
this is used.
|
|
:param table_map: mapping of polymorphic identities to
|
:class:`_schema.Table` objects.
|
:param typecolname: string name of a "discriminator" column, which will be
|
derived from the query, producing the polymorphic identity for
|
each row. If ``None``, no polymorphic discriminator is generated.
|
:param aliasname: name of the :func:`~sqlalchemy.sql.expression.alias()`
|
construct generated.
|
:param cast_nulls: if True, non-existent columns, which are represented
|
as labeled NULLs, will be passed into CAST. This is a legacy behavior
|
that is problematic on some backends such as Oracle - in which case it
|
can be set to False.
|
|
T)Z allow_selectzÂPolymorphic union can't use '%s' as the discriminator column due to mapped column %r; please apply the 'typecolname' argument; this is available on ConcreteBase as '_concrete_discriminator_name'c sh z| | W S t k
|
rb r@t t ¡ | ¡ | ¡ Y S t t ¡ | ¡ | ¡ Y S Y nX d S r~ )ÚKeyErrorr4 r ÚnullÚlabelZ type_coerce)r Útable)Ú
|
cast_nullsÚ colnamemapsÚtypesr r Úcol~ s z polymorphic_union.<locals>.colNc s g | ]} |qS r r ©r r ©rÞ rÚ r r r s z%polymorphic_union.<locals>.<listcomp>c s g | ]} |qS r r rß rà r r r s )r5 Z
|
OrderedSetr8 Úexpectr; ZStrictFromClauseRoler r¼ r ZInvalidRequestErrorÚaddÚtypeÚitemsrÇ r4 ÚselectZliteral_columnÚsql_utilZ_quote_ddl_exprrÙ Ú select_fromZ union_allÚalias)
|
Z table_mapZ typecolnameZ aliasnamerÛ Zcolnamesr¼ Úmr ÚresultÚtype_r )rÛ rÞ rÜ rÚ rÝ r Úpolymorphic_unionM sb ÿ
|
|
ûÿ
|
|
ÿþÿÿþ ÷ÿ ÿþÿrì )ÚinstanceÚrowÚidentity_tokenzOptional[Type[_T]]zUnion[Any, Tuple[Any, ...]]z Optional[_T]z%Optional[Union[Row[Any], RowMapping]]ú Optional[Any]z_IdentityKeyType[_T])Úclass_Úidentrí rî rï r} c C sz | dk rRt | }|dkrB|dkr*t d¡|jtt |¡|dS |j||dS n$|dk rlt|}| |¡S t d¡dS )aQ Generate "identity key" tuples, as are used as keys in the
|
:attr:`.Session.identity_map` dictionary.
|
|
This function has several call styles:
|
|
* ``identity_key(class, ident, identity_token=token)``
|
|
This form receives a mapped class and a primary key scalar or
|
tuple as an argument.
|
|
E.g.::
|
|
>>> identity_key(MyClass, (1, 2))
|
(<class '__main__.MyClass'>, (1, 2), None)
|
|
:param class: mapped class (must be a positional argument)
|
:param ident: primary key, may be a scalar or tuple argument.
|
:param identity_token: optional identity token
|
|
.. versionadded:: 1.2 added identity_token
|
|
|
* ``identity_key(instance=instance)``
|
|
This form will produce the identity key for a given instance. The
|
instance need not be persistent, only that its primary key attributes
|
are populated (else the key will contain ``None`` for those missing
|
values).
|
|
E.g.::
|
|
>>> instance = MyClass(1, 2)
|
>>> identity_key(instance=instance)
|
(<class '__main__.MyClass'>, (1, 2), None)
|
|
In this form, the given instance is ultimately run though
|
:meth:`_orm.Mapper.identity_key_from_instance`, which will have the
|
effect of performing a database check for the corresponding row
|
if the object is expired.
|
|
:param instance: object instance (must be given as a keyword arg)
|
|
* ``identity_key(class, row=row, identity_token=token)``
|
|
This form is similar to the class/tuple form, except is passed a
|
database result row as a :class:`.Row` or :class:`.RowMapping` object.
|
|
E.g.::
|
|
>>> row = engine.execute(\
|
text("select * from table where a=1 and b=2")\
|
).first()
|
>>> identity_key(MyClass, row=row)
|
(<class '__main__.MyClass'>, (1, 2), None)
|
|
:param class: mapped class (must be a positional argument)
|
:param row: :class:`.Row` row returned by a :class:`_engine.CursorResult`
|
(must be given as a keyword arg)
|
:param identity_token: optional identity token
|
|
.. versionadded:: 1.2 added identity_token
|
|
Nzident or row is required)rï z class or instance is required)
|
r! r r Z identity_key_from_primary_keyÚtupler5 Zto_listZidentity_key_from_rowr% Zidentity_key_from_instance)rñ rò rí rî rï Úmapperr r r Ú identity_key s" G
|
ÿ ÿ
|
rõ c @ sh e Zd ZdZe ¡ Ze ¡ Ze ¡ Ze ¡ Z e ¡ Z
|
e ¡ Z e ¡ Z e ¡ Z e ¡ Ze ¡ Ze ¡ ZdS )Ú_TraceAdaptRoleaÓ Enumeration of all the use cases for ORMAdapter.
|
|
ORMAdapter remains one of the most complicated aspects of the ORM, as it is
|
used for in-place adaption of column expressions to be applied to a SELECT,
|
replacing :class:`.Table` and other objects that are mapped to classes with
|
aliases of those tables in the case of joined eager loading, or in the case
|
of polymorphic loading as used with concrete mappings or other custom "with
|
polymorphic" parameters, with whole user-defined subqueries. The
|
enumerations provide an overview of all the use cases used by ORMAdapter, a
|
layer of formality as to the introduction of new ORMAdapter use cases (of
|
which none are anticipated), as well as a means to trace the origins of a
|
particular ORMAdapter within runtime debugging.
|
|
SQLAlchemy 2.0 has greatly scaled back ORM features which relied heavily on
|
open-ended statement adaption, including the ``Query.with_polymorphic()``
|
method and the ``Query.select_from_entity()`` methods, favoring
|
user-explicit aliasing schemes using the ``aliased()`` and
|
``with_polymorphic()`` standalone constructs; these still use adaption,
|
however the adaption is applied in a narrower scope.
|
|
N)r r
r r² ÚenumÚautoÚ ALIASED_INSPZ JOINEDLOAD_USER_DEFINED_ALIASZ JOINEDLOAD_PATH_WITH_POLYMORPHICZJOINEDLOAD_MEMOIZED_ADAPTERZMAPPER_POLYMORPHIC_ADAPTERZWITH_POLYMORPHIC_ADAPTERZ#WITH_POLYMORPHIC_ADAPTER_RIGHT_JOINZ DEPRECATED_JOIN_ADAPT_RIGHT_SIDEZADAPT_FROM_STATEMENTZCOMPOUND_EAGER_STATEMENTZLEGACY_SELECT_FROM_ALIASr r r r rö ù s rö c
|
sH e Zd ZdZdZdddddddddd d
|
d
|
d
|
d
|
d d fd dZ ZS )ÚORMStatementAdapterz.ColumnAdapter which includes a role attribute.)ÚroleNFT©Ú equivalentsÚadapt_requiredÚallow_label_resolveÚanonymize_labelsÚadapt_on_namesÚadapt_from_selectablesrö rd ú Optional[_EquivalentColumnMap]ry ú!Optional[AbstractSet[FromClause]])rû Ú
|
selectablerý rþ rÿ r r r c s$ || _ t j|||||||d d S )Nrü )rû r¤ Ú__init__) r rû r rý rþ rÿ r r r r¨ r r r : s ùz ORMStatementAdapter.__init__)r r
r r² r´ r r· r r r¨ r rú 5 s örú c sj e Zd ZU dZdZded< ded< ddd ddd ddd
|
d d d dddddddd
|
fddZdd Z ZS )Ú
|
ORMAdapterzaColumnAdapter subclass which excludes adaptation of entities from
|
non-matching mappers.
|
|
)rû rô Úis_aliased_classÚ aliased_inspry r úOptional[AliasedInsp[Any]]r NFT)rý rþ rÿ r r Úlimit_on_entityr r rö ú_InternalEntityType[Any]r zOptional[Selectable]r )
|
rû Úentityrý rþ rÿ r r r r r c
|
sh || _ |j| _|d kr |j}t|r2d| _|| _n d| _d | _t j||||||rX| jnd | |
|
d d S )NTF)rþ rÿ r Z
|
include_fnr r ) rû rô r r r r r¤ r Ú _include_fn) r rû r rý rþ rÿ r r r r r r¨ r r r ] s& øzORMAdapter.__init__c C s, |j dd ¡}| p*| | j¡p*| j |¡S )NÚ parentmapper)Ú _annotationsÚgetÚisarô )r Úelemr r r r r s zORMAdapter._include_fn) r r
r r² r´ rµ r r r· r r r¨ r r R s
|
ô($r c @ s e Zd ZU dZded< d"dddd d d
|
d d d d d
|
ddZedddddZdddddZddddddd Z dd d d Z
|
dd d d!Z dS )#Ú AliasedClassaà Represents an "aliased" form of a mapped class for usage with Query.
|
|
The ORM equivalent of a :func:`~sqlalchemy.sql.expression.alias`
|
construct, this object mimics the mapped class using a
|
``__getattr__`` scheme and maintains a reference to a
|
real :class:`~sqlalchemy.sql.expression.Alias` object.
|
|
A primary purpose of :class:`.AliasedClass` is to serve as an alternate
|
within a SQL statement generated by the ORM, such that an existing
|
mapped entity can be used in multiple contexts. A simple example::
|
|
# find all pairs of users with the same name
|
user_alias = aliased(User)
|
session.query(User, user_alias).\
|
join((user_alias, User.id > user_alias.id)).\
|
filter(User.name == user_alias.name)
|
|
:class:`.AliasedClass` is also capable of mapping an existing mapped
|
class to an entirely new selectable, provided this selectable is column-
|
compatible with the existing mapped selectable, and it can also be
|
configured in a mapping as the target of a :func:`_orm.relationship`.
|
See the links below for examples.
|
|
The :class:`.AliasedClass` object is constructed typically using the
|
:func:`_orm.aliased` function. It also is produced with additional
|
configuration when using the :func:`_orm.with_polymorphic` function.
|
|
The resulting object is an instance of :class:`.AliasedClass`.
|
This object implements an attribute scheme which produces the
|
same attribute and method interface as the original mapped
|
class, allowing :class:`.AliasedClass` to be compatible
|
with any attribute technique which works on the original class,
|
including hybrid attributes (see :ref:`hybrids_toplevel`).
|
|
The :class:`.AliasedClass` can be inspected for its underlying
|
:class:`_orm.Mapper`, aliased selectable, and other information
|
using :func:`_sa.inspect`::
|
|
from sqlalchemy import inspect
|
my_alias = aliased(MyClass)
|
insp = inspect(my_alias)
|
|
The resulting inspection object is an instance of :class:`.AliasedInsp`.
|
|
|
.. seealso::
|
|
:func:`.aliased`
|
|
:func:`.with_polymorphic`
|
|
:ref:`relationship_aliased_class`
|
|
:ref:`relationship_to_window_function`
|
|
|
rw r NFz_EntityType[_O]zOptional[FromClause]ú Optional[str]ry ú Optional[Sequence[Mapper[Any]]]ú Optional[ColumnElement[Any]]r
|
)
|
Úmapped_class_or_acrè r Úflatr Úwith_polymorphic_mappersÚ with_polymorphic_discriminatorÚ
|
base_aliasÚuse_mapper_pathÚrepresents_outer_joinc C s° t dt |¡} | j} d} |d krN| jr<| jjr<| j ¡ }qX| jj ||d}n
|
| jrXd} |d k sdt
|
t | | |||rv|n| j |d k r|n| j || ||
|
| | _d| jj d| _d S )Nú_InternalEntityType[_O]F©r r Túaliased(ú))r r3 Úinspectrô r r Z _is_subqueryrè Z _with_polymorphic_selectableÚ_anonymous_fromclauseÚAssertionErrorÚ AliasedInspr Úpolymorphic_onÚ _aliased_insprñ r )r r rè r r r r r r r r Zinsprô Ú nest_adaptersr r r r Æ sF ÿ þÿ ÿÿñzAliasedClass.__init__úAliasedInsp[_O]úAliasedClass[_O])r r} c C s\ | | ¡}d|jjj d|_||_|jrX|jD ]&}||k r0t |¡}t ||jj| q0|S )Nr! r" )
|
r¥ rô rñ r r( Ú_is_with_polymorphicÚ_with_polymorphic_entitiesr Ú _reconstitute_from_aliased_inspÚsetattr)rz r rÁ Zsub_aliased_inspÚentr r r r. ü s
|
|
ÿz,AliasedClass._reconstitute_from_aliased_inspr )r¼ r} c C s z| j d }W n tk
|
r( t Y nX |j}t||}t|dr\t|dr\t |j| ¡S t|drr| d | ¡}t|dr|
|
|¡}t | || |S )Nr( r Ú__self__Ú__get__Úadapt_to_entity) Ú__dict__r× ÚAttributeErrorÚ_targetÚgetattrÚhasattrrÝ Ú
|
MethodTypeÚ__func__r2 r3 r/ )r r¼ r( ÚtargetÚattrr r r Ú __getattr__ s
|
|
|
|
zAliasedClass.__getattr__r )r¼ Ú mapped_classr r} c C sr t ||}t|dr,t|dr,t |j| ¡S t|drB| d | ¡}t|drnt | ¡|_| |¡}t
|
| || |S )Nr r1 r2 r3 ) r7 r8 rÝ r9 r: r2 ÚweakrefÚrefÚ _weak_entityr3 r/ )r r¼ r> r r< r r r Ú_get_from_serialized+ s
|
|
|
|
z!AliasedClass._get_from_serialized©r} c C s dt | | jjjf S )Nz<AliasedClass at 0x%x; %s>)Úidr( r6 r r« r r r r¬ B s þzAliasedClass.__repr__c C s
|
t | jS r~ )rw r( r« r r r Ú__str__H s zAliasedClass.__str__) NNFFNNNFF) r r
r r² rµ r r¶ r. r= rB r¬ rE r r r r r s$
|
: õ"6 r r* c @ sò e Zd ZU dZdZdejjfdejjfdejjfdejj fdejj
|
fdej j fd ej j
|
fgZ d
|
ed < d ed< d ed< ded< ded< ded< ded< ddd ddddddddd d d Zed\d!d"dddd#d$d%d&Zed]d'd(d)dddddddd*
|
d+d,Zedd-d.d/Zd0Zd d-d1d2Zedd-d3d4Zed5d-d6d7Zed8d-d9d:Zd;d-d<d=Zd;d>d?d@dAZdBdBdCdDdEZ d^dFddFdGdHdIZ e r²d_dJddJdKdLdMZ ne Z dNdO Z dPdQ Z!dRdS Z"dTdU Z#dVdW Z$dXdY Z%dZd[ Z&d S )`r& aû Provide an inspection interface for an
|
:class:`.AliasedClass` object.
|
|
The :class:`.AliasedInsp` object is returned
|
given an :class:`.AliasedClass` using the
|
:func:`_sa.inspect` function::
|
|
from sqlalchemy import inspect
|
from sqlalchemy.orm import aliased
|
|
my_alias = aliased(MyMappedClass)
|
insp = inspect(my_alias)
|
|
Attributes on :class:`.AliasedInsp`
|
include:
|
|
* ``entity`` - the :class:`.AliasedClass` represented.
|
* ``mapper`` - the :class:`_orm.Mapper` mapping the underlying class.
|
* ``selectable`` - the :class:`_expression.Alias`
|
construct which ultimately
|
represents an aliased :class:`_schema.Table` or
|
:class:`_expression.Select`
|
construct.
|
* ``name`` - the name of the alias. Also is used as the attribute
|
name when returned in a result tuple from :class:`_query.Query`.
|
* ``with_polymorphic_mappers`` - collection of :class:`_orm.Mapper`
|
objects
|
indicating all those mappers expressed in the select construct
|
for the :class:`.AliasedClass`.
|
* ``polymorphic_on`` - an alternate column or SQL expression which
|
will be used as the "discriminator" for a polymorphic load.
|
|
.. seealso::
|
|
:ref:`inspection_toplevel`
|
|
)Ú __weakref__rA rô r r Ú_adapt_on_namesr r' Ú_use_mapper_pathÚ _base_aliasr Úpersist_selectableÚ local_tabler, r- Ú_adapterr6 Ú__clause_element__Ú_memoized_valuesZ_all_column_expressionsÚ_nest_adaptersr rG rH r6 r r r' z
|
Mapper[_O]rô rD r rL zSequence[Mapper[Any]]zSequence[AliasedInsp[Any]]r- z weakref.ref[AliasedClass[_O]]rA zUnion[_O, AliasedClass[_O]]r+ r r r r r
|
ry ) r Ú inspectedr r r r' rI rH r r r) c
|
s0 |j } |j} t |¡| _| | _| | _ | _| _|| _|| _ t |pF| ¡| _
|
|| _ |
|
| _ | | _ |r¾d| _|| _g | _| jD ]@}|| k rzt|j|| |d}t| j |jj| | j |j¡ qznd| _| g| _ttj| || j d fdd| jD dd| _| r t |t st |j | j¡| _ | _ | | _!d S )NT)r r r Fc s h | ]} s|j qS r )r )r ré ©r r r Ú <setcomp>ï s þz'AliasedInsp.__init__.<locals>.<setcomp>)r rý r r r r )"r rô r? r@ rA r rJ rK r r' rI rH r rO r, r r- r rñ r/ r rÇ r( r rö rù Z_equivalent_columnsrL r r& r% ÚwraprG r6 )r r rP r r r r' rI rH r r r) r rô Zpolyr0 r rQ r r ² s` þ
|
û
|
þñzAliasedInsp.__init__NFz"Union[_EntityType[_O], FromClause]z Optional[Union[Alias, Subquery]]z#Union[AliasedClass[_O], FromClause])Úelementrè r r r r} c C sT t |tr>|rt d¡|r*|j||dS tjtj||dS nt |||||dS d S )Nz+adapt_on_names only applies to ORM elementsr ©r )rè r r r )
|
r rD r r rè r8 rá r; ZAnonymizedFromClauseRoler )rz rT rè r r r r r r Ú_alias_factoryÿ s&
|
|
ÿ ÿûzAliasedInsp._alias_factoryzUnion[Type[_O], Mapper[_O]]z/Union[Literal['*'], Iterable[_EntityType[Any]]]z)Union[Literal[(False, None)], FromClause])
|
ÚbaseÚclassesr r r' ÚaliasedÚ innerjoinr rH r} c
|
C sj t |}
|
|dkr |r t d¡|
|
j|||d\} }|s:|rR|d k sFt|j|d}t||| ||| | dS )Nr¾ z[the 'flat' and 'selectable' arguments cannot be passed simultaneously to with_polymorphic()©rZ rU )r r r r r )r r r Ú_with_polymorphic_argsr% r$ r ) rz rW rX r r r' rY rZ r rH Úprimary_mapperÚmappersr r r Ú_with_polymorphic_factory s, ÿ ÿ
|
ùz%AliasedInsp._with_polymorphic_factoryrC c C s* | ¡ }|d kr&t | ¡}t |¡| _ |S r~ )rA r r. r? r@ )r r0 r r r r D s
|
|
zAliasedInsp.entityTc C s" | j | j| | d¡ d| d¡S )N)r Ú parententityÚentity_namespaceÚorm©Zcompile_state_pluginÚplugin_subject)r Ú _annotaterô Ú_set_propagate_attrsr« r r r Ú#_memoized_method___clause_element__U s ýÿùz/AliasedInsp._memoized_method___clause_element__c C s | j S r~ )r r« r r r ra ` s z AliasedInsp.entity_namespaceúType[_O]c C s | j jS )zUReturn the mapped class ultimately represented by this
|
:class:`.AliasedInsp`.)rô rñ r« r r r rñ d s zAliasedInsp.class_r0 c C s | j r| jjS t | ¡S d S r~ )rH rô Ú_path_registryr0 Z
|
per_mapperr« r r r ri j s zAliasedInsp._path_registryzDict[str, Any]c C s4 | j | j| j| j| j| j| j| ¡ | j| j | j
|
d S )N) r rô rè r r r r r r r r) ) r rô r r rG r r' rI rH r rO r« r r r Ú __getstate__q s õzAliasedInsp.__getstate__ÚNone)rº r} c C sN | |d |d |d |d |d |d |d |d |d |d
|
|d ¡ d S ) Nr rô rè r r r r r r r r) )r )r rº r r r Ú __setstate__ s õzAliasedInsp.__setstate__r* )Úotherr} c C s |j }| j |kstt dd | jD ¡}dd |jD }||krF|S | |¡}|j|d |j d\}}|jdd}t ||||j
|
|j |jdj S ) Nc s s | ] }|j V qd S r~ ©rñ ©r Úmpr r r Ú <genexpr> s z*AliasedInsp._merge_with.<locals>.<genexpr>c S s h | ]
|
}|j qS r rn ro r r r rR s z*AliasedInsp._merge_with.<locals>.<setcomp>r[ TrU )r r r r ) rô r% r5 Zto_setr Úunionr\ r r$ r r' rH r( )r rm r] Z our_classesZ new_classesrX r^ r r r r Ú _merge_with s.
|
ÿ
|
ÿ
|
úzAliasedInsp._merge_withrP )Úexprr¼ r} c C sD t |tst| | jd}|r&||d< | j |¡ |¡ d| d¡S )N)r` r Ú proxy_keyrb rc )r rB r% rô rL Útraversere rf )r rt r¼ Údr r r Ú_adapt_element s þ ÿýÿzAliasedInsp._adapt_elementrX )rÁ r¼ r} c C s d S r~ r )r rÁ r¼ r r r Ú_orm_adapt_elementÆ s z AliasedInsp._orm_adapt_elementc C sX | j }||kr0|| jkr | S t| j|jjjS n$| | j¡r@| S dsTtd|| f d S )NFz"mapper %s doesn't correspond to %s) r rô r7 r rñ r r( r r% )r rô Z self_polyr r r Ú_entity_for_mapperÐ s
|
ÿ z AliasedInsp._entity_for_mapperc s. j j\}} j |¡ fdd| ¡ D fS )Nc s i | ]\}} j |¡|qS r )rL rv )r rÞ Úparamr« r r Ú
|
<dictcomp>â s ÿ
|
z:AliasedInsp._memoized_attr__get_clause.<locals>.<dictcomp>)rô Z _get_clauserL rv rä )r ÚonclauseZ
|
replacemapr r« r Ú_memoized_attr__get_clauseÞ s
|
|
þþz&AliasedInsp._memoized_attr__get_clausec C s i S r~ r r« r r r Ú _memoized_attr__memoized_valuesè s z+AliasedInsp._memoized_attr__memoized_valuesc sD j r j dd jD ¡}n
|
j ¡ } fdd|D }t|S )Nc S s g | ]
|
}|j qS r )rô )r r0 r r r r î s zFAliasedInsp._memoized_attr__all_column_expressions.<locals>.<listcomp>c s g | ]\}}| |¡fqS r )rx )r r¼ rÞ r« r r r ó s )r, rô Z_columns_plus_keysr- r? )r Zcols_plus_keysr r« r Ú&_memoized_attr__all_column_expressionsë s ÿ
|
|
ÿz2AliasedInsp._memoized_attr__all_column_expressionsc O s0 || j kr| j | S ||| | j |< }|S d S r~ )rN )r r¼ Z callable_ÚargsÚkwrà r r r Ú_memoù s
|
|
zAliasedInsp._memoc C s< | j r"dd dd | j D ¡ }nd}dt| | jj|f S )Nz(%s)r c s s | ]}|j jV qd S r~ )rñ r ro r r r rq s z'AliasedInsp.__repr__.<locals>.<genexpr>r® z<AliasedInsp at 0x%x; %s%s>)r r rD rñ r )r Z with_polyr r r r¬ s ÿ ýzAliasedInsp.__repr__c s> j r,d jjd fdd jD ¡f S d jjf S d S )Nzwith_polymorphic(%s, [%s])r c 3 s | ]}| j k r|jjV qd S r~ )rô rñ r ro r« r r rq s
|
þz&AliasedInsp.__str__.<locals>.<genexpr>z aliased(%s))r, r6 r r r r« r r« r rE s þþ zAliasedInsp.__str__)NNFF)FFNFFFF)N)N)'r r
r r² r´ r< ÚExtendedInternalTraversalZ dp_stringÚ
|
dp_booleanZdp_inspectableÚdp_clauseelementÚInternalTraversalZdp_has_cache_key_listZ_cache_key_traversalrµ r r¶ rV r_ Úpropertyr r rg ra rñ ri rj rl rs rx r ry rz r~ r r r r¬ rE r r r r r& L sz
|
|
&
|
|
|
|
|
þ
|
ö "M ú ö$& ÿ ý
|
r& c @ s. e Zd ZdZdZdd Ze d¡dd ZdS ) Ú_WrapUserEntitya A wrapper used within the loader_criteria lambda caller so that
|
we can bypass declared_attr descriptors on unmapped mixins, which
|
normally emit a warning for such use.
|
|
might also be useful for other per-lambda instrumentations should
|
the need arise.
|
|
©Úsubjectc C s
|
|| _ d S r~ r )r r r r r r ' s z_WrapUserEntity.__init__zsqlalchemy.orm.decl_apic C sP t jjj}t | d¡}||jkrBt|j| |jrB|j| |¡S t
|
||S d S )Nr ) r5 Z preloadedrb Údecl_apiÚobjectÚ__getattribute__r4 r Z declared_attrÚfgetr7 )r r r r r r r r * s
|
ÿz _WrapUserEntity.__getattribute__N) r r
r r² r´ r r5 Zpreload_moduler r r r r r s
|
r c @ s e Zd ZU dZdZdejjfdejjfdej j
|
fdej j fdej j fgZ de d< d e d< d
|
e d< d e d < d e d< d e d< d e d< d3ddd d d d dddZedd Zdd Zddd d Zd d d d d!Zd"d#d$d%d&Zd d'd(d)d*d+Zd d(d d,d-Zd.d(d/d0d1Zd2S )4ÚLoaderCriteriaOptiona
|
Add additional WHERE criteria to the load for all occurrences of
|
a particular entity.
|
|
:class:`_orm.LoaderCriteriaOption` is invoked using the
|
:func:`_orm.with_loader_criteria` function; see that function for
|
details.
|
|
.. versionadded:: 1.4
|
|
)Ú root_entityr Údeferred_where_criteriaÚwhere_criteriaÚ_where_crit_origÚinclude_aliasesÚpropagate_to_loadersr r r r r zOptional[Type[Any]]z"Optional[_InternalEntityType[Any]]z9Union[ColumnElement[bool], lambdas.DeferredLambdaElement]ry r r r FTz_EntityType[Any]z _ColumnExpressionArgument[bool])Úentity_or_baser Ú loader_onlyr r Útrack_closure_variablesc C s¾ t dt |d¡}|d kr.t d|| _d | _n d | _|| _|| _t|r| jd k rZ| j}n|d k sft|j}d| _t j
|
|t j t |ft j|dd| _nd| _t t j |¡| _|| _|| _d S )Nr Frv T)r )Z lambda_argsÚopts)r r3 r# r r r Úcallabler% r r: ZDeferredLambdaElementr; ZWhereHavingRoler Z LambdaOptionsr r8 rá r r ) r r r r r r r r Z wrap_entityr r r r ^ s>
|
þ
|
ÿü
|
ÿz LoaderCriteriaOption.__init__c C s t ||||dS )N)r r )r )rz r r r r r r r Ú _unreduce s üz LoaderCriteriaOption._unreducec C s( t j| jr| jjn| j| j| j| jffS r~ )r r r rñ r r r r r« r r r Ú
|
__reduce__ s üþz LoaderCriteriaOption.__reduce__zIterator[Mapper[Any]]rC c c sz | j r| j jjE d H n^| js"tt| j ¡ }|rv| d¡}tdt j
|
|dd}|rf|jjE d H q0| | ¡ ¡ q0d S )Nr r F)Úraiseerr) r rô Zself_and_descendantsr r% ÚlistÚ__subclasses__Úpopr r3 r# Úextend)r ÚstackÚsubclassr0 r r r Ú _all_mappers¢ s
|
|
þz!LoaderCriteriaOption._all_mappersrR )Ú compile_stater} c C s |j j dd ¡| krdS dS )NÚfor_loader_criteriaFT)Zselect_statementr r ©r r¦ r r r Ú_should_include´ s ÿýÿz$LoaderCriteriaOption._should_includer úColumnElement[bool])Úext_infor} c C sF | j r td| j |j¡}n| j}t|ts0ttj |d| idddS )Nrª r§ T)Zdetect_subquery_colsZind_cols_on_fromclause)
|
r r r Z_resolve_with_argsr r rB r% ræ Ú_deep_annotate)r r« Úcritr r r Ú_resolve_where_criteria¾ s þüz,LoaderCriteriaOption._resolve_where_criteriazIterable[_MapperEntity]rk )r¦ Úmapper_entitiesr} c C s | |¡ d S r~ )Úprocess_compile_state)r r¦ r¯ r r r Ú'process_compile_state_replaced_entitiesÐ s z<LoaderCriteriaOption.process_compile_state_replaced_entitiesc C s | |j¡ dS )z7Apply a modification to a given :class:`.CompileState`.N)Úget_global_criteriaZglobal_attributesr¨ r r r r° × s z*LoaderCriteriaOption.process_compile_statezDict[Any, Any])r r} c C s, | ¡ D ] }| d|fg ¡}| | ¡ qd S )NZadditional_entity_criteria)r¥ Ú
|
setdefaultrÇ )r r rp Z load_criteriar r r r² ß s ÿz(LoaderCriteriaOption.get_global_criteriaN)FFTT)r r
r r² r´ r< r Z dp_plain_objZdp_has_cache_keyr r r
Z_traverse_internalsrµ r r¶ r r r¥ r© r® r± r° r² r r r r r 7 s:
|
|
|
|
|
|
û ù.
|
|
|
r c C s | j S r~ )r( )r; r r r Ú<lambda>è ó r´ rh zOptional[Mapper[_O]])rñ r} c C sH z&t | }|d ks|js W d S |j}W n tjk
|
r> Y d S X |S d S r~ )r' Z is_mappedrô r ZNO_STATE)rñ Z class_managerrô r r r Ú _inspect_mcë s
|
r¶ c C s t dt| }t|S )Nrh )r rL r¶ )rñ Úoriginr r r Ú_inspect_generic_aliasÿ s r¸ c @ sæ e Zd ZU dZdZdZdZdZdZe
|
¡ Z de d< e j Zde d< dd d
|
d d d ZddddddZeddddZeddddZeddd d Zde d < de d < d d! Zd"d# Zed$d% Zd&d' Zd(d)d*d+d,d-d.Zd/S )0ÚBundlea+ A grouping of SQL expressions that are returned by a :class:`.Query`
|
under one namespace.
|
|
The :class:`.Bundle` essentially allows nesting of the tuple-based
|
results returned by a column-oriented :class:`_query.Query` object.
|
It also
|
is extensible via simple subclassing, where the primary capability
|
to override is that of how the set of expressions should be returned,
|
allowing post-processing as well as custom return types, without
|
involving ORM identity-mapped classes.
|
|
.. seealso::
|
|
:ref:`bundles`
|
|
|
FTr] Ú_propagate_attrszList[_ColumnsClauseElement]Úexprsrw z _ColumnExpressionArgument[Any]r )r r» r c s` | _ _ fdd|D }| _tdd dd |D D ¡ _ _| d j¡ _dS )aQ Construct a new :class:`.Bundle`.
|
|
e.g.::
|
|
bn = Bundle("mybundle", MyClass.x, MyClass.y)
|
|
for row in session.query(bn).filter(
|
bn.c.x == 5).filter(bn.c.y == 4):
|
print(row.mybundle.x, row.mybundle.y)
|
|
:param name: name of the bundle.
|
:param \*exprs: columns or SQL expressions comprising the bundle.
|
:param single_entity=False: if True, rows for this :class:`.Bundle`
|
can be returned as a "single entity" outside of any enclosing tuple
|
in the same manner as a mapped entity.
|
|
c s g | ]}t jtj| d qS ))Zapply_propagate_attrs)r8 rá r; ÚColumnsClauseRole©r rt r« r r r I s ý ÿz#Bundle.__init__.<locals>.<listcomp>c s s | ]}t |d |j|fV qdS )r¼ N)r7 Ú_label)r rÞ r r r rq Q s ÿz"Bundle.__init__.<locals>.<genexpr>c S s g | ]}|j d |¡qS ©Úbundle©r r ©r Úer r r r S s Ú single_entityN) r r¾ r» r? Z as_readonlyr Úcolumnsr¡ rÄ )r r r» r Z coerced_exprsr r« r r 4 s
|
ü þzBundle.__init__rf zList[BindParameter[Any]]zTuple[Any, ...])rf Ú
|
bindparamsr} c s* | j | j| jft fdd| jD S )Nc s g | ]}| ¡qS r )Ú_gen_cache_keyr½ ©rf rÆ r r r [ s z)Bundle._gen_cache_key.<locals>.<listcomp>)r© r rÄ ró r» )r rf rÆ r rÈ r rÇ W s ÿzBundle._gen_cache_keyú Mapper[Any]rC c C s | j d j dd ¡S )Nr r ©r» r r r« r r r rô ^ s z Bundle.mapperr c C s | j d j dd ¡S )Nr r` rÊ r« r r r r b s z Bundle.entityz6ReadOnlyColumnCollection[str, KeyedColumnElement[Any]]c C s | j S r~ )r r« r r r ra f s zBundle.entity_namespacerÅ r c C s | j | j ¡}|j | j¡ |S r~ )r© r¥ r4 r )r Úclonedr r r Ú_clone s z Bundle._clonec C s^ | | d}| | j¡ | jd j d| j¡}tjdd | jD tj dd
|
|¡ d|d ¡S )
|
N)rÀ ra r rd c S s g | ]}|j d |¡qS r¿ rÁ r r r r r s z-Bundle.__clause_element__.<locals>.<listcomp>F)Z_literal_as_text_roleÚgrouprb rc ) r r r» rº r r r9 Z
|
ClauseListr; r¼ re rf )r r rd r r r rM s$
|
ÿþþû
|
þ÷ÿzBundle.__clause_element__c C s
|
| ¡ jS r~ )rM Úclausesr« r r r rÎ § s zBundle.clausesc C s | ¡ }||_|S )z<Provide a copy of this :class:`.Bundle` passing a new label.)rÌ r )r r rË r r r rÙ « s z Bundle.labelz Select[Any]z#Sequence[Callable[[Row[Any]], Any]]z Sequence[str]zCallable[[Row[Any]], Any])ÚqueryÚprocsÚlabelsr} c s. t |dd |D ddd fdd }|S )ag Produce the "row processing" function for this :class:`.Bundle`.
|
|
May be overridden by subclasses to provide custom behaviors when
|
results are fetched. The method is passed the statement object and a
|
set of "row processor" functions at query execution time; these
|
processor functions when given a result row will return the individual
|
attribute value, which can then be adapted into any kind of return data
|
structure.
|
|
The example below illustrates replacing the usual :class:`.Row`
|
return structure with a straight Python dictionary::
|
|
from sqlalchemy.orm import Bundle
|
|
class DictBundle(Bundle):
|
def create_row_processor(self, query, procs, labels):
|
'Override create_row_processor to return values as
|
dictionaries'
|
|
def proc(row):
|
return dict(
|
zip(labels, (proc(row) for proc in procs))
|
)
|
return proc
|
|
A result from the above :class:`_orm.Bundle` will return dictionary
|
values::
|
|
bn = DictBundle('mybundle', MyClass.data1, MyClass.data2)
|
for row in session.execute(select(bn)).where(bn.c.data1 == 'd1'):
|
print(row.mybundle['data1'], row.mybundle['data2'])
|
|
c S s g | ]}d qS )r r )r Úlr r r r Ù s z/Bundle.create_row_processor.<locals>.<listcomp>zRow[Any]r )rî r} c s fddD S )Nc s g | ] }| qS r r )r Úproc©rî r r r Ü s z=Bundle.create_row_processor.<locals>.proc.<locals>.<listcomp>r rÔ ©Z keyed_tuplerÐ rÔ r rÓ Û s z)Bundle.create_row_processor.<locals>.procr6 )r rÏ rÐ rÑ rÓ r rÕ r Úcreate_row_processor² s 'zBundle.create_row_processorN)r r
r r² rÄ Zis_clause_elementZ is_mapperr Z is_bundler5 Ú immutabledictrº rµ Ú EMPTY_SETZ proxy_setr rÇ r rô r ra rÌ rM rÎ rÙ rÖ r r r r r¹ s2
|
#
|
r¹ z
|
Bundle[_T]r^ )rT Úexcluder} c C s t | ddi|¡S )z®Deep copy the given ClauseElement, annotating each element with the
|
"_orm_adapt" flag.
|
|
Elements within the exclude collection will be cloned but not annotated.
|
|
Ú
|
_orm_adaptT)ræ r¬ )rT rÙ r r r Ú _orm_annotateá s rÛ )rT r} c C s t j| ddS )zÔRemove annotations that link a column to a particular mapping.
|
|
Note this doesn't affect "remote" and "foreign" annotations
|
passed by the :func:`_orm.foreign` and :func:`_orm.remote`
|
annotators.
|
|
)rÚ r` )r§ ©ræ Z_deep_deannotate©rT r r r Ú_orm_deannotateë s ÿrÞ c C s
|
t | ¡S r~ rÜ rÝ r r r Ú_orm_full_deannotateù s rß c
|
@ sp e Zd ZdZejjZdZddddddd d d
|
d d d Zdd Z dddddd dddZ
|
ddddd dddZ dS )Ú_ORMJoinz/Extend Join to support ORM constructs as input.TNFr r[ zOptional[_OnClauseArgument]ry rð z Tuple[ColumnElement[bool], ...])ÚleftÚrightr} ÚisouterÚfullÚ
|
_left_memoÚ _right_memoÚ_extra_criteriac C s( t dt |¡} t dt |¡}
|
|
|
j} || _|| _t|tjrpt rTt|j
|
t j sTt |j
|
¡ } |j} ||j7 }n t|tr|} | jj} nd } d } | rz| j}t | |¡r®| }nt|ts¼t |}| j|| d|
|
d|d\}}}}}}|d k r |rt |||¡}|}nt ||||¡}|}n|}|| _t| r@|j dd ¡}n t | sTt | rZ| }nd }|d k rz| j d|i¡| _|d ko|}t j! "| |||||¡ | j#d k s®t |rÈ| j#tj$| M _#| s$t%|
|
dd r$|
|
j&j'r$t d|
|
}
|
|
|
j&j(}|d k r$t |
|
r|
|
j) *|¡}| j#|@ | _#d S )Nz+Union[FromClause, _InternalEntityType[Any]]T)Zsource_selectableZdest_selectableZsource_polymorphicZof_type_entityZalias_secondaryZextra_criteriar` rô r )+r r3 r# r rå ræ r r ÚQueryableAttributer Z
|
comparatorrU Z
|
Comparatorr% Z_source_selectabler rç r, Úparentræ Zclause_is_presentrD Z _create_joinsr4 r Z_target_adapterr= r r r r rr r9 ÚJoinr r} Úand_r7 rô ZsingleZ_single_table_criterionrL rv )r rá râ r} rã rä rå ræ rç Z left_infoZ
|
right_infoZadapt_toZ on_selectableÚpropZleft_selectableZ
|
adapt_fromZpjZsjÚsourceÚdestZ secondaryZtarget_adapterr` Zaugment_onclauseZ single_critr r r r s¦ þþ ÿ
|
|
|
úù
|
|
|
ÿ
|
ÿÿ
|
þý
|
|
|
z_ORMJoin.__init__c C s` |}t |tjr|j}q| j|ks&tt| j|j| j| j| j |j d}t||j|j|j|j
|
dS )zlSplice a join into the center.
|
|
Given join(a, b) and join(b, c), return join(a, b).join(c)
|
|
)rã rå ræ )rã ræ ) r r4 rê rá râ r% rà r} rã rå ræ )r rm Zleftmostrá r r r Ú_splice_into_center} s& ú ûz _ORMJoin._splice_into_center)râ r} rã rä r} c C s t | ||||dS )N)rä rã ©rà )r râ r} rã rä r r r r s z _ORMJoin.join)râ r} rä r} c C s t | ||d|dS )NT)rã rä rð )r râ r} rä r r r Ú outerjoin£ s z_ORMJoin.outerjoin)NFFNNr )NFF)NF) r r
r r² r9 rê Z__visit_name__Z inherit_cacher rï r rñ r r r r rà ý s$ ÷ y û ürà r z"attributes.QueryableAttribute[Any]zOptional[_EntityType[Any]]rª )rí rì Ú from_entityr} c C sl t |trt d¡nHt |tjrZ|jr.|j}|j}|dksDt|sTt d| ¡|}n|}|j | |dS )a Create filtering criterion that relates this query's primary entity
|
to the given related instance, using established
|
:func:`_orm.relationship()`
|
configuration.
|
|
E.g.::
|
|
stmt = select(Address).where(with_parent(some_user, User.addresses))
|
|
|
The SQL rendered is the same as that rendered when a lazy loader
|
would fire off from the given parent on that attribute, meaning
|
that the appropriate state is taken from the parent object in
|
Python without the need to render joins to the parent table
|
in the rendered statement.
|
|
The given property may also make use of :meth:`_orm.PropComparator.of_type`
|
to indicate the left side of the criteria::
|
|
|
a1 = aliased(Address)
|
a2 = aliased(Address)
|
stmt = select(a1, a2).where(
|
with_parent(u1, User.addresses.of_type(a2))
|
)
|
|
The above use is equivalent to using the
|
:func:`_orm.with_parent.from_entity` argument::
|
|
a1 = aliased(Address)
|
a2 = aliased(Address)
|
stmt = select(a1, a2).where(
|
with_parent(u1, User.addresses, from_entity=a2)
|
)
|
|
:param instance:
|
An instance which has some :func:`_orm.relationship`.
|
|
:param property:
|
Class-bound attribute, which indicates
|
what relationship from the instance should be used to reconcile the
|
parent/child relationship.
|
|
:param from_entity:
|
Entity in which to consider as the left side. This defaults to the
|
"zero" entity of the :class:`_query.Query` itself.
|
|
.. versionadded:: 1.2
|
|
z@with_parent() accepts class-bound mapped attributes, not stringsNz6Expected relationship property for with_parent(), got )rò )
|
r rw r r r rè Z_of_typer r Z _with_parent)rí rì rò Zmapper_propertyZprop_tr r r Ú with_parent¬ s" 9
|
ÿ
|
ÿÿró ry )Úobject_r} c C s t | ¡}|jS )zÖReturn True if the given object has a database
|
identity.
|
|
This typically corresponds to the object being
|
in either the persistent or detached state.
|
|
.. seealso::
|
|
:func:`.was_deleted`
|
|
)r Úinstance_stateÚ has_identity©rô rº r r r rö û s
|
rö c C s t | ¡}|jS )zßReturn True if the given object was deleted
|
within a session flush.
|
|
This is regardless of whether or not the object is
|
persistent or detached.
|
|
.. seealso::
|
|
:attr:`.InstanceState.was_deleted`
|
|
)r rõ Ú was_deletedr÷ r r r rø s
|
rø r )Úgivenr r} c C s^ t |r(t | r$| ¡ | ¡ kr$dS dS t | rH| jr@|| jkS || kS t| sTt| | ¡S )z¬determine if 'given' corresponds to 'entity', in terms
|
of an entity passed to Query that would match the same entity
|
being referred to elsewhere in the query.
|
|
TF)r rI rH r r r% Z common_parent©rù r r r r Ú_entity_corresponds_to s
|
rû c C sR t | r*t |o(|j o(| |kp(|| jkS t |s>| |j¡S |joL| |jkS dS )a determine if 'given' corresponds to 'entity', in terms
|
of a path of loader options where a mapped attribute is taken to
|
be a member of a parent entity.
|
|
e.g.::
|
|
someoption(A).someoption(A.b) # -> fn(A, A) -> True
|
someoption(A).someoption(C.d) # -> fn(A, C) -> False
|
|
a1 = aliased(A)
|
someoption(a1).someoption(A.b) # -> fn(a1, A) -> False
|
someoption(a1).someoption(a1.b) # -> fn(a1, a1) -> True
|
|
wp = with_polymorphic(A, [A1, A2])
|
someoption(wp).someoption(A1.foo) # -> fn(wp, A1) -> False
|
someoption(wp).someoption(wp.A1.foo) # -> fn(wp, wp.A1) -> True
|
|
|
N)r rH r- r rô r rú r r r Ú$_entity_corresponds_to_use_path_impl3 s ÿý þrü rÉ )rù rô r} c C s: | j r || jkp| j |¡S | jr,|| jkS | |¡S dS )zedetermine if 'given' "is a" mapper, in terms of the given
|
would load rows of type 'mapper'.
|
|
N)r r rô r )rù rô r r r Ú _entity_isaX s ÿ
|
rý z
|
Query[Any]r )Úiterable_queryÚitemr} c C sÎ dd }t |tr¢t |¡\}}}t |trFt |trF|| dkrFg S t |trX|dk sjt |trp|dk rp| | ||¡}|dk rt|dd|j
S t|S n(|dkr²| nt| ||d
d S dS )zdcalculate __getitem__ in terms of an iterable query object
|
that also has a slice() method.
|
|
c S s t dd S )Nz@negative indexes are not accepted by SQL index / slice operators)Ú
|
IndexErrorr r r r Ú_no_negative_indexesm s ÿz&_getitem.<locals>._no_negative_indexesr Néÿÿÿÿr )r Úslicer5 Z decode_sliceÚintr Ústep)rþ rÿ r ÚstartÚstopr Úresr r r Ú_getitemg s.
|
ÿþ
|
ýÿÿ
|
r rg rv )Úraw_annotationrz Úoriginating_clsr} c C s8 zt || |j}W n tk
|
r( Y dS X t|tS d S r¾ )rF r
Ú NameErrorrI r )r
|
rz r Ú annotatedr r r Ú_is_mapped_annotation s ÿr c @ s e Zd ZdS )Ú _CleanupErrorN)r r
r r r r r r £ s r rw )r{ r| r} c
|
s\ t d| ¡}|s| S zt| d¡|}W n@ tk
|
rh } z"td| d| d¡ d|W 5 d }~X Y nX z t|tr~|j}n| W S W n t k
|
r | Y S X g }|}|
|
||kr¸|n| d¡¡ | d¡}t d|¡}|d kr¨|
|
|¡ qðq¨t d|d ¡sXt d |d ¡sXd
|
d fd d |d d¡D ¡|d< d |¡dt |d } | S )Nz^(.+?)\[(.+)\]$r zFor annotation "z%", could not resolve container type "z[". Please ensure this type is imported at the module level outside of TYPE_CHECKING blocksr1 z ^["'].*["']$r z.*\[.*\]z"' r c 3 s | ]}d | ¡ d V qdS )ú"N)Ústrip)r r ©Z
|
stripcharsr r rq ó s z1_cleanup_mapped_str_annotation.<locals>.<genexpr>rª ú[ú])r¯ ÚmatchrH rÍ r r Ú
|
issubclassr r Ú TypeErrorrÇ r r° Úlen) r{ r| ÚmmrÁ ÚneZ real_symbolr£ ÚinnerZg2r r r Ú _cleanup_mapped_str_annotation§ sF ÿû
|
|
|
|
|
ýú ÿ r z Optional[_AnnotationScanType]rã z1Optional[Tuple[Union[type, str], Optional[type]]])
|
r
|
rz r| r¼ Úattr_clsÚrequiredÚis_dataclass_fieldÚ expect_mappedr r} c
|
C sb | dkr2|r.t d|j d| d|j d¡dS zt|| |td} W nz tk
|
r| }
|
zt d| d¡|
|
W 5 d}
|
~
|
X Y nF tk
|
rÀ } z(|r¬d | kr¬t d| d¡| | } W 5 d} ~ X Y nX |rÎ| dfS t| d
|
rät| t s4|r,t
|
| d
|
dt j krdS |s dS t jd |j d| d d dn| dfS t | jdkrNt d¡| jd | jfS dS )z¨given an annotation, figure out if it's ``Mapped[something]`` and if
|
so, return the ``something`` part.
|
|
Includes error raise scenarios and other options.
|
|
Nz4Python typing annotation is required for attribute "Ú.z " when primary argument(s) for "z#" construct are None or not presentr z Could not interpret annotation zt. Check that it uses names that are correctly imported at the module level. See chained stack trace for more hints.zMapped[Ú
|
__origin__zType annotation for "a " can't be correctly interpreted for Annotated Declarative Table form. ORM annotations should normally make use of the ``Mapped[]`` generic type, or other ORM-compatible generic type, as a container for the actual type, which indicates the intent that the attribute is mapped. Class variables that are not intended to be mapped by the ORM should use ClassVar[]. To allow Annotated Declarative to disregard legacy annotations which don't use Mapped[] to pass, set "__allow_unmapped__ = True" on the class or a superclass this class.Zzlpr)Úcoder z)Expected sub-type for Mapped[] annotationr )r r r rF r r r r8 rI r r7 ÚtypingÚClassVarr Ú__args__r" ) r
|
rz r| r¼ r r r r r r Zcer r r r Ú_extract_mapped_subtypeü s` ÿü
|
|
ÿü
|
ÿü ÿ òÿr' )rÖ T)NN)N)N)TT)´Ú
|
__future__r r÷ Ú functoolsr¯ rÝ r$ r r r r r r r r
|
r r r r r r r r r r r? r® r r Ú_typingr r r r rW r r r r r r! r" r# r$ r% r& r' r( r) r* Z
|
interfacesr+ r, r- r. r/ Z path_registryr0 r2 r r3 r4 r5 Z engine.resultr7 r8 r9 r: r; ræ r< Z sql._typingr= Zsql.annotationr> Zsql.baser? Z sql.cache_keyr@ rA Z sql.elementsrB rC Zsql.selectablerD Zutil.langhelpersrE Z util.typingrF Z_de_stringify_annotationrG Z _de_stringify_union_elementsrH Z_eval_name_onlyrI rJ rK rL rM rN rO rP ÚcontextrQ rR rô rS rÏ rT Z relationshipsrU ZenginerV rW rX rY rZ r[ r\ r] r^ r_ r` ra rb rc rd re Z sql.visitorsrf rg rh ri Ú frozensetr³ Úpartialr× Z_de_stringify_partialrs r r rw r rÕ rì rõ ÚEnumrö Z ColumnAdapterrú r Z Inspectabler Z_self_inspectsr& r r Z _inspectsrã r¶ Z GenericAliasr¸ r¹ rÛ rÞ rß rê rà ró rö rø rû rü rý r r Ú Exceptionr r r' r r r r Ú<module> s ÿ ÿ ÿ þKC ÿ
|
S þú Z< 5
|
ÿ F
|
ù Q 2
|
û Y
|
3 ýO%'] ÷
|
