>> from sqlalchemy import inspect
>>> mapper = inspect(User)
>>> addresses_property = mapper.attrs.addresses
>>> addresses_property.class_attribute is User.addresses
True
>>> User.addresses.property is addresses_property
True
)getattrr class_r! r% s r' class_attributez MapperProperty.class_attribute s 0 t{)48444r) c dS )zPerform subclass-specific initialization post-mapper-creation
steps.
This is a template method called by the ``MapperProperty``
object's init() method.
Nr$ r% s r' rH zMapperProperty.do_init r1 r) c dS )a Perform instrumentation adjustments that need to occur
after init() has completed.
The given Mapper is the Mapper invoking the operation, which
may not be the same Mapper as self.parent in an inheritance
scenario; however, Mapper will always at least be a sub-mapper of
self.parent.
This method is typically used by StrategizedProperty, which delegates
it to LoaderStrategy.init_class_attribute() to perform final setup
on the class-bound InstrumentedAttribute.
Nr$ rB s r' post_instrument_classz$MapperProperty.post_instrument_class r1 r) c dS )zoMerge the attribute represented by this ``MapperProperty``
from source to destination object.
Nr$ ) r& session source_state source_dict
dest_state dest_dictload
_recursive_resolve_conflict_maps r' mergezMapperProperty.merge r1 r) c ^ d| j j t | t | dd fz S )Nz<%s at 0x%x; %s>r! zno key) __class____name__idrJ r% s r' __repr__zMapperProperty.__repr__
s4 ! N # tHH D% * *%
r) )NN)r\
__module__ __qualname____doc__ __slots__ frozensetcascade is_propertyr( r0 r6 r= r@ rC rF r? propertyrL rH rO rY r^ r$ r) r' r r @ s I ikkG K
0 =A " () ) )( ( ( 5 5 X52
r) r c e Zd ZdZdZddZd Zd Zd Zd Z e
d Z e
d
Z e
d Z
ed Zed
Zed Zd ZddZddZdS )r aU
Defines SQL operators for :class:`.MapperProperty` objects.
SQLAlchemy allows for operators to
be redefined at both the Core and ORM level. :class:`.PropComparator`
is the base class of operator redefinition for ORM-level operations,
including those of :class:`.ColumnProperty`,
:class:`.RelationshipProperty`, and :class:`.CompositeProperty`.
.. note:: With the advent of Hybrid properties introduced in SQLAlchemy
0.7, as well as Core-level operator redefinition in
SQLAlchemy 0.8, the use case for user-defined :class:`.PropComparator`
instances is extremely rare. See :ref:`hybrids_toplevel` as well
as :ref:`types_operators`.
User-defined subclasses of :class:`.PropComparator` may be created. The
built-in Python comparison and math operator methods, such as
:meth:`.operators.ColumnOperators.__eq__`,
:meth:`.operators.ColumnOperators.__lt__`, and
:meth:`.operators.ColumnOperators.__add__`, can be overridden to provide
new operator behavior. The custom :class:`.PropComparator` is passed to
the :class:`.MapperProperty` instance via the ``comparator_factory``
argument. In each case,
the appropriate subclass of :class:`.PropComparator` should be used::
# definition of custom PropComparator subclasses
from sqlalchemy.orm.properties import \
ColumnProperty,\
CompositeProperty,\
RelationshipProperty
class MyColumnComparator(ColumnProperty.Comparator):
def __eq__(self, other):
return self.__clause_element__() == other
class MyRelationshipComparator(RelationshipProperty.Comparator):
def any(self, expression):
"define the 'any' operation"
# ...
class MyCompositeComparator(CompositeProperty.Comparator):
def __gt__(self, other):
"redefine the 'greater than' operation"
return sql.and_(*[a>b for a, b in
zip(self.__clause_element__().clauses,
other.__composite_values__())])
# application of custom PropComparator subclasses
from sqlalchemy.orm import column_property, relationship, composite
from sqlalchemy import Column, String
class SomeMappedClass(Base):
some_column = column_property(Column("some_column", String),
comparator_factory=MyColumnComparator)
some_relationship = relationship(SomeOtherClass,
comparator_factory=MyRelationshipComparator)
some_composite = composite(
Column("a", String), Column("b", String),
comparator_factory=MyCompositeComparator
)
Note that for column-level operator redefinition, it's usually
simpler to define the operators at the Core level, using the
:attr:`.TypeEngine.comparator_factory` attribute. See
:ref:`types_operators` for more detail.
.. seealso::
:class:`.ColumnProperty.Comparator`
:class:`.RelationshipProperty.Comparator`
:class:`.CompositeProperty.Comparator`
:class:`.ColumnOperators`
:ref:`types_operators`
:attr:`.TypeEngine.comparator_factory`
proprf
_parententity_adapt_to_entityNc B |x| _ | _ |p|| _ || _ d S Nrh )r& ri parentmapperadapt_to_entitys r' rF zPropComparator.__init__l s+ $(( DM , < / r) c & t d| z )Nz%r)NotImplementedErrorr% s r' __clause_element__z!PropComparator.__clause_element__q s !$+...r) c * | S rm rr r% s r' _query_clause_elementz$PropComparator._query_clause_elementt s &&(((r) c 0 | |fgS rm rt )r& values r' _bulk_update_tuplesz"PropComparator._bulk_update_tuplesw s ((**E233r) c D | | j | j | S )zReturn a copy of this PropComparator which will use the given
:class:`.AliasedInsp` to produce corresponding expressions.
)r[ ri rj )r& ro s r' ro z PropComparator.adapt_to_entityz s ~~di);_MMMr) c 4 t | j j S )zZlegacy; this is renamed to _parententity to be
compatible with QueryableAttribute.)r rj r3 r% s r'
_parentmapperz PropComparator._parentmapper s t)**11r) c , | j dS | j j S )zrProduce a callable that adapts column expressions
to suit an aliased version of this comparator.
N)rk _adapt_elementr% s r' r. zPropComparator.adapter s (4(7 7r) c | j j S rm )rf r" r% s r' r" zPropComparator.info s
}!!r) c | j |fi |S rm )anyabr/ s r' any_opzPropComparator.any_op quQ!!&!!!r) c | j |fi |S rm )hasr s r' has_opzPropComparator.has_op r r) c , | | S rm )of_type)r rK s r'
of_type_opzPropComparator.of_type_op s yy r) c B | t j | S )a Redefine this object in terms of a polymorphic subclass,
:func:`.with_polymorphic` construct, or :func:`.aliased` construct.
Returns a new PropComparator from which further criterion can be
evaluated.
e.g.::
query.join(Company.employees.of_type(Engineer)).\
filter(Engineer.name=='foo')
:param \class_: a class or mapper indicating that criterion will be
against this specific subclass.
.. seealso::
:ref:`inheritance_of_type`
)operater r )r& rK s r' r zPropComparator.of_type s * ||N 5v>>>r) c 4 | j t j |fi |S )a Return true if this collection contains any member that meets the
given criterion.
The usual implementation of ``any()`` is
:meth:`.RelationshipProperty.Comparator.any`.
:param criterion: an optional ClauseElement formulated against the
member class' table or attributes.
:param \**kwargs: key/value pairs corresponding to member class
attribute names which will be compared via equality to the
corresponding values.
)r r r r& criterionr/ s r' r zPropComparator.any # t|N 19GGGGGr) c 4 | j t j |fi |S )a Return true if this element references a member which meets the
given criterion.
The usual implementation of ``has()`` is
:meth:`.RelationshipProperty.Comparator.has`.
:param criterion: an optional ClauseElement formulated against the
member class' table or attributes.
:param \**kwargs: key/value pairs corresponding to member class
attribute names which will be compared via equality to the
corresponding values.
)r r r r s r' r zPropComparator.has r r) rm )r\ r_ r` ra rb rF rr ru rx ro rf r{ r. r" staticmethodr r r r r r r$ r) r' r r s_ U Un HI0 0 0 0
/ / /) ) )4 4 4N N N 2 2 X2
8 8 X8 " " X" " " \" " " \" ! ! \!? ? ?.H H H H$H H H H H Hr) r c e Zd ZdZdZdZd Zd Zd Zd Z d Z
d Z d
Z d Z
ej e Zed Zed
ZdS )r a A MapperProperty which uses selectable strategies to affect
loading behavior.
There is a single strategy selected by default. Alternate
strategies can be selected at Query time through the usage of
``StrategizedOption`` objects via the Query.options() method.
The mechanics of StrategizedProperty are used for every Query
invocation for every mapped attribute participating in that Query,
to determine first how the attribute will be rendered in SQL
and secondly how the attribute will retrieve a value from a result
row and apply it to a mapped object. The routines here are very
performance-critical.
) _strategiesstrategy_wildcard_token_default_path_loader_keyNc 0 | j dt j fS )N:)strategy_wildcard_keyr _WILDCARD_TOKENr% s r' _memoized_attr__wildcard_tokenz2StrategizedProperty._memoized_attr__wildcard_token s( )))=+H+H
J
r) c 4 d| j dt j ffS )Nloaderr )r r _DEFAULT_TOKENr% s r' '_memoized_attr__default_path_loader_keyz;StrategizedProperty._memoized_attr__default_path_loader_key s0 ---}/K/KM
r) c x d }|| }|j |j |j fD ]}||j v r|j | } n|S rm ) _loader_key_wildcard_path_loader_keyr
attributes)r& r+ r- rV search_pathpath_keys r' _get_context_loaderz'StrategizedProperty._get_context_loader sc 4j
# 1 0
H
7--- )(3 . r) c | j | S # t $ r Y nw xY w | j | g|R } || | x| j |< x| j |< }|S rm )r KeyError_strategy_lookup)r& r! clsr s r'
_get_strategyz!StrategizedProperty._get_strategy s #C( ( D $d#D/3///CF3 #D
D
0 5 s
c | || }|r"|j r| |j }n| j } |j |||||fi | d S rm )r r r setup_query)r& r+ r, r- r. r/ r strats r' r0 zStrategizedProperty.setup% s ))'488 "fo "&&v77EEME \4
.decorateJ sf w'777)+&rxxzz**++C,3C $S ) " ) )# . . .Nr) r$ )r r r s `` r' strategy_forz StrategizedProperty.strategy_forH s) r) c | j D ]3}|| j v r(| j | } || c S # t $ r Y /w xY w4| j D ]\ }}||v r |}|| } nd }d }t j | |||| rm )__mro__r r r orm_excLoaderStrategyException) r requesting_propertyr! prop_cls
strategies
property_typestratsintended_property_typeactual_strategys r' r z$StrategizedProperty._strategy_lookupV s H3... 0 :
%c?*** D / &)%8%>%>%@%@ # # !M6f}})6&"(+
&* " "O- "
s +
88)r\ r_ r` ra rb r r r r r r0 r6 rH rO collections defaultdictdictr classmethodr r r$ r) r' r r s I !
$
> > >7 7 7 .k-d33O [
[
r) r c * e Zd ZdZdZ d Zd Zd ZdS )r z#Describe a modification to a Query.Fc dS )z8Apply a modification to the given :class:`_query.Query`.Nr$ r& querys r'
process_queryzMapperOption.process_query| r1 r) c 0 | | dS )al same as process_query(), except that this option may not
apply to the given query.
This is typically used during a lazy load or scalar refresh
operation to propagate options stated in the original Query to the
new Query being used for the load. It occurs for those options that
specify propagate_to_loaders=True.
N)r r s r' process_query_conditionallyz(MapperOption.process_query_conditionally s
5!!!!!r) c dS )a
Used by the "baked lazy loader" to see if this option can be cached.
The "baked lazy loader" refers to the :class:`_query.Query` that is
produced during a lazy load operation for a mapped relationship.
It does not yet apply to the "lazy" load operation for deferred
or expired column attributes, however this may change in the future.
This loader generates SQL for a query only once and attempts to cache
it; from that point on, if the SQL has been cached it will no longer
run the :meth:`_query.Query.options` method of the
:class:`_query.Query`. The
:class:`.MapperOption` object that wishes to participate within a lazy
load operation therefore needs to tell the baked loader that it either
needs to forego this caching, or that it needs to include the state of
the :class:`.MapperOption` itself as part of its cache key, otherwise
SQL or other query state that has been affected by the
:class:`.MapperOption` may be cached in place of a query that does not
include these modifications, or the option may not be invoked at all.
By default, this method returns the value ``False``, which means
the :class:`.BakedQuery` generated by the lazy loader will
not cache the SQL when this :class:`.MapperOption` is present.
This is the safest option and ensures both that the option is
invoked every time, and also that the cache isn't filled up with
an unlimited number of :class:`_query.Query` objects for an unlimited
number of :class:`.MapperOption` objects.
.. versionchanged:: 1.2.8 the default return value of
:meth:`.MapperOption._generate_cache_key` is False; previously it
was ``None`` indicating "safe to cache, don't include as part of
the cache key"
To enable caching of :class:`_query.Query` objects within lazy loaders
, a
given :class:`.MapperOption` that returns a cache key must return a key
that uniquely identifies the complete state of this option, which will
match any other :class:`.MapperOption` that itself retains the
identical state. This includes path options, flags, etc. It should
be a state that is repeatable and part of a limited set of possible
options.
If the :class:`.MapperOption` does not apply to the given path and
would not affect query results on such a path, it should return None,
indicating the :class:`_query.Query` is safe to cache for this given
loader path and that this :class:`.MapperOption` need not be
part of the cache key.
Fr$ )r& r- s r' _generate_cache_keyz MapperOption._generate_cache_key s
d ur) N)r\ r_ r` ra propagate_to_loadersr r r r$ r) r' r r r sU -- G G G " " "2 2 2 2 2r) r c 4 e Zd ZdZdZd Zd Zd Zd Zd Z dS ) r a Describe the loading behavior of a StrategizedProperty object.
The ``LoaderStrategy`` interacts with the querying process in three
ways:
* it controls the configuration of the ``InstrumentedAttribute``
placed on a class to handle the behavior of the attribute. this
may involve setting up class-level callable functions to fire
off a select operation when the attribute is first accessed
(i.e. a lazy load)
* it processes the ``QueryContext`` at statement construction time,
where it can modify the SQL statement that is being produced.
For example, simple column attributes will add their represented
column to the list of selected columns, a joined eager loader
may establish join clauses to add to the statement.
* It produces "row processor" functions at result fetching time.
These "row processor" functions populate a particular attribute
on a particular mapped instance.
)parent_propertyis_class_levelr r! r
strategy_optsc || _ d| _ | j j | _ | j j | _ || _ t | | _ d S rE )r r r r! r r r )r& r r s r' rF zLoaderStrategy.__init__ sJ % #*1 '+ ( !, / /r) c d S rm r$ rB s r' r z#LoaderStrategy.init_class_attribute s r) c dS )zEstablish column and other state for a given QueryContext.
This method fulfills the contract specified by MapperProperty.setup().
StrategizedProperty delegates its setup() method
directly to this method.
Nr$ )r& r+ r, r- loadoptr. r/ s r' r zLoaderStrategy.setup_query r1 r) c dS )a Establish row processing functions for a given QueryContext.
This method fulfills the contract specified by
MapperProperty.create_row_processor().
StrategizedProperty delegates its create_row_processor() method
directly to this method.
Nr$ )r& r+ r- r r3 r4 r. r5 s r' r6 z#LoaderStrategy.create_row_processor r1 r) c * t | j S rm )strr r% s r' __str__zLoaderStrategy.__str__ s 4'(((r) N)
r\ r_ r` ra rb rF r r r6 r r$ r) r' r r sp .I0 0 0
) ) ) ) )r) r )#ra
__future__r r r r r baser r r r
r r r
r r r r r sqlr r r r __all__
MemoizedSlotsr ColumnOperatorsr r objectr r r$ r) r' r st ' & & & & & " " " " " " $ $ $ $ $ $ ;? > >"%7 &O
O
O
O
O
%~t7I O
O
O
dHH HH HH HH HHY. HH HH HHVR
R
R
R
R
. R
R
R
jL L L L L6 L L L^F) F) F) F) F)V F) F) F) F) F)r)