d-Z-d. Z.d/ Z/ G d0 d1e j0 Z1 d?d2Z2d@d3Z3d>d4Z4d5 Z5d6 Z6d7 Z7d8 Z8d9 Z9d: Z:dS )A N )
attributes)_class_to_mapper)
_never_set) _none_set)
attribute_str) class_mapper)InspectionAttr) instance_str)
object_mapper) object_state)state_attribute_str)state_class_str) state_str)MapperProperty)PropComparator) PathRegistry )event)exc)
inspection)sql)util)
expression)delete
delete-orphanallmergeexpunge save-updaterefresh-expirenonec r e Zd ZdZe g d ZeZg dZdZ d Z
d Z e d Z
dS ) CascadeOptionszHKeeps track of the options sent to
:paramref:`.relationship.cascade`)r r" r )r r r" r! ) save_updater refresh_expirer r
delete_orphanc t |t j s|| | S t | }| | j rYt j dd d t | | j D z d|v r| | j d|v r|
| d t t" | }d|v |_ d|v |_ d|v |_ d |v |_ d
|v |_ d |v |_ |j r|j st j d |S )
Nz Invalid cascade option(s): %s, c , g | ]}t | S )repr.0xs J/opt/cloudlinux/venv/lib64/python3.11/site-packages/sqlalchemy/orm/util.py
z*CascadeOptions.__new__..P s. Q r r" r r r! r r r z5The 'delete-orphan' cascade option requires 'delete'.)
isinstancer string_types from_stringset
difference_allowed_cascadessa_exc
ArgumentErrorjoinsortedupdate_add_w_all_cascadescleardiscard frozenset__new__r$ r% r r& r r r' warn)cls
value_listvaluesselfs r0 rB zCascadeOptions.__new__H s j$"3 4 4 /
8J??:.. .Z S 2 3 3 &/)) !' " - -c.C D D" "
F?? MM#1 2 2 2 V LLNNNu 88(F2 &( .& 8 &
F* , 6 dk IJ
r2 c ` dd d t | D z S )NzCascadeOptions(%r),c g | ]}|S r+ r+ r- s r0 r1 z+CascadeOptions.__repr__..n s 0I0I0Iq0I0I0Ir2 )r; r< rG s r0 __repr__zCascadeOptions.__repr__m s. #sxx0I0IF4LL0I0I0I'J'JKKr2 c Z d t j d|pd D } | | S )Nc g | ]}||S r+ r+ )r. cs r0 r1 z.CascadeOptions.from_string..r s BBBB!BBBr2 z\s*,\s* )resplit)rD argrF s r0 r5 zCascadeOptions.from_stringp s3 BBRXj#) < <BBBs6{{r2 N)__name__
__module__ __qualname____doc__ all_cascadesr7 r> r8 _viewonly_cascades __slots__rB rL classmethodr5 r+ r2 r0 r$ r$ 4 s ) ) '11((( %EEEI# # #JL L L [ r2 r$ c ` sfd |r! fd} fd} fd} fd}n fd} fd} fd}t j | d |d
d
t j | d |d
t j | d|d
d
|rt j | d|d
d
dS dS )zNRuns a validation method on an attribute value to be set or
appended.
c : | j j }|j |uS N)managerimpl)state initiatorr` keys r0 detect_is_backrefz,_validator_events..detect_is_backref} s =%*D >- -r2 c |j t j ur.s | | s | |d S |S NFopr OP_BULK_REPLACEobjra valuerb rd include_backrefsrc validators r0 appendz!_validator_events..append sU |:#=== >(9(9%(K(K > !yc5%@@@ r2 c | s | | s+| fd|D |d d < d S d S )Nc , g | ]} |d S )Fr+ r. rl rc rj rn s r0 r1 z7_validator_events..bulk_set.. s6 :?IIc3u55 r2 rj ra rF rb rj rd rm rc rn s @r0 bulk_setz#_validator_events..bulk_set sv
'8'8 'J'J
iikk CI qqq
r2 c d s | | s | |d S |S rf rs ra rl oldvaluerb rd rm rc rn s r0 set_z _validator_events..set_ sC
'8'8 'J'J
yc5%@@@ r2 c h s | | s" | |d d S d S )NTrs rk s r0 removez!_validator_events..remove sN
9'8'8 'J'J
9 %))++sE488888
9
9r2 c |j t j ur-s | | s | | S |S r^ rg rk s r0 ro z!_validator_events..append sS |:#=== >(9(9%(K(K > !yc5999 r2 c | s | | s+| fd|D |d d < d S d S )Nc * g | ]} | S r+ r+ rr s r0 r1 z7_validator_events..bulk_set.. s' L L LEYYsC 7 7 L L Lr2 rs rt s @r0 ru z#_validator_events..bulk_set sg
M'8'8 'J'J
Miikk L L L L L LV L L Lqqq
M
Mr2 c b s | | s | | S |S r^ rs rw s r0 ry z _validator_events..set_ sA
'8'8 'J'J
yc5999 r2 ro T)rawretval bulk_replace)r r6 r{ N)r listen)
descrc rn include_removesrm ro ru ry r{ rd s
`` ` @r0 _validator_eventsr v s
. . . . . . . 9 9 9 9 9 9 9 9 9 M M M M M M M M
LxT$???? L~xT:::: LudT:::: D
T8VdCCCCCCD Dr2 p_unionTc "
t j }i i
| D ]}| | t t j r | |< i } j D ]5}| |j |||j < |j
|j < 6| <
fd
g }|
D ]\ } |s| t j
fd|D t j
t j | | gz g z| t j
fd|D g t j | | 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.
c F | | S # t $ r rAt j t j | | cY S t j t j | | cY S w xY wr^ )KeyErrorr castnulllabel type_coerce)nametable
cast_nulls colnamemapstypess r0 colz polymorphic_union..col s L u%d+ + L L L
Lx
E$K88>>tDDDDDsxzz5;??EEdKKKKK Ls
A B ?B B Nc ( g | ]} | S r+ r+ r. r r r s r0 r1 z%polymorphic_union.. % ;;;$SSu%%;;;r2 )from_objc ( g | ]} | S r+ r+ r s r0 r1 z%polymorphic_union.. r r2 )r
OrderedSetr3 r SelectaliasrO addrc typeitemsro selectliteral_columnsql_util_quote_ddl_exprr union_all) table_map typecolname aliasnamer colnamesrc mrO resulttype_r r r r s ` @@@@r0 polymorphic_unionr s , HK E # eSZ ( ( #KKMME "IcN " "A LL AaeH 6E!%LL EL L L L L L L F!)) u " MM
;;;;;(;;;* $ 4U ; ; % ,, $W
MM
;;;;;(;;;ug
=& ! ' ' 2 22r2 c | rd}t | }|dk rD| d } | d }nF# t $ r | d }Y n%w xY w|dv r| \ }}nt j d|z | dd }|r*t j d d
| z t
| }|)| t j | | S |
|| S | d }|r/t j d d
|j z t | }|
| S )
a) 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))
(, (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)
(, (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:`.RowProxy` object.
E.g.::
>>> row = engine.execute("select * from table where a=1 and b=2").\
first()
>>> identity_key(MyClass, row=row)
(, (1, 2), None)
:param class: mapped class (must be a positional argument)
:param row: :class:`.RowProxy` row returned by a
:class:`_engine.ResultProxy`
(must be given as a keyword arg)
:param identity_token: optional identity token
.. versionadded:: 1.2 added identity_token
Nr r rowident)r z1expected up to three positional arguments, got %sidentity_tokenz unknown keyword arguments: %sr) )r instance)lenpopr r9 r: r; r identity_key_from_primary_keyr to_listidentity_key_from_rowkeysr identity_key_from_instance) argskwargsr largsclass_r r mapperr s r0 identity_keyr s @ %;D A::!WF
, jj''
,
,
,
7++
,
f__ MFEE&FN
$4d;; &/$))F2C2CC
f%% ;77 U##N 8
//N 0
::j)) &/$))FK2H2HH
x((00:::s : A A c ( e Zd ZdZ ddZd ZdS )
ORMAdapterzaColumnAdapter subclass which excludes adaptation of entities from
non-matching mappers.
NFTc t j | }|j | _ |j }|j }|r|| _ nd | _ t j | |||||| j d S )N)adapt_requiredallow_label_resolveanonymize_labels
include_fn)
r inspectr
selectableis_aliased_class
aliased_classr
ColumnAdapter__init__ _include_fn) rG entity equivalentsr r r infor r s r0 r zORMAdapter.__init__o s !&))k _
0 &!'D !%D '' ) 3 -' (
r2 c r |j dd }| p| | j S )N parentmapper) _annotationsgetisar )rG elemr s r0 r zORMAdapter._include_fn s5 "&&~t<<z4VZZ 4 44r2 )NFTF)rT rU rV rW r r r+ r2 r0 r r i sO
85 5 5 5 5r2 r c > e Zd ZdZ d dZd Zd Zd ZdS )
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`
NFr+ c t | } | | j || }t | | |||r|n| j ||n| j || ||
| _ d| j j z | _ d S )N)r flatzAliasedClass_%s) r _with_polymorphic_selectabler AliasedInspwith_polymorphic_mapperspolymorphic_on
_aliased_inspr rT ) rG rD r r r adapt_on_namesr with_polymorphic_discriminator
base_aliasuse_mapper_pathrepresents_outer_joinr s r0 r zAliasedClass.__init__ s "#&& =7== > E ) '
1 $ $0-9
+ *& !
" *FM,BB
r2 c | j d }|j }t || }n # t $ r t w xY wt |d r*t |d rt
j |j | S t |d r| d | }t |d r&|
| }t | || |S )Nr __call____self____get__adapt_to_entity) __dict___targetgetattrr AttributeErrorhasattrr
MethodType__func__r r setattr)rG rc r targetattrs r0 __getattr__zAliasedClass.__getattr__ s ( M/ :M #*F63''DD # # # "" " # 4 $ $ 9z)B)B 9#DM488 8 4 # # ,<<d++D 4* + + %''
66D D#t $ $ $ s
' A c H dt | | j j j fz S )Nz)idr r rT rK s r0 rL zAliasedClass.__repr__ s) + tHH & //
r2 c * t | j S r^ )strr rK s r0 __str__zAliasedClass.__str__ s 4%&&&r2 ) NNFFr+ NNFF)rT rU rV rW r r rL r r+ r2 r0 r r s 8 8z
!#'+ #%C %C %C %CN :
' ' ' ' 'r2 r c e Zd ZdZd Zed ZdZ ed Zed Z d Z
d Z d Z d
Z
ej d Zej d Zd
Zd Zd ZdS )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`
c b t j | | _ || _ |x| _ x| _ | _ || _ || _ t j |p| | _ || _
|
| _ |r|d| _ || _
g | _ | j
D ]^} | |urXt | j || | | } t# | j | j j | | j | j _nd| _ |g| _
t- j ||j | d | _ | | _ |j | _ d S )NT)r r r F)r r r ) weakrefref _weak_entityr r persist_selectable local_tabler r _base_alias_use_mapper_pathr _is_with_polymorphicr _with_polymorphic_entitiesr r r r rT ro r r r _equivalent_columns_adapter_adapt_on_namesr )
rG r r r r r r r r r r polyents
r0 r zAliasedInsp.__init__@ se $K / / * * * # ,";{':d;; 0 %:" # 5(,D %,DD ).0D + 5
N
Nv%%& "#''5(8 C DK)=sCCC3::3;LMMM
N ).D %-3HD ) . 2) !
. } r2 c * | S r^ )r rK s r0 r zAliasedInsp.entityw s """r2 Tc | j j S )zUReturn the mapped class ultimately represented by this
:class:`.AliasedInsp`.)r r rK s r0 r zAliasedInsp.class_~ s {!!r2 c P | j r | j j S t j | S r^ )r r _path_registryr
per_mapperrK s r0 r
zAliasedInsp._path_registry s) 1;- - *400 0r2 c | 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 r r r r r rK s r0 __getstate__zAliasedInsp.__getstate__ sR kk_I " 2(,(E.2.A **,, # 4%)%?
r2 c
| |d |d |d |d |d |d |d |d |d |d
d S ) Nr r r r r r r r r r )r )rG ra s r0 __setstate__zAliasedInsp.__setstate__ ss
(O (O 'N &M , - 2 3 , # $ " # ) *
r2 c l | j | | | j d S )N) parententityr )r traverse _annotater )rG r s r0 _adapt_elementzAliasedInsp._adapt_element s7 }%%d++55 !4; ? ?
r2 c | j }||v r/|| j u r| S t | j |j j j S | | j r| S J d|d| )NFzmapper z doesn't correspond to )r r r r r rT r r )rG r self_polys r0 _entity_for_mapperz AliasedInsp._entity_for_mapper s 1 Y $$ K !7 ZZ
$
$ PK O O&&&$$O O O5r2 c j j \ }} j | fd| D fS )Nc L i | ] \ }}j | |!S r+ )r r )r. r paramrG s r0
z+AliasedInsp._get_clause.. s?
C
&&s++U
r2 )r _get_clauser r r )rG onclause
replacemaps ` r0 r zAliasedInsp._get_clause sa #{ 6 * M " "8 , ,
","2"2"4"4
r2 c i S r^ r+ rK s r0 _memoized_valuesz AliasedInsp._memoized_values s r2 c V || j v r
| j | S ||i |x| j |< }|S r^ )r# )rG rc callable_r kwrl s r0 _memozAliasedInsp._memo sD $' ' '(- -1:D1GB1G1G GD !# &Lr2 c | j r(dd d | j D z }nd}dt | | j j |fz S )Nz(%s)r) c 3 . K | ]}|j j V d S r^ )r rT r. mps r0 z'AliasedInsp.__repr__.. s8 + +') "+ + + + + +r2 rP z)r r; r r rT )rG with_polys r0 rL zAliasedInsp.__repr__ su ( + +-1-J+ + + " " II I, tHH K 0
r2 c j r7d j j dd fd j D dS d j j dS )Nzwith_polymorphic(z, [r) c 3 B K | ]}|j u |j j V d S r^ )r r rT )r. r+ rG s r0 r, z&AliasedInsp.__str__.. sA ,, I&,,,, r2 z])zaliased())r r rT r; r rK s `r0 r zAliasedInsp.__str__ s $
<
< %%% " ;
< %)L$9$9$9; ;r2 N)rT rU rV rW r propertyr r r r
r r r r r memoized_propertyr r# r' rL r r+ r2 r0 r r s3 $ $L5% 5% 5%n # # X#
" " X"
1 1 X1
P P P
< < < < r5 s &2F r2 c | S r^ r+ r4 s r0 r5 r5 s r2 Fc t | t j r-|rt j d | || S t
| |||| S )a Produce an alias of the given element, usually an :class:`.AliasedClass`
instance.
E.g.::
my_alias = aliased(MyClass)
session.query(MyClass, my_alias).filter(MyClass.id > my_alias.id)
The :func:`.aliased` function is used to create an ad-hoc mapping of a
mapped class to a new selectable. By default, a selectable is generated
from the normally mapped selectable (typically a :class:`_schema.Table`)
using the
:meth:`_expression.FromClause.alias` method. However, :func:`.aliased`
can also be
used to link the class to a new :func:`_expression.select` statement.
Also, the :func:`.with_polymorphic` function is a variant of
:func:`.aliased` that is intended to specify a so-called "polymorphic
selectable", that corresponds to the union of several joined-inheritance
subclasses at once.
For convenience, the :func:`.aliased` function also accepts plain
:class:`_expression.FromClause` constructs, such as a
:class:`_schema.Table` or
:func:`_expression.select` construct. In those cases, the
:meth:`_expression.FromClause.alias`
method is called on the object and the new
:class:`_expression.Alias` object returned. The returned
:class:`_expression.Alias` is not
ORM-mapped in this case.
:param element: element to be aliased. Is normally a mapped class,
but for convenience can also be a :class:`_expression.FromClause`
element.
:param alias: Optional selectable unit to map the element to. This is
usually used to link the object to a subquery, and should be an aliased
select construct as one would produce from the
:meth:`_query.Query.subquery` method or
the :meth:`_expression.Select.alias` methods of the
:func:`_expression.select` construct.
:param name: optional string name to use for the alias, if not specified
by the ``alias`` parameter. The name, among other things, forms the
attribute name that will be accessible via tuples returned by a
:class:`_query.Query` object.
:param flat: Boolean, will be passed through to the
:meth:`_expression.FromClause.alias` call so that aliases of
:class:`_expression.Join` objects
don't include an enclosing SELECT. This can lead to more efficient
queries in many circumstances. A JOIN against a nested JOIN will be
rewritten as a JOIN against an aliased SELECT subquery on backends that
don't support this syntax.
.. seealso:: :meth:`_expression.Join.alias`
:param adapt_on_names: if True, more liberal "matching" will be used when
mapping the mapped columns of the ORM entity to those of the
given selectable - a name-based match will be performed if the
given selectable doesn't otherwise have a column that corresponds
to one on the entity. The use case for this is when associating
an entity with some derived selectable such as one that uses
aggregate functions::
class UnitPrice(Base):
__tablename__ = 'unit_price'
...
unit_id = Column(Integer)
price = Column(Numeric)
aggregated_unit_price = Session.query(
func.sum(UnitPrice.price).label('price')
).group_by(UnitPrice.unit_id).subquery()
aggregated_unit_price = aliased(UnitPrice,
alias=aggregated_unit_price, adapt_on_names=True)
Above, functions on ``aggregated_unit_price`` which refer to
``.price`` will return the
``func.sum(UnitPrice.price).label('price')`` column, as it is
matched on the name "price". Ordinarily, the "price" function
wouldn't have any "column correspondence" to the actual
``UnitPrice.price`` column as it is not a proxy of the original.
z+adapt_on_names only applies to ORM elementsr )r r r r )r3 r
FromClauser9 r: r r )elementr r r r s r0 aliasedr; sx n ':011
&=
}}T}--- )
r2 c n t | } |rZ|j | u sJ t j | }t d |j D }
||
k r|S | |
}| ||| \ } }|s|r| | }t | || ||| S )a Produce an :class:`.AliasedClass` construct which specifies
columns for descendant mappers of the given base.
Using this method will ensure that each descendant mapper's
tables are included in the FROM clause, and will allow filter()
criterion to be used against those tables. The resulting
instances will also have those columns already loaded so that
no "post fetch" of those columns will be required.
.. seealso::
:ref:`with_polymorphic` - full discussion of
:func:`_orm.with_polymorphic`.
:param base: Base class to be aliased.
:param classes: a single class or mapper, or list of
class/mappers, which inherit from the base class.
Alternatively, it may also be the string ``'*'``, in which case
all descending mapped classes will be added to the FROM clause.
:param aliased: when True, the selectable will be wrapped in an
alias, that is ``(SELECT * FROM ) AS anon_1``.
This can be important when using the with_polymorphic()
to create the target of a JOIN on a backend that does not
support parenthesized joins, such as SQLite and older
versions of MySQL. However if the
:paramref:`.with_polymorphic.selectable` parameter is in use
with an existing :class:`_expression.Alias` construct,
then you should not
set this flag.
:param flat: Boolean, will be passed through to the
:meth:`_expression.FromClause.alias` call so that aliases of
:class:`_expression.Join`
objects don't include an enclosing SELECT. This can lead to more
efficient queries in many circumstances. A JOIN against a nested JOIN
will be rewritten as a JOIN against an aliased SELECT subquery on
backends that don't support this syntax.
Setting ``flat`` to ``True`` implies the ``aliased`` flag is
also ``True``.
.. versionadded:: 0.9.0
.. seealso:: :meth:`_expression.Join.alias`
:param selectable: a table or select() statement that will
be used in place of the generated FROM clause. This argument is
required if any of the desired classes use concrete table
inheritance, since SQLAlchemy currently cannot generate UNIONs
among tables automatically. If used, the ``selectable`` argument
must represent the full set of tables and columns mapped by every
mapped class. Otherwise, the unaccounted mapped columns will
result in their table being appended directly to the FROM clause
which will usually lead to incorrect results.
:param polymorphic_on: a column to be used as the "discriminator"
column for the given selectable. If not given, the polymorphic_on
attribute of the base classes' mapper will be used, if any. This
is useful for mappings that don't have polymorphic loading
behavior by default.
:param innerjoin: if True, an INNER JOIN will be used. This should
only be specified if querying for one specific subtype only
c g | ] }|j
S r+ )r r* s r0 r1 z$with_polymorphic.. s J J J2RY J J Jr2 ) innerjoinr8 )r r r r )
r r r to_setr6 r union_with_polymorphic_argsr r ) baseclassesr r r r; r> r _existing_aliasprimary_mapper new_classesmapperss r0 with_polymorphicrH V s Z &d++N 1 % 7777+g&& J J !I J J J
k ! !" " mmK00G(??y @ GZ 1$ 1 %%4%00
!('5("+m
r2 c 2 t j | ddi| S )zDeep 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 _deep_annotate)r: excludes r0
_orm_annotaterM s "7\4,@' J JJr2 c . t j | d S )zRemove 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.
)rJ r )rF r _deep_deannotater: s r0 _orm_deannotaterR s$ $6 r2 c * t j | S r^ rO rQ s r0 _orm_full_deannotaterT s $W - --r2 c Z e Zd ZdZej j Z ddZd Z d dZ d
dZ
dS ) _ORMJoinz/Extend Join to support ORM constructs as input.NFc t j | }t |d| } t j | }
|
j } |
| _ || _ || _ t |t j rt | j
| }t |t j r!|j
} |j }
n&t |t r|}
|
j j } nd }
|
rt% j | |j r| }n|j }|
|| dd|
j d \ }}}}}}|5|rt- j ||| }|}n t- j |||| }|}n|}|| _ t2 j | ||||| |
s]t |
dd rN|
j j rD|
j j }|8|
j r|
j | }| j! |z | _! d S d S d S d S d S )N_joined_from_infoT)source_selectabledest_selectablesource_polymorphicdest_polymorphicof_type_mapperalias_secondaryr )"r r r r rX
_left_memo _right_memor3 r r4 r r QueryableAttribute
comparator_source_selectabler1 r parentr clause_is_present
_create_joinsr r r; _target_adapterr Joinr single_single_table_criterionr r r r )rG leftrightr isouterfullr_ r` left_info
left_orm_info
right_infoadapt_to
on_selectableprop
adapt_frompjsjsourcedest secondarytarget_adapter single_crits r0 r z_ORMJoin.__init__ sY &t,, &99EE
'..
(!+ $& h 1 2 2 ? } 3X>>H h
= > > $ / B B D DM$DD
.
1
1 D K 2MMD 2)-9MNN
2 *
& 1
""", (#'!% ) 0 $
#
~ " HYr : :E !HH 8D)RAAD !HH #1D tUHgtLLL <
Hd33 < !( < %+CK& . L","5">">{"K"KK $
;
< < < < < < '&r2 c H |}t |t j r!|j }t |t j !| j |u sJ t | j |j | j | j | j |j }t ||j |j |j |j S )zlSplice a join into the center.
Given join(a, b) and join(b, c), return join(a, b).join(c)
)rm r_ r` )rm r` )
r3 r rh rk rl rV r rm r_ r` )rG otherleftmostrk s r0 _splice_into_centerz _ORMJoin._splice_into_center1 s 38,, % }H 38,, % zX%%%% I J ML (
K NM )
r2 c * t | |||| S )N)rn rm rV )rG rl r rm rn join_to_lefts r0 r; z
_ORMJoin.joinN s eXD'JJJJr2 c * t | ||d| S )NT)rm rn r )rG rl r rn r s r0 outerjoinz_ORMJoin.outerjoinX s eXt$GGGGr2 )NFFNNNFFNNFN) rT rU rV rW r rh __visit_name__r r r; r r+ r2 r0 rV rV s 99 _3N
Q< Q< Q< Q 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
)r r r r r r r s r0 $_entity_corresponds_to_use_path_implr s (
#
P++
P& NEV-N$N
$
""6=111
#
988
r2 c | j r#|| j v p| j | S | j r || j v S | | S )zedetermine if 'given' "is a" mapper, in terms of the given
would load rows of type 'mapper'.
)r r r r )r r s r0 _entity_isar sh
!77
5<;K;K <
<
' !777yy r2 c | ddl m} m}m}m} ddlm} ddlm} |x|_ x| _ x|_ x|_ |_ dS )aZ Use random-ordering sets within the unit of work in order
to detect unit of work sorting issues.
This is a utility function that can be used to help reproduce
inconsistent unit of work sorting issues. For example,
if two kinds of objects A and B are being inserted, and
B has a foreign key reference to A - the A must be inserted first.
However, if there is no relationship between A and B, the unit of work
won't know to perform this sorting, and an operation may or may not
fail, depending on how the ordering works out. Since Python sets
and dictionaries have non-deterministic ordering, such an issue may
occur on some runs and not on others, and in practice it tends to
have a great dependence on the state of the interpreter. This leads
to so-called "heisenbugs" where changing entirely irrelevant aspects
of the test program still cause the failure behavior to change.
By calling ``randomize_unitofwork()`` when a script first runs, the
ordering of a key series of sets within the unit of work implementation
are randomized, so that the script can be minimized down to the
fundamental mapping and operation that's failing, while still reproducing
the issue on at least some runs.
This utility is also available when running the test suite via the
``--reversetop`` flag.
r )
unitofworksessionr
dependency) topological) RandomSetN)
sqlalchemy.ormr r r r sqlalchemy.utilr sqlalchemy.testing.utilr r6 )r r r r r r s r0 randomize_unitofworkr s 6 GFFFFFFFFFFF++++++111111 5>>KO >> > j:>>>r2 )r T)NNFF)FFNFFFNr^ r r );rQ r r rP r rB r r r r r r
r r r
r r r
interfacesr r
path_registryr r r r9 r r r r r rA rX r$ r r r r r objectr r _inspectsr; rH rM rR rT rh rV r; r r r r r r r r r+ r2 r0 r s
" " " " " " % % % % % % ! ! ! ! ! ! & & & & & & & & & & & & ' ' ' ' ' ' " " " " " " y ? ? ? ? ?Y ? ? ?D?D ?D ?DF =AF3 F3 F3 F3Re; e; e;P$5 $5 $5 $5 $5' $5 $5 $5NF' F' F' F' F'6 F' F' F'RO< O< O< O< O<. O< O< O !> !> !> !>r2