흉dZddlmZddlZddlmZddlmZddlm Z ddlm Z dd lm Z dd lm Z dd lm Z dd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZdxZxZZdZGdde e ejZGddejZGddeZGdde Z!Gdde Z"dS) aI Contains various base classes used throughout the ORM. Defines some key base classes prominent within the internals, as well as the now-deprecated ORM extension classes. Other than the deprecated extensions, this module and the classes within are mostly private, though some attributes are exposed when inspecting mappings. )absolute_importN)exc) path_registry)_MappedAttribute) EXT_CONTINUE)EXT_SKIP)EXT_STOP)InspectionAttr)InspectionAttrInfo) MANYTOMANY) MANYTOONE) NOT_EXTENSION) ONETOMANY)inspect)util) operators)AttributeExtensionrr r rr rrLoaderStrategyMapperExtension MapperOptionMapperPropertyPropComparatorSessionExtensionStrategizedPropertyceZdZdZdZeZ dZ dZdZ dZ ddZ d Z d Z d Zd Zed ZdZdZdZdZdS)raRepresent a particular class attribute mapped by :class:`_orm.Mapper`. The most common occurrences of :class:`.MapperProperty` are the mapped :class:`_schema.Column`, which is represented in a mapping as an instance of :class:`.ColumnProperty`, and a reference to another class produced by :func:`_orm.relationship`, represented in the mapping as an instance of :class:`.RelationshipProperty`. )_configure_started_configure_finishedparentkeyinfoTciS)aInfo dictionary associated with the object, allowing user-defined data to be associated with this :class:`.InspectionAttr`. The dictionary is generated when first accessed. Alternatively, it can be specified as a constructor argument to the :func:`.column_property`, :func:`_orm.relationship`, or :func:`.composite` functions. .. versionchanged:: 1.0.0 :attr:`.MapperProperty.info` is also available on extension types via the :attr:`.InspectionAttrInfo.info` attribute, so that it can apply to a wider variety of ORM and extension constructs. .. seealso:: :attr:`.QueryableAttribute.info` :attr:`.SchemaItem.info` selfs m/builddir/build/BUILD/cloudlinux-venv-1.0.10/venv/lib64/python3.11/site-packages/sqlalchemy/orm/interfaces.py_memoized_attr_infoz"MapperProperty._memoized_attr_infocs , c dS)aCalled by Query for the purposes of constructing a SQL statement. Each MapperProperty associated with the target mapper processes the statement referenced by the query context, adding columns and/or criterion as appropriate. Nr$)r&context query_entitypathadapterkwargss r'setupzMapperProperty.setup{r)cdS)zcProduce row processing functions and append to the given set of populators lists. Nr$)r&r+r-mapperresultr. populatorss r'create_row_processorz#MapperProperty.create_row_processorr1r)Nc tdS)aIterate through instances related to the given instance for a particular 'cascade', starting with this MapperProperty. Return an iterator3-tuples (instance, mapper, state). Note that the 'cascade' collection on this MapperProperty is checked first for the given type before cascade_iterator is called. This method typically only applies to RelationshipProperty. r$)iter)r&type_statevisited_instanceshalt_ons r'cascade_iteratorzMapperProperty.cascade_iteratorsBxxr)c||_dS)zSet the parent mapper that references this MapperProperty. This method is overridden by some subclasses to perform extra setup when the mapper is first known. N)r )r&r inits r' set_parentzMapperProperty.set_parents r)cdS)aIHook called by the Mapper to the property to initiate instrumentation of the class attribute managed by this MapperProperty. The MapperProperty here will typically call out to the attributes module to set up an InstrumentedAttribute. This step is the first of two steps to set up an InstrumentedAttribute, and is called early in the mapper setup process. The second step is typically the init_class_attribute step, called from StrategizedProperty via the post_instrument_class() hook. This step assigns additional state to the InstrumentedAttribute (specifically the "impl") which has been determined after the MapperProperty has determined what kind of persistence management it needs to do (e.g. scalar, object, collection, etc). Nr$r&r3s r'instrument_classzMapperProperty.instrument_classr1r)c"d|_d|_dSNF)rrr%s r'__init__zMapperProperty.__init__s"'#(   r)cJd|_|d|_dS)zCalled after all mappers are created to assemble relationships between mappers and perform other post-mapper-creation initialization steps. TN)rdo_initrr%s r'r?zMapperProperty.inits' #' #'   r)c@t|jj|jS)aReturn the class-bound descriptor corresponding to this :class:`.MapperProperty`. This is basically a ``getattr()`` call:: return getattr(self.parent.class_, self.key) I.e. if this :class:`.MapperProperty` were named ``addresses``, and the class to which it is mapped is ``User``, this sequence is possible:: >>> from sqlalchemy import inspect >>> mapper = inspect(User) >>> addresses_property = mapper.attrs.addresses >>> addresses_property.class_attribute is User.addresses True >>> User.addresses.property is addresses_property True )getattrr class_r!r%s r'class_attributezMapperProperty.class_attributes0t{)48444r)cdS)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'rHzMapperProperty.do_initr1r)cdS)aPerform 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$rBs r'post_instrument_classz$MapperProperty.post_instrument_classr1r)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.merger1r)c^d|jjt|t|ddfzS)Nz<%s at 0x%x; %s>r!zno key) __class____name__idrJr%s r'__repr__zMapperProperty.__repr__ s4! N # tHH D% * *%   r))NN)r\ __module__ __qualname____doc__ __slots__ frozensetcascade is_propertyr(r0r6r=r@rCrFr?propertyrLrHrOrYr^r$r)r'rr@s  IikkGK 0      =A"   ()))(((55X52               r)rceZdZdZdZddZdZdZdZdZ e d Z e d Z e d Z ed Zed ZedZdZddZddZdS)raU 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_entityNcB|x|_|_|p||_||_dSNrh)r&ri parentmapperadapt_to_entitys r'rFzPropComparator.__init__ls+$(( DM,<  /r)c&td|z)Nz%r)NotImplementedErrorr%s r'__clause_element__z!PropComparator.__clause_element__qs!$+...r)c*|Srmrrr%s r'_query_clause_elementz$PropComparator._query_clause_elementts&&(((r)c0||fgSrmrt)r&values r'_bulk_update_tuplesz"PropComparator._bulk_update_tuplesws((**E233r)cD||j|j|S)zReturn a copy of this PropComparator which will use the given :class:`.AliasedInsp` to produce corresponding expressions. )r[rirj)r&ros r'rozPropComparator.adapt_to_entityzs~~di);_MMMr)c4t|jjS)zZlegacy; this is renamed to _parententity to be compatible with QueryableAttribute.)rrjr3r%s r' _parentmapperzPropComparator._parentmapperst)**11r)c,|jdS|jjS)zrProduce a callable that adapts column expressions to suit an aliased version of this comparator. N)rk_adapt_elementr%s r'r.zPropComparator.adapters  (4(7 7r)c|jjSrm)rfr"r%s r'r"zPropComparator.infos }!!r)c |j|fi|Srm)anyabr/s r'any_opzPropComparator.any_opquQ!!&!!!r)c |j|fi|Srm)hasrs r'has_opzPropComparator.has_oprr)c,||Srm)of_type)rrKs r' of_type_opzPropComparator.of_type_opsyy   r)cB|tj|S)aRedefine 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` )operaterr)r&rKs r'rzPropComparator.of_types*||N5v>>>r)c 4|jtj|fi|S)aReturn 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. )rrrr& criterionr/s r'rzPropComparator.any# t|N19GGGGGr)c 4|jtj|fi|S)aReturn 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. )rrrrs r'rzPropComparator.hasrr)rm)r\r_r`rarbrFrrrurxrorfr{r.r" staticmethodrrrrrrr$r)r'rrs_UUnHI0000 ///)))444NNN 22X2 88X8""X"""\"""\"!!\!???.HHHH$HHHHHHr)rceZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z ejeZed Zed ZdS)raA 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_keyNc0|jdtjfS)N:)strategy_wildcard_keyr_WILDCARD_TOKENr%s r'_memoized_attr__wildcard_tokenz2StrategizedProperty._memoized_attr__wildcard_tokens()))=+H+H J  r)c4d|jdtjffS)Nloaderr)rr_DEFAULT_TOKENr%s r''_memoized_attr__default_path_loader_keyz;StrategizedProperty._memoized_attr__default_path_loader_keys0 ---}/K/KM   r)cxd}||}|j|j|jfD]}||jvr|j|}n|Srm) _loader_key_wildcard_path_loader_keyr attributes)r&r+r-rV search_pathpath_keys r'_get_context_loaderz'StrategizedProperty._get_context_loadersc4j  #  1  0   H 7---)(3. r)c |j|S#t$rYnwxYw|j|g|R}|||x|j|<x|j|<}|Srm)rKeyError_strategy_lookup)r&r!clsrs r' _get_strategyz!StrategizedProperty._get_strategys #C( (    D $d#D/3///CF3 #D D    0 5s  c |||}|r"|jr||j}n|j}|j|||||fi|dSrm)rrr setup_query)r&r+r,r-r.r/rstrats r'r0zStrategizedProperty.setup%s))'488  "fo "&&v77EEME \4  .decorateJsf w'777)+&rxxzz**++C,3C  $S )  " ) )# . . .Nr)r$)rrrs`` r' strategy_forz StrategizedProperty.strategy_forHs)      r)c|jD]3}||jvr(|j|} ||cS#t$rY/wxYw4|jD]\}}||vr |}||}nd}d}t j|||||rm)__mro__rrrorm_excLoaderStrategyException) rrequesting_propertyr!prop_cls strategies property_typestratsintended_property_typeactual_strategys r'rz$StrategizedProperty._strategy_lookupVs   H3... 0: %c?***D /&)%8%>%>%@%@ # # !M6f}})6&"(+ &* ""O-   "      s + 88)r\r_r`rarbrrrrrr0r6rHrO collections defaultdictdictr classmethodrrr$r)r'rrs I!      $          >>>777.k-d33O  [   [   r)rc*eZdZdZdZ dZdZdZdS)rz#Describe a modification to a Query.FcdS)z8Apply a modification to the given :class:`_query.Query`.Nr$r&querys r' process_queryzMapperOption.process_query|r1r)c0||dS)alsame 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)rrs r'process_query_conditionallyz(MapperOption.process_query_conditionallys 5!!!!!r)cdS)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_keys dur)N)r\r_r`rapropagate_to_loadersrrrr$r)r'rrrsU--  GGG " " "22222r)rc4eZdZdZdZdZdZdZdZdZ dS) raDescribe 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|_|jj|_|jj|_||_t ||_dSrE)rrr r!rrr)r&r rs r'rFzLoaderStrategy.__init__sJ%#*1 '+(!,//r)cdSrmr$rBs r'rz#LoaderStrategy.init_class_attributes 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'rzLoaderStrategy.setup_queryr1r)cdS)aEstablish 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-rr3r4r.r5s r'r6z#LoaderStrategy.create_row_processorr1r)c*t|jSrm)strrr%s r'__str__zLoaderStrategy.__str__s4'(((r)N) r\r_r`rarbrFrrr6rr$r)r'rrsp.I000           )))))r)r)#ra __future__rrrrrbaserrr r r r r rrrrrsqlrrrr__all__ MemoizedSlotsrColumnOperatorsrrobjectrrr$r)r'rst  '&&&&&"""""" $$$$$$;?>>"%7 &O O O O O %~t7IO O O dHHHHHHHHHHY.HHHHHHVR R R R R .R R R jLLLLL6LLL^F)F)F)F)F)VF)F)F)F)F)r)