U
|
¸ý°dá ã @ s¼ U d Z ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z dd lm
|
Z
|
dd
|
lm Z dd lm Z dd lm Z dd lZddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z ddlm Z ddlm Z dd lm Z dd l m!Z! d dlmZ" d d lm#Z# d d lm$Z$ d d!l%m&Z& d d"l%m'Z' e r<dd#lm(Z( dd$lm)Z) dd%lm*Z* dd&l+m,Z, dd'l+m-Z- dd(lm.Z. dd)l/m0Z0 dd*l1m2Z2 dd+l3m4Z4 dd,lm5Z5 dd-l6m7Z7 dd.l8m9Z9 d d/l:m;Z; d d0l<m=Z> d d1l<m?Z? e rLd2e@d3< nd ZAe sZd Z>G d4d5 d5e'ZBG d6d7 d7e'e ZCe#jDG d8d9 d9ejEee ZFG d:d; d;ZGG d<d= d=ZHd S )>zDefines instrumentation of instances.
|
|
This module is usually not directly visible to user applications, but
|
defines a large part of the ORM's interactivity.
|
|
é )Ú annotations)ÚAny)ÚCallable)ÚDict)ÚGeneric)ÚIterable)ÚOptional)ÚSet)ÚTuple)Ú TYPE_CHECKING)ÚUnionNé )Úbase)Úexc)Ú
|
interfaces)Ú_O)Úis_collection_impl)Ú ATTR_WAS_SET)ÚINIT_OK)ÚLoaderCallableStatus)Ú NEVER_SET)ÚNO_VALUE)ÚPASSIVE_NO_INITIALIZE)ÚPASSIVE_NO_RESULT)Ú PASSIVE_OFF)ÚSQL_OK)Ú PathRegistryé )Ú
|
inspection)Úutil)ÚLiteral)ÚProtocol)Ú_IdentityKeyType)Ú _InstanceDict)Ú_LoaderCallable)Ú AttributeImpl)ÚHistory)Ú PassiveFlag)Ú_AdaptedCollectionProtocol)Ú IdentityMap)Ú ClassManager)Ú ORMOption)ÚMapper)ÚSession)ÚRow)Ú async_session)Ú AsyncSessionz)weakref.WeakValueDictionary[int, Session]Ú _sessionsc @ s e Zd ZddddZdS )Ú_InstanceDictProtoúOptional[IdentityMap]©Úreturnc C s d S ©N© ©Úselfr7 r7 úKd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\sqlalchemy/orm/state.pyÚ__call__Q s z_InstanceDictProto.__call__N)Ú__name__Ú
|
__module__Ú __qualname__r; r7 r7 r7 r: r2 P s r2 c @ s$ e Zd ZdZdddddddZd S )
|
Ú_InstallLoaderCallableProtoa used at result loading time to install a _LoaderCallable callable
|
upon a specific InstanceState, which will be used to populate an
|
attribute when that attribute is accessed.
|
|
Concrete examples are per-instance deferred column loaders and
|
relationship lazy loaders.
|
|
úInstanceState[_O]r# úRow[Any]ÚNone©ÚstateÚdict_Úrowr5 c C s d S r6 r7 )r9 rD rE rF r7 r7 r: r; _ s z$_InstallLoaderCallableProto.__call__N)r< r= r> Ú__doc__r; r7 r7 r7 r: r? U s r? c @ sp e Zd ZU dZdZded< dZded< dZded < dZded
|
< d Z d ed < e
|
j Z ded< dZ ded< dZded< ded< ded< dZded< dZded< dZded< dZded < dZded < d Zded < dZd ed!< dZd"ed#< d$ed%< esôd&d' Zd(ed)< d*ed+< esejZd,dd-d.d/Z ej d0d1d2d3Z e dd1d4d5Z e dd1d6d7Z!e dd1d8d9Z"e dd1d:d;Z#e dd1d<d=Z$e dd1d>d?Z%ej&e 'd@¡dd1dAdBZ(dCdDdEdFdGZ)e dHd1dIdJZ*e dKd1dLdMZ+e dNd1dOdPZ,e dQd1dRdSZ-e dd1dTdUZ.ej dVd1dWdXZ/ej dYd1dZd[Z0ej d\d1d]d^Z1ej d_d1d`daZ2e dd1dbdcZ3e4d»dddeddDdfdgdhZ5d¼dHdDdidjdkZ6dDd1dldmZ7ddDdndodpZ8e dqd1drdsZ9dtdtdDdudvdwZ:dCdxdydzd{d|Z;dCd}dEd~dZ<dCddEddZ=dd1ddZ>ddDd
ddZ?dqdCdDdddZ@ddDdddZAe4dddtddddZBdqddDdddZCd½dqdddDdddZDddxdddd ZEe d(d1d¡d¢ZFdd(d£d¤d¥ZGe d(d1d¦d§ZHe d(d1d¨d©ZIe d(d1dªd«ZJd¾dqd¬dtdddDdd®d¯ZKdqddDd°d±d²ZLd¿dqd³dDd´dµd¶ZMe4dÀd·d³dDd¸d¹dºZNdS )ÁÚ InstanceStatea tracks state information at the instance level.
|
|
The :class:`.InstanceState` is a key object used by the
|
SQLAlchemy ORM in order to track the state of an object;
|
it is created the moment an object is instantiated, typically
|
as a result of :term:`instrumentation` which SQLAlchemy applies
|
to the ``__init__()`` method of the class.
|
|
:class:`.InstanceState` is also a semi-public object,
|
available for runtime inspection as to the state of a
|
mapped instance, including information such as its current
|
status within a particular :class:`.Session` and details
|
about data on individual attributes. The public API
|
in order to acquire a :class:`.InstanceState` object
|
is to use the :func:`_sa.inspect` system::
|
|
>>> from sqlalchemy import inspect
|
>>> insp = inspect(some_mapped_object)
|
>>> insp.attrs.nickname.history
|
History(added=['new nickname'], unchanged=(), deleted=['nickname'])
|
|
.. seealso::
|
|
:ref:`orm_mapper_inspection_instancestate`
|
|
)Ú__dict__Ú __weakref__Úclass_ÚmanagerÚobjÚcommitted_stateÚexpired_attributeszClassManager[_O]rL Nz Optional[int]Ú
|
session_idz Optional[_IdentityKeyType[_O]]ÚkeyÚrunidr7 zTuple[ORMOption, ...]Ú load_optionsr Ú load_pathÚ insert_orderzOptional[object]Ú _strong_objzweakref.ref[_O]rM zDict[str, Any]rN FÚboolÚmodifiedÚexpiredÚ_deletedÚ _load_pendingÚ _orphaned_outside_of_sessionTÚ is_instanceÚobjectÚidentity_tokenzOptional[Dict[str, Any]]Ú_last_known_valuesr2 Ú_instance_dictc C s dS )z+default 'weak reference' for _instance_dictNr7 r8 r7 r7 r: ra ¨ s z InstanceState._instance_dictzSet[str]rO z:Dict[str, Callable[[InstanceState[_O], PassiveFlag], Any]]Ú callablesr )rM rL c C s0 |j | _|| _t || j¡| _i | _t | _ d S r6 )
|
Ú __class__rK rL ÚweakrefÚrefÚ_cleanuprM rN ÚsetrO )r9 rM rL r7 r7 r: Ú__init__Ã s
|
zInstanceState.__init__z'util.ReadOnlyProperties[AttributeState]r4 c s t fdd jD ¡S )aa Return a namespace representing each attribute on
|
the mapped object, including its current value
|
and history.
|
|
The returned object is an instance of :class:`.AttributeState`.
|
This object allows inspection of the current data
|
within an attribute as well as attribute history
|
since the last flush.
|
|
c s i | ]}|t |qS r7 )ÚAttributeState)Ú.0rQ r8 r7 r: Ú
|
<dictcomp>× s z'InstanceState.attrs.<locals>.<dictcomp>)r ZReadOnlyPropertiesrL r8 r7 r8 r: ÚattrsÊ s ÿzInstanceState.attrsc C s | j dko| j S )z}Return ``True`` if the object is :term:`transient`.
|
|
.. seealso::
|
|
:ref:`session_object_states`
|
|
N©rQ Ú _attachedr8 r7 r7 r: Ú transientÚ s zInstanceState.transientc C s | j dko| jS )z|Return ``True`` if the object is :term:`pending`.
|
|
|
.. seealso::
|
|
:ref:`session_object_states`
|
|
Nrm r8 r7 r7 r: Úpendingå s
|
zInstanceState.pendingc C s | j dk o| jo| jS )að Return ``True`` if the object is :term:`deleted`.
|
|
An object that is in the deleted state is guaranteed to
|
not be within the :attr:`.Session.identity_map` of its parent
|
:class:`.Session`; however if the session's transaction is rolled
|
back, the object will be restored to the persistent state and
|
the identity map.
|
|
.. note::
|
|
The :attr:`.InstanceState.deleted` attribute refers to a specific
|
state of the object that occurs between the "persistent" and
|
"detached" states; once the object is :term:`detached`, the
|
:attr:`.InstanceState.deleted` attribute **no longer returns
|
True**; in order to detect that a state was deleted, regardless
|
of whether or not the object is associated with a
|
:class:`.Session`, use the :attr:`.InstanceState.was_deleted`
|
accessor.
|
|
.. versionadded: 1.1
|
|
.. seealso::
|
|
:ref:`session_object_states`
|
|
N©rQ rn rZ r8 r7 r7 r: Údeletedñ s zInstanceState.deletedc C s | j S )aN Return True if this object is or was previously in the
|
"deleted" state and has not been reverted to persistent.
|
|
This flag returns True once the object was deleted in flush.
|
When the object is expunged from the session either explicitly
|
or via transaction commit and enters the "detached" state,
|
this flag will continue to report True.
|
|
.. seealso::
|
|
:attr:`.InstanceState.deleted` - refers to the "deleted" state
|
|
:func:`.orm.util.was_deleted` - standalone function
|
|
:ref:`session_object_states`
|
|
)rZ r8 r7 r7 r: Ú was_deleted s zInstanceState.was_deletedc C s | j dk o| jo| j S )a Return ``True`` if the object is :term:`persistent`.
|
|
An object that is in the persistent state is guaranteed to
|
be within the :attr:`.Session.identity_map` of its parent
|
:class:`.Session`.
|
|
.. seealso::
|
|
:ref:`session_object_states`
|
|
Nrq r8 r7 r7 r: Ú
|
persistent$ s zInstanceState.persistentc C s | j dk o| j S )z|Return ``True`` if the object is :term:`detached`.
|
|
.. seealso::
|
|
:ref:`session_object_states`
|
|
Nrm r8 r7 r7 r: Údetached3 s zInstanceState.detachedzsqlalchemy.orm.sessionc C s | j d k o| j tjjjkS r6 )rP r Z preloadedZ orm_sessionr1 r8 r7 r7 r: rn > s
|
þzInstanceState._attachedÚstrrB )rQ r5 c C s, | j }|dkri | _ }||kr(t||< dS )z|Track the last known value of a particular key after expiration
|
operations.
|
|
.. versionadded:: 1.3
|
|
N)r` r )r9 rQ Úlkvr7 r7 r: Ú_track_last_known_valueF s
|
|
z%InstanceState._track_last_known_valuezOptional[Session]c C s, | j r(z t| j W S tk
|
r& Y nX dS )aL Return the owning :class:`.Session` for this instance,
|
or ``None`` if none available.
|
|
Note that the result here can in some cases be *different*
|
from that of ``obj in session``; an object that's been deleted
|
will report as not ``in session``, however if the transaction is
|
still in progress, this attribute will still refer to that session.
|
Only when the transaction is completed does the object become
|
fully detached under normal circumstances.
|
|
.. seealso::
|
|
:attr:`_orm.InstanceState.async_session`
|
|
N)rP r1 ÚKeyErrorr8 r7 r7 r: ÚsessionT s zInstanceState.sessionzOptional[AsyncSession]c C s* t dkr dS | j}|dk r"t |S dS dS )aG Return the owning :class:`_asyncio.AsyncSession` for this instance,
|
or ``None`` if none available.
|
|
This attribute is only non-None when the :mod:`sqlalchemy.ext.asyncio`
|
API is in use for this ORM object. The returned
|
:class:`_asyncio.AsyncSession` object will be a proxy for the
|
:class:`_orm.Session` object that would be returned from the
|
:attr:`_orm.InstanceState.session` attribute for this
|
:class:`_orm.InstanceState`.
|
|
.. versionadded:: 1.4.18
|
|
.. seealso::
|
|
:ref:`asyncio_toplevel`
|
|
N)Ú_async_providerrz )r9 Úsessr7 r7 r: r/ l s zInstanceState.async_sessionz Optional[_O]c C s | ¡ S )zReturn the mapped object represented by this
|
:class:`.InstanceState`.
|
|
Returns None if the object has been garbage collected
|
|
)rM r8 r7 r7 r: r^ s zInstanceState.objectzOptional[Tuple[Any, ...]]c C s | j dkrdS | j d S dS )aì Return the mapped identity of the mapped object.
|
This is the primary key identity as persisted by the ORM
|
which can always be passed directly to
|
:meth:`_query.Query.get`.
|
|
Returns ``None`` if the object has no primary key identity.
|
|
.. note::
|
An object which is :term:`transient` or :term:`pending`
|
does **not** have a mapped identity until it is flushed,
|
even if its attributes include primary key values.
|
|
Nr ©rQ r8 r7 r7 r: Úidentity s
|
zInstanceState.identityc C s | j S )zõReturn the identity key for the mapped object.
|
|
This is the key used to locate the object within
|
the :attr:`.Session.identity_map` mapping. It contains
|
the identity as returned by :attr:`.identity` within it.
|
|
|
r} r8 r7 r7 r: Ú identity_key¦ s
|
zInstanceState.identity_keyz4Dict[int, Union[Literal[False], InstanceState[Any]]]c C s i S r6 r7 r8 r7 r7 r: Úparents² s zInstanceState.parentsz Dict[str, PendingCollection]c C s i S r6 r7 r8 r7 r7 r: Ú_pending_mutations¶ s z InstanceState._pending_mutationsz%Dict[str, _AdaptedCollectionProtocol]c C s i S r6 r7 r8 r7 r7 r: Ú_empty_collectionsº s z InstanceState._empty_collectionsz
|
Mapper[_O]c C s | j jS )z<Return the :class:`_orm.Mapper` used for this mapped object.)rL Úmapperr8 r7 r7 r: r ¾ s zInstanceState.mapperc C s
|
t | jS )z³Return ``True`` if this object has an identity key.
|
|
This should always have the same value as the
|
expression ``state.persistent`` or ``state.detached``.
|
|
)rW rQ r8 r7 r7 r: Ú has_identityà s zInstanceState.has_identityzIterable[InstanceState[_O]]r- )Ústatesrz Ú to_transientr5 c C sÒ |j jp
|
d }|j jpd }|j jp"d }|j jp.d }|D ]}|j} |jd k}
|
|
|
oR| } d |_|rh|jrh|`| r|r|d k r||| qÆ|d k rÆ||| n.| r°|d k r°||| n|
|
rÆ|d k rÆ||| d |_q4d S r6 ) ÚdispatchÚpersistent_to_detachedÚdeleted_to_detachedÚpending_to_transientÚpersistent_to_transientrZ rQ rP rV ) r9 r
rz r r r r r rD rr rp rt r7 r7 r: Ú_detach_statesÍ s0
|
ÿ
|
ÿ
|
|
|
z InstanceState._detach_states)rz r5 c C s$ |rt | g|¡ n d | _| _d S r6 )rH r rP rV )r9 rz r7 r7 r: Ú_detachó s zInstanceState._detachc C s | ¡ d S r6 )r r8 r7 r7 r: Ú_disposeù s zInstanceState._dispose)re r5 c C s: t dkr dS | ¡ }|dk r*| | ¡ | `d | _| _dS )zäWeakref callback cleanup.
|
|
This callable cleans out the state when it is being garbage
|
collected.
|
|
this _cleanup **assumes** that there are no strong refs to us!
|
Will not work otherwise!
|
|
N)Údictra Z _fast_discardrP rV )r9 re Ú instance_dictr7 r7 r: rf ý s
|
zInstanceState._cleanupr# c C s" | ¡ }|dk rt |¡S i S dS )a Return the instance dict used by the object.
|
|
Under normal circumstances, this is always synonymous
|
with the ``__dict__`` attribute of the mapped object,
|
unless an alternative instrumentation system has been
|
configured.
|
|
In the case that the actual object has been garbage
|
collected, this accessor returns a blank dictionary.
|
|
N)rM r r )r9 Úor7 r7 r: r s
|
zInstanceState.dictr )ÚmixedÚkwargsr5 c O s | d | d | dd
}}}|j }|j |||¡ z|j| dd
| W n0 t ¡ |j |||¡ W 5 Q R X Y nX d S )Nr r r )rL r ÚinitZ original_initr Z safe_reraiseZ init_failure)r r r9 ÚinstanceÚargsrL r7 r7 r: Ú_initialize_instance- s
|
z"InstanceState._initialize_instancer' r& )rQ Úpassiver5 c C s | j | j | | j|¡S r6 )rL ÚimplÚ get_historyr )r9 rQ r r7 r7 r: r 9 s zInstanceState.get_historyr% c C s | j | jS r6 )rL r ©r9 rQ r7 r7 r: Úget_impl< s zInstanceState.get_implÚPendingCollectionc C s || j krt | j |< | j | S r6 )r r r r7 r7 r: Ú_get_pending_mutation? s
|
z#InstanceState._get_pending_mutationc sZ ¡ j j jd}| fdddD ¡ jrD j ¡ |d< j |¡|d< |S )N)r rK rN rO c 3 s& | ] }| j kr| j | fV qd S r6 )rI ©rj Úkr8 r7 r: Ú <genexpr>K s
|
óz-InstanceState.__getstate__.<locals>.<genexpr>)
|
r rX rY rb rQ r rS rK rO ÚinforT rL ) rM rK rN rO ÚupdaterT Ú serializerL Ú
|
_serialize)r9 Ú
|
state_dictr7 r8 r: Ú __getstate__D s üþzInstanceState.__getstate__)r¦ r5 c s2 d }|d k r*t || j¡| _|j| _ndd | _ d | _ di ¡| _ di ¡| _ di ¡| _ dd ¡| _
|
d
|
d ¡| _ d kr| j d ¡ d krº d | _ d | _n d krÎ d | _nt | _| j fdddD ¡ | jr| jd | _d kr t d ¡| _ d | | d S )Nr c S s d S r6 r7 r7 r7 r7 r: Ú<lambda>h ó z,InstanceState.__setstate__.<locals>.<lambda>rK rN r r rX FrY r¢ rb rO c s g | ]}| kr| | fqS r7 r7 r ©r¦ r7 r: Ú
|
<listcomp>} s þz.InstanceState.__setstate__.<locals>.<listcomp>)rQ rS r rT rL )rd re rf rM rc rK ÚgetrN r r rX rY r¢ r£ rb rO rg rI rQ r_ r Z deserializerT )r9 r¦ Úinstr7 rª r: Ú __setstate__b s:
|
|
|
|
|
þÿ
|
zInstanceState.__setstate__)rE rQ r5 c C sV | |d¡}| j| j}|dk r2t|r2| |¡ | j |¡ | jrR| j |d¡ dS )zHRemove the given attribute and any
|
callables associated with it.N)ÚpoprL r r Ú_invalidate_collectionrO Údiscardrb )r9 rE rQ ÚoldZ manager_implr7 r7 r: Ú_reset s
|
zInstanceState._resetúInstanceState[Any])Úfrom_r5 c C s d|j krt|j| _d S ©Nrb )rI r rb )r9 rµ r7 r7 r: Ú_copy_callables s
|
z InstanceState._copy_callablesr$ z _InstallLoaderCallableProto[_O])rL ÚfnrQ r5 c sR | j }t|r4| ddddd fdd }ndddddfdd }|S ) Nr@ r# rA rB rC c s< d| j kri | _| d ¡}|d k r. |¡ | j< d S r¶ )rI rb r¯ r° )rD rE rF r² ©Z
|
fixed_implr¸ rQ r7 r: Ú _set_callable£ s
|
|
zGInstanceState._instance_level_callable_processor.<locals>._set_callablec s d| j kri | _ | j< d S r¶ )rI rb )rD rE rF )r¸ rQ r7 r: rº ¯ s
|
)r r )ÚclsrL r¸ rQ r rº r7 r¹ r: Ú"_instance_level_callable_processor s
|
z0InstanceState._instance_level_callable_processorzSet[InstanceState[Any]])rE Ú modified_setr5 c s d| _ | jr&| | ¡ | j ¡ d| _d | _d| jkr>| jd= d| jkrP| jd= | j dd | j j
|
D ¡ | j r| j | j ¡D ] }| j |= q~| j j ¡D ]} |¡}d|j_q| jrÔ| j fdd| jD ¡ | j j ¡D ]
|
} |= qâ| j j | d ¡ d S ) NTFr r c S s g | ]
|
}|j qS r7 r} )rj r r7 r7 r: r« Ê s z)InstanceState._expire.<locals>.<listcomp>c s i | ]}| kr| | qS r7 r7 r ©rE r7 r: rk â s z)InstanceState._expire.<locals>.<dictcomp>)rY rX r± rN ÚclearrV rI rO r£ rL Z _loader_implsrb Ú intersectionZ_collection_impl_keysr¯ Z _sa_adapterZ invalidatedr` Z _all_key_setr Úexpire)r9 rE r½ r Ú
|
collectionrQ r7 r¾ r: Ú_expire¸ s4
|
|
|
|
ÿ
|
|
|
ÿzInstanceState._expirez Iterable[str])rE Úattribute_namesÚ no_loaderr5 c
|
C sà | j dd ¡}| j}|D ]²}| j| j}|jr`|rB|js||krBq| j |¡ |r`||kr`||= | |t
|
¡}t |r|t
|
k r| |¡ | j } | d k r¬|| kr¬|t
|
k r¬|| |< | j |d ¡ |r| |d ¡ q| jj | |¡ d S )Nr )rI r¬ rb rL r Úaccepts_scalar_loaderZ callable_rO Úaddr¯ r r r° r` rN r rÁ )
|
r9 rE rÄ rÅ rp rb rQ r r² rw r7 r7 r: Ú_expire_attributesê s(
|
z InstanceState._expire_attributesr@ r )rD r r5 c sP |t @ s tS j j¡}| fdd|D ¡} j ||¡ j ¡ t S )z¡__call__ allows the InstanceState to act as a deferred
|
callable for loading expired attributes, which is also
|
serializable (picklable).
|
|
c 3 s | ]} j | jjs|V qd S r6 )rL r Zload_on_unexpire©rj Úattrr8 r7 r: r¡ s þz.InstanceState._load_expired.<locals>.<genexpr>)
|
r r rO rÀ Ú
|
unmodifiedÚ
|
differencerL Zexpired_attribute_loaderr¿ r )r9 rD r Ztoloadr7 r8 r: Ú _load_expired s þ
|
zInstanceState._load_expiredc C s t | j | j¡S )z8Return the set of keys which have no uncommitted changes)rg rL rÌ rN r8 r7 r7 r: rË ( s zInstanceState.unmodified)Úkeysr5 c C s t | | j¡ | j¡S )z*Return self.unmodified.intersection(keys).)rg rÀ rL rÌ rN )r9 rÎ r7 r7 r: Úunmodified_intersection. s ÿþÿz%InstanceState.unmodified_intersectionc C s t | j | j¡ | j¡S ©z²Return the set of keys which do not have a loaded value.
|
|
This includes expired attributes and any other attribute that
|
was never populated or modified.
|
|
)rg rL rÌ rN r r8 r7 r7 r: Úunloaded7 s
|
ÿþÿzInstanceState.unloadedc C s | j S rÐ )rÑ r8 r7 r7 r: Úunloaded_expirableE s z InstanceState.unloaded_expirablec s j fdd jD ¡S )Nc 3 s | ]} j | jjr|V qd S r6 )rL r rÆ rÉ r8 r7 r: r¡ Q s þz5InstanceState._unloaded_non_object.<locals>.<genexpr>)rÑ rÀ rL r8 r7 r8 r: Ú_unloaded_non_objectO s þz"InstanceState._unloaded_non_objectzOptional[AttributeImpl])rE rÊ ÚpreviousrÂ Ú is_userlandr5 c C s |r²|j sd S |r,|j|kr,t d|j ¡|j| jks<|r|rtrPt|sPt|tkrl|j|krl||j }|d t tfkr|
|
|¡}|| j|j< | j }|d k r²|j|kr²t ||j< | j rÂ| j d ksÊ| js~d| _| ¡ }|rôt|j}|j | ¡ nd}| ¡ } | j rN| | _ |sNzt| j }
|
W n tk
|
r8 Y nX |
|
jd krN|
|
¡ | d kr~|r~t d| j|j t | ¡f ¡d S )NzHCan't flag attribute '%s' modified; it's not present in the object stateTFzaCan't emit change event for attribute '%s' - parent object of type %s has been garbage collected.) Zsend_modified_eventsrQ Úsa_excZInvalidRequestErrorrN r r ÚAssertionErrorr r Úcopyr` rP rV rX ra rW Ú _modifiedrÇ rM r1 ry Z _transactionZ _autobegin_tÚorm_excZObjectDereferencedErrorrL r Zstate_class_str) r9 rE rÊ rÔ r rÕ rw r Z has_modifiedr rz r7 r7 r: Ú_modified_eventW sZ ÿÿ
|
|
|
|
|
ýÿz InstanceState._modified_event)rE rÎ r5 c C sb |D ]}| j |d¡ qd| _| j t| |¡¡ | jr^t| j |¡ |¡D ] }| j|= qPdS )a8 Commit attributes.
|
|
This is used by a partial-attribute load operation to mark committed
|
those attributes which were refreshed from the database.
|
|
Attributes marked as "expired" can potentially remain "expired" after
|
this step if a value was not populated in state.dict.
|
|
NF)rN r¯ rY rO Údifference_updaterg rÀ rb )r9 rE rÎ rQ r7 r7 r: Ú_commit s
|
ÿÿzInstanceState._commitr3 )rE r r5 c C s | | |fg|¡ dS )aS commit all attributes unconditionally.
|
|
This is used after a flush() or a full load/refresh
|
to remove all pending state from the instance.
|
|
- all attributes are marked as "committed"
|
- the "strong dirty reference" is removed
|
- the "modified" flag is set to False
|
- any "expired" markers for scalar attributes loaded are removed.
|
- lazy load callables for objects / collections *stay*
|
|
Attributes marked as "expired" can potentially remain
|
"expired" after this step if a value was not populated in state.dict.
|
|
N)Ú_commit_all_states)r9 rE r r7 r7 r: Ú _commit_all¼ s zInstanceState._commit_allz2Iterable[Tuple[InstanceState[Any], _InstanceDict]])Úiter_r r5 c C sd |D ]Z\}}|j }|j ¡ d|kr*|d= |j |¡ |rL|jrL|j |¡ d |_|_d|_ qdS )z.Mass / highly inlined version of commit_all().r FN)
|
rI rN r¿ rO rÜ rX rÙ r± rY rV )r9 rà r rD rE r¦ r7 r7 r: rÞ Ð s
|
|
z InstanceState._commit_all_states)F)N)F)FF)N)N)Or< r= r> rG Ú __slots__Ú__annotations__rP rQ rR rS r ÚrootrT rU rV rX rY rZ r[ r\ r] r_ r` r ra r Ú
|
EMPTY_DICTrb rh Zmemoized_propertyrl Úpropertyro rp rr rs rt ru Znon_memoized_propertyZpreload_modulern rx rz r/ r^ r~ r r r r r r Ú classmethodr r r rf r r r r r r§ r® r³ r· r¼ rà rÈ rÍ rË rÏ rÑ rÒ rÓ rÛ rÝ rß rÞ r7 r7 r7 r: rH e sÔ
|
|
|
|
ü% ) 6 ü! úH ÿ ýrH c @ sz e Zd ZU dZdZded< ded< dddddZed d
|
d d Zed d
|
d dZ edd
|
ddZ
|
dd
|
ddZ dS )ri a Provide an inspection interface corresponding
|
to a particular attribute on a particular mapped object.
|
|
The :class:`.AttributeState` object is accessed
|
via the :attr:`.InstanceState.attrs` collection
|
of a particular :class:`.InstanceState`::
|
|
from sqlalchemy import inspect
|
|
insp = inspect(some_mapped_object)
|
attr_state = insp.attrs.some_attribute
|
|
©rD rQ r´ rD rv rQ c C s || _ || _d S r6 rç )r9 rD rQ r7 r7 r: rh ý s zAttributeState.__init__r r4 c C s | j j | jt¡S )zÇThe current value of this attribute as loaded from the database.
|
|
If the value has not been loaded, or is otherwise not present
|
in the object's dictionary, returns NO_VALUE.
|
|
)rD r r¬ rQ r r8 r7 r7 r: Ú loaded_value s zAttributeState.loaded_valuec C s | j j| j | j ¡ | j j¡S )zàReturn the value of this attribute.
|
|
This operation is equivalent to accessing the object's
|
attribute directly or via ``getattr()``, and will fire
|
off any pending loader callables if needed.
|
|
)rD rL rQ Ú__get__rM rK r8 r7 r7 r: Úvalue s ÿzAttributeState.valuer& c C s | j | jt¡S )ai Return the current **pre-flush** change history for
|
this attribute, via the :class:`.History` interface.
|
|
This method will **not** emit loader callables if the value of the
|
attribute is unloaded.
|
|
.. note::
|
|
The attribute history system tracks changes on a **per flush
|
basis**. Each time the :class:`.Session` is flushed, the history
|
of each attribute is reset to empty. The :class:`.Session` by
|
default autoflushes each time a :class:`_query.Query` is invoked.
|
For
|
options on how to control this, see :ref:`session_flushing`.
|
|
|
.. seealso::
|
|
:meth:`.AttributeState.load_history` - retrieve history
|
using loader callables if the value is not locally present.
|
|
:func:`.attributes.get_history` - underlying function
|
|
)rD r rQ r r8 r7 r7 r: Úhistory s zAttributeState.historyc C s | j | jttA ¡S )a Return the current **pre-flush** change history for
|
this attribute, via the :class:`.History` interface.
|
|
This method **will** emit loader callables if the value of the
|
attribute is unloaded.
|
|
.. note::
|
|
The attribute history system tracks changes on a **per flush
|
basis**. Each time the :class:`.Session` is flushed, the history
|
of each attribute is reset to empty. The :class:`.Session` by
|
default autoflushes each time a :class:`_query.Query` is invoked.
|
For
|
options on how to control this, see :ref:`session_flushing`.
|
|
.. seealso::
|
|
:attr:`.AttributeState.history`
|
|
:func:`.attributes.get_history` - underlying function
|
|
)rD r rQ r r r8 r7 r7 r: Ú load_history4 s zAttributeState.load_historyN) r< r= r> rG rá râ rh rå rè rê rë rì r7 r7 r7 r: ri é s
|
ri c @ sT e Zd ZU dZdZded< ded< ddd d
|
Zd dd d dZd dd ddZdS )r a A writable placeholder for an unloaded collection.
|
|
Stores items appended to and removed from a collection that has not yet
|
been loaded. When the collection is loaded, the changes stored in
|
PendingCollection are applied to it to produce the final result.
|
|
)Ú deleted_itemsÚ added_itemszutil.IdentitySetrí zutil.OrderedIdentitySetrî rB r4 c C s t ¡ | _t ¡ | _d S r6 )r Z IdentitySetrí ZOrderedIdentitySetrî r8 r7 r7 r: rh \ s
|
zPendingCollection.__init__r )rê r5 c C s( || j kr| j |¡ n | j |¡ d S r6 )rí Úremoverî rÇ ©r9 rê r7 r7 r: Úappend` s
|
zPendingCollection.appendc C s( || j kr| j |¡ n | j |¡ d S r6 )rî rï rí rÇ rð r7 r7 r: rï f s
|
zPendingCollection.removeN) r< r= r> rG rá râ rh rñ rï r7 r7 r7 r: r N s
|
r )IrG Ú
|
__future__r Útypingr r r r r r r r
|
r r rd Ú r r rÚ r Ú_typingr r r r r r r r r r r Z path_registryr rÖ r r Z util.typingr r! r" r# r$ Ú
|
attributesr% r& r' Ú collectionsr( r~ r) Zinstrumentationr* r+ r r, rz r- Zenginer. Zext.asyncio.sessionr/ r{ r0 râ r1 r2 r? Z_self_inspectsZInspectionAttrInforH ri r r7 r7 r7 r: Ú<module> s
|
|
e
|
