U
|
¸ý°dÖÙ ã @ sV d Z ddlmZ ddlmZ ddlZddlmZ ddlm Z ddlm
|
Z
|
ddlm Z ddlm Z dd lm Z dd
|
lmZ dd lmZ dd lmZ dd lmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z ddlm 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"lm*Z* dd#lm+Z+ dd$l m,Z, dd%l m-Z- dd&l m.Z. d'd(lm/Z0 d'd)lm1Z1 d'd*lm2Z2 d'd+lm3Z3 d'd,lm4Z4 d'dlm Z d'd-l5m6Z6 d'd.l5m7Z7 d'd/l8m9Z9 d'd0l8m:Z: d'd1l4m;Z; d'd2l4m<Z< d'd3l4m=Z= d'd4l4m>Z> d'dl4m Z? d'd5l4m@Z@ d'd6lAmBZB d'd7lAmCZC d'd8lDmEZE d'd9lFmGZG d'd:lFmHZH d'd;lFmIZI d'd<lFmJZJ d'd=lFmKZK d'd>lLmMZM d'd?lNmOZO d'd@lPmQZQ d'dAlPmRZR d'dBlPmSZS d'dClPmTZT d'dDlPmUZU d'dElPmVZV d'dFlPmWZW d'dGlPmXZX d'dHlYmZZZ d'dIlYm[Z[ er²ddJl m\Z\ ddKl m]Z] ddLl m^Z^ ddMl m_Z_ ddNl`maZa ddOlbmcZc ddPldmeZe ddQldmfZf ddRlgmhZh d'dSlimjZj d'dTlkmlZl d'dUlkmmZm d'dVlkmnZn d'dWlkmoZo d'dXlpmqZq d'dYlpmrZr d'dZlAmsZs d'd[lAmtZt d'd\lAmuZu d'd]lAmvZv d'd^lAmwZw d'd_lAmxZx d'd`lAmyZy d'dalAmzZz d'dblAm{Z{ d'dclAm|Z| d'ddlAm}Z} d'delAm~Z~ d'dflAmZ d'dglAmZ d'dhlAmZ d'dilAmZ d'djlAmZ d'dklAmZ d'dllAm
Z
d'dmlAmZ d'dnlFmZ d'dolFmZ d'dplLmZ d'dqlLmZ d'drlPmZ d'dslPmZ d'dtlPmZ d'dulPmZ d'dvlPmZ d'dwlPmZ d'dxlPmZ d'dylPmZ dzd{gZed|ed}Ze2je3jG d~dz dzeReEeUeVeTe:e3jeKeJe e ZG dd dejZG dd dZG dd deZG d
d deZG dd dee7eC ZdS )a The Query class and support.
|
|
Defines the :class:`_query.Query` class, the central
|
construct used by the ORM to construct database queries.
|
|
The :class:`_query.Query` class should not be confused with the
|
:class:`_expression.Select` class, which defines database
|
SELECT operations at the SQL (non-ORM) level. ``Query`` differs from
|
``Select`` in that it returns ORM-mapped objects and interacts with an
|
ORM session, whereas the ``Select`` construct interacts directly with the
|
database to return iterable result sets.
|
|
é )Ú annotationsN)ÚAny)ÚCallable)Úcast)ÚDict)ÚGeneric)ÚIterable)ÚIterator)ÚList)ÚMapping)ÚOptional)Úoverload)ÚSequence)ÚTuple)ÚType)Ú TYPE_CHECKING)ÚTypeVar)ÚUnioné )Ú
|
attributes)Ú
|
interfaces)Úloading)Úutil)Ú_O)Ú _assertions©Ú_column_descriptions)Ú _determine_last_joined_entity)Ú _legacy_filter_by_entity_zero)Ú FromStatement)ÚORMCompileState)Ú QueryContext)ÚORMColumnDescription)ÚORMColumnsClauseRole)Ú AliasedClass)Ú object_mapper)Ú with_parenté )Úexc)Úinspect)Ú
|
inspection)Úlog)Úsql)ÚResult)ÚRow)Ú
|
dispatcher)Ú EventTarget)Ú coercions)Ú
|
expression)Úroles)ÚSelect)Úvisitors)Ú_FromClauseArgument)Ú_TP)ÚSupportsCloneAnnotations©Ú_entity_namespace_key)Ú _generative)Ú_NoArg)Ú
|
Executable)Ú
|
Generative)ÚBooleanClauseList)ÚExists)Ú_MemoizedSelectEntities)Ú_SelectFromElements)Ú ForUpdateArg)ÚHasHints)Ú HasPrefixes)Ú HasSuffixes)Ú LABEL_STYLE_TABLENAME_PLUS_COL)ÚSelectLabelStyle)ÚLiteral)ÚSelf)Ú _EntityType)Ú_ExternalEntityType)Ú_InternalEntityType)ÚSynchronizeSessionArgument)ÚMapper)Ú PathRegistry)Ú_PKIdentityArgument)ÚSession)Ú InstanceState)Ú CursorResult)Ú_ImmutableExecuteOptions)ÚCompiledCacheType)ÚIsolationLevel)ÚSchemaTranslateMapType)Ú FrozenResult)Ú ScalarResult)Ú_ColumnExpressionArgument)Ú#_ColumnExpressionOrStrLabelArgument)Ú_ColumnsClauseArgument)Ú_DMLColumnArgument)Ú_JoinTargetArgument)Ú_LimitOffsetType)Ú _MAYBE_ENTITY)Ú_no_kw)Ú _NOT_ENTITY)Ú_OnClauseArgument)Ú_PropagateAttrsType)Ú_T0)Ú_T1)Ú_T2)Ú_T3)Ú_T4)Ú_T5)Ú_T6)Ú_T7)Ú_TypedColumnClauseArgument)ÚCacheableOptions)ÚExecutableOption)Ú ColumnElement)ÚLabel)Ú_JoinTargetElement)Ú_SetupJoinsElement)ÚAlias)ÚCTE)ÚExecutableReturnsRows)Ú
|
FromClause)Ú ScalarSelect)ÚSubqueryÚQueryr! Ú_T)Úboundc @ sF e Zd ZU dZdZded< dZded< dZded< dZded< dZ d ed
|
< dZ
|
d ed < d Z d ed< dZ ded< dZ ded< dZded< dZd ed< dZded< dZded< ejZded< dZejZded < d ed < ejd di Ze j Z d ed!< dZ dZ d"ed#< d$ed%< d&ed'< e j!d(d)d*d+Z"dÜd,d-d.d/d0Z#d1d2d3d4d5Z$d6d7d8d9d:Z%d;d<d=d>d?Z&d@d)dAdBZ'dCdDdEdFdGZ(dHd d7dIdJdKZ)e*dLd2dMdNdOZ+d7d)dPdQZ,d7d)dRdSZ-dÝdCd d d7dTdUdVZ.dÞdCd d d7dTdWdXZ/dCd7dYdZd[Z0dCd7dYd\d]Z1dCd7dYd^d_Z2e3d d)d`daZ4dßdbdbdcddded2dfdgdhZ5did2djdkdlZ6dmd)dndoZ7e3dpd)dqdrZ8dàd dsdtdudvZ9dád d dpdwdxdyZ:dâdzd d d{d|d}d~Z;dãdzd d ddddZ<dzddd
dZ=e>ddd=ddZ?e>ddd=ddZ?e>dd)ddZ?e @dd¡dd)ddZ?e>ddd=ddZAe>ddd=ddZAe>dd)ddZAdd)ddZAe3dpd)ddZBdpd)ddZCe>d;ddddd ZDe>d;d¡d;dd¢d ZDe*d d£d¤d¥d ZDe3d d)d¦d§ZEe*d d2d¤d¨d©ZFe*did2dªd«d¬ZGe jHdd®d¯d2d)d°d±ZIeIZJe3dd)d²d³ZKdd2d´dµd¶ZLe*d d2d¤d·d¸ZMe3d¹d)dºd»ZNe*d¼d2d½d¾d¿ZOe*dÀd2dÁdÂdÃZPe jHdÄdÅd¯dÆdedÇdÈdÉZQdädÆdÊdededËdÌdÍZRe3ddd)dÎdÏZSe3d¼d)dÐdÑZTe*dÒd2dÓdÔdÕZUe*d d2dÖd×dØZVe*d2d)dÙdÚZWe*d d2d¤dÛdÜZXe jHdÝdÞd¯e Ydß¡dådàdádâd2dãdädåZZe*dædædçd£dèdédêZ[e*d$d2dëdìdíZ\dîd2d8dïdðZ]e*d d2dñdòdóZ^e*dçdôd d2dõdöd÷Z_e @ddø¡dîdùdúdûdüZ`e`ZadîdùdúdýdþZbe @ddÿ¡d didddZce>dd;dddZde>dd d
|
d dZde>d d ddddZde>d d dddddZde>d d ddddddZde>d d dddddd dZde>d d dddd d d d dZde>d d dddd d!d"d#d$dZde>d d dddd d!d%d&d' d(dZde>dîd£d8d)dZde*dîdid£d*d+dZde*d d£dd,d-Zee @dd.¡d d£dd/d0Zfe*d1d2d2d3d4Zgd5d£d6d7d8Zhd9d)d:d;Zie>d<d<d<d d d<d<d<d<d d d= d>dCd?d d dÀdÀdÀd@d d did2dA dBdCZje>did2dªdDdCZje*did2dEdFdCZje*d d dd d dGd d dHd d d2dIdJdKZke*dèdLdid2dMdNdOZldPd2dQdRdSZme*ene1e2dPd2dQdTdUZoe j!dVd)dWdXZpdid)dYdZZqdid2dEd[d\Zre*esjtfd]d^d2d_d`daZue*esjtfd]d^d2d_dbdcZve*ene1e2dPd2dddedfZwdid£d2dgdhdiZxd£d2djdkdlZyd£d2djdmdnZzd£d2djdodpZ{d£d2djdqdrZ|d£d2djdsdtZ}d£d2djdudvZ~e*ene1e2déd d dwdxdyd d d2dzd{d|Zdêd d}dxdyd d2d~ddZe*ene1d2d)ddZe*ene0dd2dd
dZdididddZe*ene1dÀdÀd2dddZe*ene1dd2dddZ
e*ene1dd2dddZe*ene1d d2dddZdd)ddZe*ene0dd2dddZdd)dd Zdd)d¡d¢Zd£d)d¤d¥Zdid)d¦d§Zd¨d)d©dªZd«d)d¬dZdCd)d®d¯Zdidididid°d±d²Ze3d³d)d´dµZe @d¶d·¡dëd¸d¹didºd»d¼Ze jHd½d¾d d¿dìdÀd dÁdÂdÃdÄZdÅd)dÆdÇZdÀd)dÈdÉZdídËdÀdÌdÍdÎZdîdÏdËdÐdÀdÑdÒdÓZdïd didÔdÕdÖd×Zdðd dØdÙdÚdÛZdS (ñ r{ aO ORM-level SQL construction object.
|
|
.. legacy:: The ORM :class:`.Query` object is a legacy construct
|
as of SQLAlchemy 2.0. See the notes at the top of
|
:ref:`query_api_toplevel` for an overview, including links to migration
|
documentation.
|
|
:class:`_query.Query` objects are normally initially generated using the
|
:meth:`~.Session.query` method of :class:`.Session`, and in
|
less common cases by instantiating the :class:`_query.Query` directly and
|
associating with a :class:`.Session` using the
|
:meth:`_query.Query.with_session`
|
method.
|
|
© z Tuple[ColumnElement[Any], ...]Ú_where_criteriaÚ_having_criteriaÚ_order_by_clausesÚ_group_by_clausesNz Optional[ColumnElement[Any]]Ú _limit_clauseÚ_offset_clauseFÚboolÚ _distinctÚ _distinct_onzOptional[ForUpdateArg]Ú_for_update_argzTuple[FromClause, ...]Ú
|
_correlateTÚ_auto_correlateÚ _from_objz Tuple[_SetupJoinsElement, ...]Ú _setup_joinsrH Ú _label_stylez/Union[Type[CacheableOptions], CacheableOptions]Ú_compile_optionsz Tuple[ExecutableOption, ...]Ú _with_optionsZ_legacy_uniquingz util.immutabledict[str, Any]Ú_paramsz Optional[ExecutableReturnsRows]Ú
|
_statementrR Úsessionzdispatcher[Query[_T]]Údispatchre ©Úreturnc C s t jS ©N)r Ú
|
EMPTY_DICT©Úselfr~ r~ úKd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\sqlalchemy/orm/query.pyÚ_propagate_attrsç s zQuery._propagate_attrsz%Sequence[_ColumnsClauseArgument[Any]]zOptional[Session])Úentitiesr c C s || _ | |¡ dS )a· Construct a :class:`_query.Query` directly.
|
|
E.g.::
|
|
q = Query([User, Address], session=some_session)
|
|
The above is equivalent to::
|
|
q = some_session.query(User, Address)
|
|
:param entities: a sequence of entities and/or SQL expressions.
|
|
:param session: a :class:`.Session` with which the
|
:class:`_query.Query`
|
will be associated. Optional; a :class:`_query.Query`
|
can be associated
|
with a :class:`.Session` generatively via the
|
:meth:`_query.Query.with_session` method as well.
|
|
.. seealso::
|
|
:meth:`.Session.query`
|
|
:meth:`_query.Query.with_session`
|
|
N)r Ú _set_entities)r r r r~ r~ r Ú__init__ë s %zQuery.__init__zMapping[str, Any]rJ )Úvaluesr c C s t |¡| _| S r )r Z immutabledictr )r r r~ r~ r Ú_set_propagate_attrs s zQuery._set_propagate_attrsz%Iterable[_ColumnsClauseArgument[Any]]ÚNone)r r c s fddt |¡D _d S )Nc s g | ]}t jtj| d dqS )T©Úapply_propagate_attrsZ post_inspect©r1 Úexpectr3 ÚColumnsClauseRole)Ú.0Úentr r~ r Ú
|
<listcomp> s úüz'Query._set_entities.<locals>.<listcomp>)r Zto_listÚ _raw_columns©r r r~ r r r s
|
ùzQuery._set_entitiesz Query[_O]zQuery[Tuple[_O]])r r c C s
|
| d¡S )a¢ return a tuple-typed form of this :class:`.Query`.
|
|
This method invokes the :meth:`.Query.only_return_tuples`
|
method with a value of ``True``, which by itself ensures that this
|
:class:`.Query` will always return :class:`.Row` objects, even
|
if the query is made against a single entity. It then also
|
at the typing level will return a "typed" query, if possible,
|
that will type result rows as ``Tuple`` objects with typed
|
elements.
|
|
This method can be compared to the :meth:`.Result.tuples` method,
|
which returns "self", but from a typing perspective returns an object
|
that will yield typed ``Tuple`` objects for results. Typing
|
takes effect only if this :class:`.Query` object is a typed
|
query object already.
|
|
.. versionadded:: 2.0
|
|
.. seealso::
|
|
:meth:`.Result.tuples` - v2 equivalent method.
|
|
T)Úonly_return_tuplesr r~ r~ r Útuples$ s z Query.tuplesz"Optional[_InternalEntityType[Any]]c C sl | j s
|
d S | j d }d|jkr(|jd S d|jkr<|jd S t |¡D ] }d|jkrF|jd S qFd S d S )Nr Ú parententityZbundle)rª Ú _annotationsr5 Ziterate)r r¨ Úelementr~ r~ r Ú_entity_from_pre_ent_zero> s
|
|
|
|
|
|
z Query._entity_from_pre_ent_zeroÚstrz Mapper[Any])Úmethnamer c C sH t | jdks*d| jd jks*| jd js8t d| ¡| jd jd S )Nr r® r z4%s() can only be used against a single mapped class.)Úlenrª r¯ Z is_selectableÚsa_excÚInvalidRequestError)r r³ r~ r~ r Ú_only_full_mapper_zeroP s ÿþ
|
ýÿÿz Query._only_full_mapper_zeroz Iterable[_FromClauseArgument])ÚobjÚset_base_aliasr c s2 fdd|D } j d|i7 _ t| _d S )Nc s g | ]}t jtj|d dqS )T)Z allow_selectr£ )r1 r¥ r3 ZStrictFromClauseRole)r§ Úelemr r~ r r© ` s úüz*Query._set_select_from.<locals>.<listcomp>Ú_set_base_alias)r Útupler )r r¸ r¹ Úfar~ r r Ú_set_select_from] s
|
|
ù
|
zQuery._set_select_fromzInstanceState[Any])Ústater c C s | j d|i7 _ | S )NÚ_lazy_loaded_from©Ú load_options)r r¿ r~ r~ r Ú_set_lazyload_fromm s zQuery._set_lazyload_fromc C s | j dddd dS )zused by legacy BakedQueryÚgetF©Úorder_byÚdistinctN)Ú_no_criterion_conditionr r~ r~ r Ú_get_conditionr s zQuery._get_conditionc C s | j dddd d S )NrÄ FrÅ )Ú_no_criterion_assertionr r~ r~ r Ú_get_existing_conditionv s z Query._get_existing_condition)ÚmethrÆ rÇ r c C sf | j s
|
d S | jsT| jd k sT| jsT| jsT| jd k sT| jd k sT| jsT|rJ| jsT|rb| j rbt
|
d| ¡d S ©Nz<Query.%s() being called on a Query with existing criterion. ) Ú_enable_assertionsr r r r r r r r r rµ r¶ ©r rÌ rÆ rÇ r~ r~ r rÊ y s: ÿþýüûúùøø ÷ ÷ ÿÿz Query._no_criterion_assertionc C sR | |||¡ d | _| _| jd k r6| jdd i7 _d| _d| _d | _| _d S )Nr~ r F) rÊ r r r r r r r r rÏ r~ r~ r rÈ s
|
z Query._no_criterion_condition)rÌ r c C s, | j s
|
d S | jr t d| ¡| |¡ d S rÍ )rÎ r rµ r¶ rÈ ©r rÌ r~ r~ r Ú_no_clauseelement_condition s ÿÿz!Query._no_clauseelement_conditionc C s& | j s
|
d S | jd k r"t d| ¡d S )Nz[Query.%s() being called on a Query with an existing full statement - can't apply criterion.)rÎ r rµ r¶ rÐ r~ r~ r Ú_no_statement_condition¥ s
|
üÿz Query._no_statement_conditionc C s4 | j s
|
d S | jd k s | jd k r0t d||f ¡d S )NzQuery.%s() being called on a Query which already has LIMIT or OFFSET applied. Call %s() before limit() or offset() are applied.)rÎ r r rµ r¶ rÐ r~ r~ r Ú_no_limit_offset± s þÿzQuery._no_limit_offsetc C s | j d k p| jd k S r )r r r r~ r~ r Ú_has_row_limiting_clause» s ÿz Query._has_row_limiting_clausezOptional[bool]zOptional[Sequence[str]]z Optional[InstanceState[Any]]z Optional[Any])Úpopulate_existingÚ version_checkÚonly_load_propsÚ refresh_stateÚidentity_tokenr c C sx i }i }|r||d< |r ||d< |r4||d< d|d< |rDt ||d< |rP||d< |rb| j|7 _|rt| j|7 _| S )NZ_version_checkÚ_populate_existingZ_refresh_stateTZ_for_refresh_stateZ_only_load_propsZ_identity_token)Ú frozensetr r )r rÕ rÖ r× rØ rÙ r Úcompile_optionsr~ r~ r Ú _get_optionsÁ s$ zQuery._get_optionsr )Úkwr c K s | ¡ S r )Ú _generate)r rÞ r~ r~ r Ú_cloneß s z Query._cloneú
|
Select[_T]c C s | j d k rt d¡td| jS )Nz<Can't call this method on a Query that uses from_statement()rá )r rµ r¶ r Ú statementr r~ r~ r Ú_get_select_statement_onlyâ s
|
|
ÿz Query._get_select_statement_onlyz$Union[Select[_T], FromStatement[_T]]c C s: | j js| jdd}n| jddj}| jr6| | j¡}|S )z×The full SELECT statement represented by this Query.
|
|
The statement by default will not have disambiguating labels
|
applied to the construct unless with_labels(True) is called
|
first.
|
|
T©Ú for_statement)r r» Ú _statement_20Ú_compile_staterâ r Úparams)r Ústmtr~ r~ r râ é s zQuery.statementz Select[Any])Úlegacy_query_styler c C s | ¡ }|j|djS )a8 Return the 'final' SELECT statement for this :class:`.Query`.
|
|
This is used by the testing suite only and is fairly inefficient.
|
|
This is the Core-only select() that will be rendered by a complete
|
compilation of this query, and is what .statement used to return
|
in 1.3.
|
|
|
)Úuse_legacy_query_style)rà rç râ )r rê Úqr~ r~ r Ú_final_statement s ÿzQuery._final_statement)rå rë r c C sê | j jrJ| j jD ]8}|| }|d k r|| k r|} |js| jddi7 _q| j}|||d7 }| jd k rt| j| j}|jj| j | j
|
|| j | j d n2t jf | j}|jj| j|| j d |j dd ¡ d|j kræ|j dd d ¡|_ |S )
|
NÚ_bake_okF)Ú_for_statementZ_use_legacy_query_style)r Ú_with_context_optionsr Ú_execution_optionsr )r r r r Úcompile_state_pluginÚorm)rò Zplugin_subject)r Zbefore_compilerî r r r rª Ú__dict__Úupdater rð rñ r r4 Z_create_raw_selectr ÚpopÚunion)r rå rë ÚfnÚ new_queryrÜ ré r~ r~ r ræ $ sB þ
|
û ý
|
ÿzQuery._statement_20z Optional[str]rz )ÚnameÚ with_labelsÚreduce_columnsr c C sJ | d¡}|r| t¡}| ¡ }tr2t|ts2t|r>| ¡ }|j |dS )aî Return the full SELECT statement represented by
|
this :class:`_query.Query`, embedded within an
|
:class:`_expression.Alias`.
|
|
Eager JOIN generation within the query is disabled.
|
|
.. seealso::
|
|
:meth:`_sql.Select.subquery` - v2 comparable method.
|
|
:param name: string name to be assigned as the alias;
|
this is passed through to :meth:`_expression.FromClause.alias`.
|
If ``None``, a name will be deterministically generated
|
at compile time.
|
|
:param with_labels: if True, :meth:`.with_labels` will be called
|
on the :class:`_query.Query` first to apply table-qualified labels
|
to all columns.
|
|
:param reduce_columns: if True,
|
:meth:`_expression.Select.reduce_columns` will
|
be called on the resulting :func:`_expression.select` construct,
|
to remove same-named columns where one also refers to the other
|
via foreign key or WHERE clause equivalence.
|
|
F)rú )
|
Úenable_eagerloadsÚset_label_stylerG rã r Ú
|
isinstancer4 ÚAssertionErrorrü Úsubquery)r rú rû rü rì ré r~ r~ r r X s
|
|
zQuery.subqueryrv )rú Ú recursiveÚnestingr c C s | d¡ ¡ j|||dS )a\ Return the full SELECT statement represented by this
|
:class:`_query.Query` represented as a common table expression (CTE).
|
|
Parameters and usage are the same as those of the
|
:meth:`_expression.SelectBase.cte` method; see that method for
|
further details.
|
|
Here is the `PostgreSQL WITH
|
RECURSIVE example
|
<https://www.postgresql.org/docs/current/static/queries-with.html>`_.
|
Note that, in this example, the ``included_parts`` cte and the
|
``incl_alias`` alias of it are Core selectables, which
|
means the columns are accessed via the ``.c.`` attribute. The
|
``parts_alias`` object is an :func:`_orm.aliased` instance of the
|
``Part`` entity, so column-mapped attributes are available
|
directly::
|
|
from sqlalchemy.orm import aliased
|
|
class Part(Base):
|
__tablename__ = 'part'
|
part = Column(String, primary_key=True)
|
sub_part = Column(String, primary_key=True)
|
quantity = Column(Integer)
|
|
included_parts = session.query(
|
Part.sub_part,
|
Part.part,
|
Part.quantity).\
|
filter(Part.part=="our part").\
|
cte(name="included_parts", recursive=True)
|
|
incl_alias = aliased(included_parts, name="pr")
|
parts_alias = aliased(Part, name="p")
|
included_parts = included_parts.union_all(
|
session.query(
|
parts_alias.sub_part,
|
parts_alias.part,
|
parts_alias.quantity).\
|
filter(parts_alias.part==incl_alias.c.sub_part)
|
)
|
|
q = session.query(
|
included_parts.c.sub_part,
|
func.sum(included_parts.c.quantity).
|
label('total_quantity')
|
).\
|
group_by(included_parts.c.sub_part)
|
|
.. seealso::
|
|
:meth:`_sql.Select.cte` - v2 equivalent method.
|
|
F)rú r r )rý rã Úcte)r rú r r r~ r~ r r
s = þÿz Query.ctez
|
Label[Any])rú r c C s | d¡ ¡ |¡S )zùReturn the full SELECT statement represented by this
|
:class:`_query.Query`, converted
|
to a scalar subquery with a label of the given name.
|
|
.. seealso::
|
|
:meth:`_sql.Select.label` - v2 comparable method.
|
|
F)rý rã Úlabel)r rú r~ r~ r r Ç s þÿz Query.labelzQuery[Tuple[_MAYBE_ENTITY]]zScalarSelect[_MAYBE_ENTITY]c C s d S r r~ r r~ r~ r Ú as_scalarØ s zQuery.as_scalarzQuery[Tuple[_NOT_ENTITY]]zScalarSelect[_NOT_ENTITY]c C s d S r r~ r r~ r~ r r Þ s zScalarSelect[Any]c C s d S r r~ r r~ r~ r r ä s ú1.4zThe :meth:`_query.Query.as_scalar` method is deprecated and will be removed in a future release. Please refer to :meth:`_query.Query.scalar_subquery`.c C s | ¡ S )z}Return the full SELECT statement represented by this
|
:class:`_query.Query`, converted to a scalar subquery.
|
|
)Úscalar_subqueryr r~ r~ r r è s c C s d S r r~ r r~ r~ r r õ s zQuery.scalar_subqueryc C s d S r r~ r r~ r~ r r û s c C s d S r r~ r r~ r~ r r s c C s | d¡ ¡ ¡ S )aÈ Return the full SELECT statement represented by this
|
:class:`_query.Query`, converted to a scalar subquery.
|
|
Analogous to
|
:meth:`sqlalchemy.sql.expression.SelectBase.scalar_subquery`.
|
|
.. versionchanged:: 1.4 The :meth:`_query.Query.scalar_subquery`
|
method replaces the :meth:`_query.Query.as_scalar` method.
|
|
.. seealso::
|
|
:meth:`_sql.Select.scalar_subquery` - v2 comparable method.
|
|
F)rý rã r r r~ r~ r r s ÿc C s | ¡ S )z÷Return the :class:`_expression.Select` object emitted by this
|
:class:`_query.Query`.
|
|
Used for :func:`_sa.inspect` compatibility, this is equivalent to::
|
|
query.enable_eagerloads(False).with_labels().statement
|
|
)Ú__clause_element__r r~ r~ r Ú
|
selectable s
|
zQuery.selectablec C s | j ddd t¡jS )NFT)Ú_enable_eagerloadsZ_render_for_subquery)Ú_with_compile_optionsrþ rG râ r r~ r~ r r ' s ÿýÿzQuery.__clause_element__z Literal[True]z RowReturningQuery[Tuple[_O]])r Úvaluer c C s d S r r~ ©r r r~ r~ r r¬ 0 s zQuery.only_return_tupleszLiteral[False]c C s d S r r~ r r~ r~ r r¬ 6 s ú
|
Query[Any])r r c C s | j t|d7 _ | S )að When set to True, the query results will always be a
|
:class:`.Row` object.
|
|
This can change a query that normally returns a single entity
|
as a scalar to return a :class:`.Row` result in all cases.
|
|
.. seealso::
|
|
:meth:`.Query.tuples` - returns tuples, but also at the typing
|
level will type results as ``Tuple``.
|
|
:meth:`_query.Query.is_single_entity`
|
|
:meth:`_engine.Result.tuples` - v2 comparable method.
|
|
)Ú_only_return_tuples)r Údictr r~ r~ r r¬ < s c C s> | j j o<t| jdko<d| jd jko<t| jd jd tS )a Indicates if this :class:`_query.Query`
|
returns tuples or single entities.
|
|
Returns True if this query returns a single entity for each instance
|
in its result list, and False if this query returns a tuple of entities
|
for each result.
|
|
.. versionadded:: 1.3.11
|
|
.. seealso::
|
|
:meth:`_query.Query.only_return_tuples`
|
|
r r® r )r r r´ rª r¯ rÿ r# r r~ r~ r Úis_single_entityQ s
|
ÿþþüzQuery.is_single_entityc C s | j d|i7 _ | S )a Control whether or not eager joins and subqueries are
|
rendered.
|
|
When set to False, the returned Query will not render
|
eager joins regardless of :func:`~sqlalchemy.orm.joinedload`,
|
:func:`~sqlalchemy.orm.subqueryload` options
|
or mapper-level ``lazy='joined'``/``lazy='subquery'``
|
configurations.
|
|
This is used primarily when nesting the Query's
|
statement into a subquery or other
|
selectable, or when using :meth:`_query.Query.yield_per`.
|
|
r ©r r r~ r~ r rý k s zQuery.enable_eagerloads)Úoptr c K s | j |7 _ | S r r ©r r r~ r~ r r ~ s zQuery._with_compile_optionszB:meth:`_orm.Query.with_labels` and :meth:`_orm.Query.apply_labels`z<Use set_label_style(LABEL_STYLE_TABLENAME_PLUS_COL) instead.)Ú alternativec C s | tj¡S r )rþ rH rG r r~ r~ r rû s ÿzQuery.with_labelsc C s | j S )z²
|
Retrieve the current label style.
|
|
.. versionadded:: 1.4
|
|
.. seealso::
|
|
:meth:`_sql.Select.get_label_style` - v2 equivalent method.
|
|
)r r r~ r~ r Úget_label_style s zQuery.get_label_style)Ústyler c C s | j |k r| ¡ } || _ | S )að Apply column labels to the return value of Query.statement.
|
|
Indicates that this Query's `statement` accessor should return
|
a SELECT statement that applies labels to all columns in the
|
form <tablename>_<columnname>; this is commonly used to
|
disambiguate columns from multiple tables which have the same
|
name.
|
|
When the `Query` actually issues SQL to load rows, it always
|
uses column labeling.
|
|
.. note:: The :meth:`_query.Query.set_label_style` method *only* applies
|
the output of :attr:`_query.Query.statement`, and *not* to any of
|
the result-row invoking systems of :class:`_query.Query` itself,
|
e.g.
|
:meth:`_query.Query.first`, :meth:`_query.Query.all`, etc.
|
To execute
|
a query using :meth:`_query.Query.set_label_style`, invoke the
|
:attr:`_query.Query.statement` using :meth:`.Session.execute`::
|
|
result = session.execute(
|
query
|
.set_label_style(LABEL_STYLE_TABLENAME_PLUS_COL)
|
.statement
|
)
|
|
.. versionadded:: 1.4
|
|
|
.. seealso::
|
|
:meth:`_sql.Select.set_label_style` - v2 equivalent method.
|
|
)r rß )r r r~ r~ r rþ s #
|
zQuery.set_label_stylec C s
|
|| _ | S )a Control whether assertions are generated.
|
|
When set to False, the returned Query will
|
not assert its state before certain operations,
|
including that LIMIT/OFFSET has not been applied
|
when filter() is called, no criterion exists
|
when get() is called, and no "from_statement()"
|
exists when filter()/order_by()/group_by() etc.
|
is called. This more permissive mode is used by
|
custom Query subclasses to specify criterion or
|
other modifiers outside of the usual usage patterns.
|
|
Care should be taken to ensure that the usage
|
pattern is even possible. A statement applied
|
by from_statement() will override any criterion
|
set by filter() or order_by(), for example.
|
|
)rÎ r r~ r~ r Úenable_assertionsÅ s zQuery.enable_assertionsz Optional[ColumnElement[bool]]c C s t | j¡S )a3 A readonly attribute which returns the current WHERE criterion for
|
this Query.
|
|
This returned value is a SQL expression construct, or ``None`` if no
|
criterion has been established.
|
|
.. seealso::
|
|
:attr:`_sql.Select.whereclause` - v2 equivalent property.
|
|
)r? Z_construct_for_whereclauser r r~ r~ r Ú whereclauseÜ s ÿzQuery.whereclauserP )Úpathr c C s | j d|i7 _ | S )a indicate that this query applies to objects loaded
|
within a certain path.
|
|
Used by deferred loaders (see strategies.py) which transfer
|
query options from an originating query to a newly generated
|
query intended for the deferred load.
|
|
Ú _current_pathr )r r r~ r~ r Ú_with_current_pathí s
|
zQuery._with_current_pathÚint)Úcountr c C s | j d|i7 _ | S )a¡ Yield only ``count`` rows at a time.
|
|
The purpose of this method is when fetching very large result sets
|
(> 10K rows), to batch results in sub-collections and yield them
|
out partially, so that the Python interpreter doesn't need to declare
|
very large areas of memory which is both time consuming and leads
|
to excessive memory use. The performance from fetching hundreds of
|
thousands of rows can often double when a suitable yield-per setting
|
(e.g. approximately 1000) is used, even with DBAPIs that buffer
|
rows (which are most).
|
|
As of SQLAlchemy 1.4, the :meth:`_orm.Query.yield_per` method is
|
equivalent to using the ``yield_per`` execution option at the ORM
|
level. See the section :ref:`orm_queryguide_yield_per` for further
|
background on this option.
|
|
.. seealso::
|
|
:ref:`orm_queryguide_yield_per`
|
|
Ú
|
_yield_perrÁ )r r r~ r~ r Ú yield_perú s zQuery.yield_perz:meth:`_orm.Query.get`z7The method is now available as :meth:`_orm.Session.get`rQ )Úidentr c C s | j dddd | |tj¡S )a® Return an instance based on the given primary key identifier,
|
or ``None`` if not found.
|
|
E.g.::
|
|
my_user = session.query(User).get(5)
|
|
some_object = session.query(VersionedFoo).get((5, 10))
|
|
some_object = session.query(VersionedFoo).get(
|
{"id": 5, "version_id": 10})
|
|
:meth:`_query.Query.get` is special in that it provides direct
|
access to the identity map of the owning :class:`.Session`.
|
If the given primary key identifier is present
|
in the local identity map, the object is returned
|
directly from this collection and no SQL is emitted,
|
unless the object has been marked fully expired.
|
If not present,
|
a SELECT is performed in order to locate the object.
|
|
:meth:`_query.Query.get` also will perform a check if
|
the object is present in the identity map and
|
marked as expired - a SELECT
|
is emitted to refresh the object as well as to
|
ensure that the row is still present.
|
If not, :class:`~sqlalchemy.orm.exc.ObjectDeletedError` is raised.
|
|
:meth:`_query.Query.get` is only used to return a single
|
mapped instance, not multiple instances or
|
individual column constructs, and strictly
|
on a single primary key value. The originating
|
:class:`_query.Query` must be constructed in this way,
|
i.e. against a single mapped entity,
|
with no additional filtering criterion. Loading
|
options via :meth:`_query.Query.options` may be applied
|
however, and will be used if the object is not
|
yet locally present.
|
|
:param ident: A scalar, tuple, or dictionary representing the
|
primary key. For a composite (e.g. multiple column) primary key,
|
a tuple or dictionary should be passed.
|
|
For a single-column primary key, the scalar calling form is typically
|
the most expedient. If the primary key of a row is the value "5",
|
the call looks like::
|
|
my_object = query.get(5)
|
|
The tuple form contains primary key values typically in
|
the order in which they correspond to the mapped
|
:class:`_schema.Table`
|
object's primary key columns, or if the
|
:paramref:`_orm.Mapper.primary_key` configuration parameter were
|
used, in
|
the order used for that parameter. For example, if the primary key
|
of a row is represented by the integer
|
digits "5, 10" the call would look like::
|
|
my_object = query.get((5, 10))
|
|
The dictionary form should include as keys the mapped attribute names
|
corresponding to each element of the primary key. If the mapped class
|
has the attributes ``id``, ``version_id`` as the attributes which
|
store the object's primary key value, the call would look like::
|
|
my_object = query.get({"id": 5, "version_id": 10})
|
|
.. versionadded:: 1.3 the :meth:`_query.Query.get`
|
method now optionally
|
accepts a dictionary of attribute names to values in order to
|
indicate a primary key identifier.
|
|
|
:return: The object instance, or ``None``.
|
|
rÄ FrÅ )rÊ Ú _get_implr Zload_on_pk_identity)r r" r~ r~ r rÄ s Rz Query.getzCallable[..., Any])Úprimary_key_identityÚ
|
db_load_fnrÙ r c
|
C s0 | d¡}| jj|||| jj| j| j|| jdS )NrÄ )rÕ Úwith_for_updateÚoptionsrÙ Úexecution_options)r· r r# r rÚ r r rñ )r r$ r% rÙ Úmapperr~ r~ r r# l s
|
øzQuery._get_implc C s | j jS )a An :class:`.InstanceState` that is using this :class:`_query.Query`
|
for a lazy load operation.
|
|
.. deprecated:: 1.4 This attribute should be viewed via the
|
:attr:`.ORMExecuteState.lazy_loaded_from` attribute, within
|
the context of the :meth:`.SessionEvents.do_orm_execute`
|
event.
|
|
.. seealso::
|
|
:attr:`.ORMExecuteState.lazy_loaded_from`
|
|
)r rÀ r r~ r~ r Úlazy_loaded_from~ s zQuery.lazy_loaded_fromc C s | j jS r )r r r r~ r~ r r s zQuery._current_pathz2Union[Literal[(None, False)], _FromClauseArgument])Ú fromclausesr c G s< d| _ |r |d dkr d| _n| jtdd |D | _| S )a Return a :class:`.Query` construct which will correlate the given
|
FROM clauses to that of an enclosing :class:`.Query` or
|
:func:`~.expression.select`.
|
|
The method here accepts mapped classes, :func:`.aliased` constructs,
|
and :class:`_orm.Mapper` constructs as arguments, which are resolved
|
into expression constructs, in addition to appropriate expression
|
constructs.
|
|
The correlation arguments are ultimately passed to
|
:meth:`_expression.Select.correlate`
|
after coercion to expression constructs.
|
|
The correlation arguments take effect in such cases
|
as when :meth:`_query.Query.from_self` is used, or when
|
a subquery as returned by :meth:`_query.Query.subquery` is
|
embedded in another :func:`_expression.select` construct.
|
|
.. seealso::
|
|
:meth:`_sql.Select.correlate` - v2 equivalent method.
|
|
Fr > NFr~ c s s | ]}t tj|¡V qd S r )r1 r¥ r3 ZFromClauseRole)r§ Úfr~ r~ r Ú <genexpr>´ s z"Query.correlate.<locals>.<genexpr>)r r r¼ )r r+ r~ r~ r Ú correlate s ÿ zQuery.correlate)Úsettingr c C s | j d|i7 _ | S )a? Return a Query with a specific 'autoflush' setting.
|
|
As of SQLAlchemy 1.4, the :meth:`_orm.Query.autoflush` method
|
is equivalent to using the ``autoflush`` execution option at the
|
ORM level. See the section :ref:`orm_queryguide_autoflush` for
|
further background on this option.
|
|
Z
|
_autoflushrÁ )r r/ r~ r~ r Ú autoflush¹ s
|
zQuery.autoflushc C s | j ddi7 _ | S )a¿ Return a :class:`_query.Query`
|
that will expire and refresh all instances
|
as they are loaded, or reused from the current :class:`.Session`.
|
|
As of SQLAlchemy 1.4, the :meth:`_orm.Query.populate_existing` method
|
is equivalent to using the ``populate_existing`` execution option at
|
the ORM level. See the section :ref:`orm_queryguide_populate_existing`
|
for further background on this option.
|
|
rÚ TrÁ r r~ r~ r rÕ Æ s zQuery.populate_existingc C s | j d|i7 _ | S )zêSet the 'invoke all eagers' flag which causes joined- and
|
subquery loaders to traverse into already-loaded related objects
|
and collections.
|
|
Default is that of :attr:`_query.Query._invoke_all_eagers`.
|
|
Z_invoke_all_eagersrÁ r r~ r~ r Ú_with_invoke_all_eagersÕ s z Query._with_invoke_all_eagersz :meth:`_orm.Query.with_parent`z6Use the :func:`_orm.with_parent` standalone construct.z sqlalchemy.orm.relationshipsÚobjectz,Optional[attributes.QueryableAttribute[Any]]z"Optional[_ExternalEntityType[Any]])ÚinstanceÚpropertyÚ from_entityr c C s t jj}|rt|}nt| }|dkrvt|}|jD ]$}t||jr4|j |j kr4|} qvq4t
|
d|j j j |jj f ¡| t|||j¡S )a Add filtering criterion that relates the given instance
|
to a child object or collection, using its attribute state
|
as well as an established :func:`_orm.relationship()`
|
configuration.
|
|
The method uses the :func:`.with_parent` function to generate
|
the clause, the result of which is passed to
|
:meth:`_query.Query.filter`.
|
|
Parameters are the same as :func:`.with_parent`, with the exception
|
that the given property can be None, in which case a search is
|
performed against this :class:`_query.Query` object's target mapper.
|
|
: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.
|
|
Nz\Could not locate a property which relates instances of class '%s' to instances of class '%s')r Z preloadedZorm_relationshipsr) r r% Ziterate_propertiesrÿ ZRelationshipPropertyr) rµ r¶ Úclass_Ú__name__Ú __class__Úfilterr& Úentity)r r3 r4 r5 Z relationshipsZ entity_zeror) Úpropr~ r~ r r& á s6 '
|
|
|
ÿ
|
þþþÿ ýÿzQuery.with_parentz_EntityType[Any]z Optional[Union[Alias, Subquery]])r: Úaliasr c C s< |dk rt ||}t| j| _| j tjtj|| d¡ | S )zadd a mapped entity to the list of result columns
|
to be returned.
|
|
.. seealso::
|
|
:meth:`_sql.Select.add_columns` - v2 comparable method.
|
N©r£ )r$ Úlistrª Úappendr1 r¥ r3 r¦ )r r: r< r~ r~ r Ú
|
add_entity+ s
|
ÿÿzQuery.add_entity)r r c C s
|
|| _ | S )a Return a :class:`_query.Query` that will use the given
|
:class:`.Session`.
|
|
While the :class:`_query.Query`
|
object is normally instantiated using the
|
:meth:`.Session.query` method, it is legal to build the
|
:class:`_query.Query`
|
directly without necessarily using a :class:`.Session`. Such a
|
:class:`_query.Query` object, or any :class:`_query.Query`
|
already associated
|
with a different :class:`.Session`, can produce a new
|
:class:`_query.Query`
|
object associated with a target session using this method::
|
|
from sqlalchemy.orm import Query
|
|
query = Query([MyClass]).filter(MyClass.id == 5)
|
|
result = query.with_session(my_session).one()
|
|
)r )r r r~ r~ r Ú with_sessionF s zQuery.with_sessionz_ColumnsClauseArgument[Any]c G s4 | t¡ d ¡ ¡ ¡ }| |¡}|r0| |¡ |S r )rþ rG r. r Z_anonymous_fromclauseÚ_from_selectabler )r r Ú
|
fromclauserì r~ r~ r Ú_legacy_from_selfa s
|
ÿ
|
ÿ
|
|
zQuery._legacy_from_self)Úvalr c C s | j d|i7 _ | S )NÚ_enable_single_critr )r rE r~ r~ r Ú_set_enable_single_critt s z Query._set_enable_single_critrx )rC Úset_entity_fromr c C s< dD ]}| j |d ¡ q| |g|¡ | jddi7 _| S )N) r r r r r Ú_last_joined_entityr Ú_memoized_select_entitiesr r r Ú _prefixesZ _suffixesrF F)rô rö r¾ r )r rC rH Úattrr~ r~ r rB y s ÿzQuery._from_selectablez:meth:`_query.Query.values` is deprecated and will be removed in a future release. Please use :meth:`_query.Query.with_entities`z Iterable[Any])Úcolumnsr c G s
|
| j | S )zfReturn an iterator yielding result tuples corresponding
|
to the given list of columns
|
|
)Ú_values_no_warn)r rM r~ r~ r r s z Query.valuesc G sF |s t dS | ¡ d¡}| |¡ |jjs>| jddi7 _t |S )Nr~ Fr é
|
)Úiterrà rý r r r )r rM rì r~ r~ r rN £ s
|
zQuery._values_no_warnz°:meth:`_query.Query.value` is deprecated and will be removed in a future release. Please use :meth:`_query.Query.with_entities` in combination with :meth:`_query.Query.scalar`z _ColumnExpressionArgument[Any])Úcolumnr c C s0 zt | |¡d W S tk
|
r* Y dS X dS )zVReturn a scalar result corresponding to the given
|
column expression.
|
|
r N)ÚnextrN Ú StopIteration©r rQ r~ r~ r r ® s z Query.valuez_EntityType[_O])Ú_entityr c C s d S r r~ )r rU r~ r~ r Ú with_entities¿ s zQuery.with_entitiesz roles.TypedColumnsClauseRole[_T]z RowReturningQuery[Tuple[_T]])Ú_colexprr c C s d S r r~ )r rW r~ r~ r rV Ã s z
|
_TCCA[_T0]z
|
_TCCA[_T1]z"RowReturningQuery[Tuple[_T0, _T1]])Ú _Query__ent0Ú _Query__ent1r c C s d S r r~ )r rX rY r~ r~ r rV Ï s z
|
_TCCA[_T2]z'RowReturningQuery[Tuple[_T0, _T1, _T2]])rX rY Ú _Query__ent2r c C s d S r r~ )r rX rY rZ r~ r~ r rV Õ s z
|
_TCCA[_T3]z,RowReturningQuery[Tuple[_T0, _T1, _T2, _T3]])rX rY rZ Ú _Query__ent3r c C s d S r r~ )r rX rY rZ r[ r~ r~ r rV Û s z
|
_TCCA[_T4]z1RowReturningQuery[Tuple[_T0, _T1, _T2, _T3, _T4]])rX rY rZ r[ Ú _Query__ent4r c C s d S r r~ )r rX rY rZ r[ r\ r~ r~ r rV å s z
|
_TCCA[_T5]z6RowReturningQuery[Tuple[_T0, _T1, _T2, _T3, _T4, _T5]])rX rY rZ r[ r\ Ú _Query__ent5r c C s d S r r~ )r rX rY rZ r[ r\ r] r~ r~ r rV ð s
|
z
|
_TCCA[_T6]z;RowReturningQuery[Tuple[_T0, _T1, _T2, _T3, _T4, _T5, _T6]])rX rY rZ r[ r\ r] Ú _Query__ent6r c C s d S r r~ )r rX rY rZ r[ r\ r] r^ r~ r~ r rV ü s z
|
_TCCA[_T7]z@RowReturningQuery[Tuple[_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7]]) rX rY rZ r[ r\ r] r^ Ú _Query__ent7r c C s d S r r~ ) r rX rY rZ r[ r\ r] r^ r_ r~ r~ r rV s c G s d S r r~ r« r~ r~ r rV s )r Ú
|
_Query__kwr c O s" |r
|
t t | ¡ | |¡ | S )a Return a new :class:`_query.Query`
|
replacing the SELECT list with the
|
given entities.
|
|
e.g.::
|
|
# Users, filtered on some arbitrary criterion
|
# and then ordered by related email address
|
q = session.query(User).\
|
join(User.address).\
|
filter(User.name.like('%ed%')).\
|
order_by(Address.email)
|
|
# given *only* User.id==5, Address.email, and 'q', what
|
# would the *next* User in the result be ?
|
subq = q.with_entities(Address.email).\
|
order_by(None).\
|
filter(User.id==5).\
|
subquery()
|
q = q.join((subq, subq.c.email < Address.email)).\
|
limit(1)
|
|
.. seealso::
|
|
:meth:`_sql.Select.with_only_columns` - v2 comparable method.
|
)rb rA Z_generate_for_statementr )r r r` r~ r~ r rV s
|
|
|
c s* t j _ j fdd|D ¡ S )z¼Add one or more column expressions to the list
|
of result columns to be returned.
|
|
.. seealso::
|
|
:meth:`_sql.Select.add_columns` - v2 comparable method.
|
c 3 s" | ]}t jtj| d dV qdS )Tr¢ Nr¤ )r§ Úcr r~ r r- U s úüz$Query.add_columns.<locals>.<genexpr>)r> rª ÚextendrT r~ r r Ú add_columnsG s
|
ù zQuery.add_columnsz:meth:`_query.Query.add_column` is deprecated and will be removed in a future release. Please use :meth:`_query.Query.add_columns`c C s
|
| |¡S )zWAdd a column expression to the list of result columns to be
|
returned.
|
|
)rc rT r~ r~ r Ú
|
add_column` s zQuery.add_columnrp )Úargsr c G sj t t |¡}| jjr8|D ]}|js|jr| | ¡ qn |D ]}|js<|jr<| | ¡ q<| j |7 _ | S )aK Return a new :class:`_query.Query` object,
|
applying the given list of
|
mapper options.
|
|
Most supplied options regard changing how column- and
|
relationship-mapped attributes are loaded.
|
|
.. seealso::
|
|
:ref:`loading_columns`
|
|
:ref:`relationship_loader_options`
|
|
)
|
r¼ r Zflatten_iteratorr r Z_is_coreZ_is_legacy_optionZprocess_query_conditionallyZ process_queryr )r re Úoptsr r~ r~ r r' m s z Query.optionsz"Callable[[Query[Any]], Query[Any]])rø r c C s || S )aª Return a new :class:`_query.Query` object transformed by
|
the given function.
|
|
E.g.::
|
|
def filter_something(criterion):
|
def transform(q):
|
return q.filter(criterion)
|
return transform
|
|
q = q.with_transformation(filter_something(x==5))
|
|
This allows ad-hoc recipes to be created for :class:`_query.Query`
|
objects.
|
|
r~ )r rø r~ r~ r Úwith_transformation s zQuery.with_transformationrU c C s | j S )a Get the non-SQL options which will take effect during execution.
|
|
.. versionadded:: 1.3
|
|
.. seealso::
|
|
:meth:`_query.Query.execution_options`
|
|
:meth:`_sql.Select.get_execution_options` - v2 comparable method.
|
|
)rñ r r~ r~ r Úget_execution_options¡ s zQuery.get_execution_options.) Úcompiled_cacheÚ logging_tokenÚisolation_levelÚ no_parametersÚstream_resultsÚmax_row_bufferr! Úinsertmanyvalues_page_sizeÚschema_translate_maprÕ r0 zOptional[CompiledCacheType]rW z Optional[SchemaTranslateMapType]) ri rj rk rl rm rn r! ro rp rÕ r0 r r c K s d S r r~ ) r ri rj rk rl rm rn r! ro rp rÕ r0 r r~ r~ r r( ¯ s zQuery.execution_optionsc K s d S r r~ r r~ r~ r r( Â s )Úkwargsr c K s | j |¡| _ | S )a Set non-SQL options which take effect during execution.
|
|
Options allowed here include all of those accepted by
|
:meth:`_engine.Connection.execution_options`, as well as a series
|
of ORM specific options:
|
|
``populate_existing=True`` - equivalent to using
|
:meth:`_orm.Query.populate_existing`
|
|
``autoflush=True|False`` - equivalent to using
|
:meth:`_orm.Query.autoflush`
|
|
``yield_per=<value>`` - equivalent to using
|
:meth:`_orm.Query.yield_per`
|
|
Note that the ``stream_results`` execution option is enabled
|
automatically if the :meth:`~sqlalchemy.orm.query.Query.yield_per()`
|
method or execution option is used.
|
|
.. versionadded:: 1.4 - added ORM options to
|
:meth:`_orm.Query.execution_options`
|
|
The execution options may also be specified on a per execution basis
|
when using :term:`2.0 style` queries via the
|
:paramref:`_orm.Session.execution_options` parameter.
|
|
.. warning:: The
|
:paramref:`_engine.Connection.execution_options.stream_results`
|
parameter should not be used at the level of individual ORM
|
statement executions, as the :class:`_orm.Session` will not track
|
objects from different schema translate maps within a single
|
session. For multiple schema translate maps within the scope of a
|
single :class:`_orm.Session`, see :ref:`examples_sharding`.
|
|
|
.. seealso::
|
|
:ref:`engine_stream_results`
|
|
:meth:`_query.Query.get_execution_options`
|
|
:meth:`_sql.Select.execution_options` - v2 equivalent method.
|
|
)rñ r÷ )r rq r~ r~ r r( Æ s .)ÚnowaitÚreadÚofÚ skip_lockedÚ key_sharezYOptional[Union[_ColumnExpressionArgument[Any], Sequence[_ColumnExpressionArgument[Any]]]])rr rs rt ru rv r c C s t |||||d| _| S )aÎ return a new :class:`_query.Query`
|
with the specified options for the
|
``FOR UPDATE`` clause.
|
|
The behavior of this method is identical to that of
|
:meth:`_expression.GenerativeSelect.with_for_update`.
|
When called with no arguments,
|
the resulting ``SELECT`` statement will have a ``FOR UPDATE`` clause
|
appended. When additional arguments are specified, backend-specific
|
options such as ``FOR UPDATE NOWAIT`` or ``LOCK IN SHARE MODE``
|
can take effect.
|
|
E.g.::
|
|
q = sess.query(User).populate_existing().with_for_update(nowait=True, of=User)
|
|
The above query on a PostgreSQL backend will render like::
|
|
SELECT users.id AS users_id FROM users FOR UPDATE OF users NOWAIT
|
|
.. warning::
|
|
Using ``with_for_update`` in the context of eager loading
|
relationships is not officially supported or recommended by
|
SQLAlchemy and may not work with certain queries on various
|
database backends. When ``with_for_update`` is successfully used
|
with a query that involves :func:`_orm.joinedload`, SQLAlchemy will
|
attempt to emit SQL that locks all involved tables.
|
|
.. note:: It is generally a good idea to combine the use of the
|
:meth:`_orm.Query.populate_existing` method when using the
|
:meth:`_orm.Query.with_for_update` method. The purpose of
|
:meth:`_orm.Query.populate_existing` is to force all the data read
|
from the SELECT to be populated into the ORM objects returned,
|
even if these objects are already in the :term:`identity map`.
|
|
.. seealso::
|
|
:meth:`_expression.GenerativeSelect.with_for_update`
|
- Core level method with
|
full argument and behavioral description.
|
|
:meth:`_orm.Query.populate_existing` - overwrites attributes of
|
objects already loaded in the identity map.
|
|
)rs rr rt ru rv )rC r )r rr rs rt ru rv r~ r~ r r& ÷ s >ûzQuery.with_for_updatezOptional[Dict[str, Any]])Ú_Query__paramsrÞ r c K s |r| |¡ | j |¡| _| S )a Add values for bind parameters which may have been
|
specified in filter().
|
|
Parameters may be specified using \**kwargs, or optionally a single
|
dictionary as the first positional argument. The reason for both is
|
that \**kwargs is convenient, however some parameter dictionaries
|
contain unicode keys in which case \**kwargs cannot be used.
|
|
)rõ r r÷ )r rw rÞ r~ r~ r rè > s
|
z Query.paramsz _ColumnExpressionArgument[bool])Ú criterionr c G s
|
| j | S )z¢A synonym for :meth:`.Query.filter`.
|
|
.. versionadded:: 1.4
|
|
.. seealso::
|
|
:meth:`_sql.Select.where` - v2 equivalent method.
|
|
)r9 )r rx r~ r~ r ÚwhereP s
|
z Query.wherec G s4 t |D ]&}tjtj|| d}| j|f7 _q| S )a` Apply the given filtering criterion to a copy
|
of this :class:`_query.Query`, using SQL expressions.
|
|
e.g.::
|
|
session.query(MyClass).filter(MyClass.name == 'some name')
|
|
Multiple criteria may be specified as comma separated; the effect
|
is that they will be joined together using the :func:`.and_`
|
function::
|
|
session.query(MyClass).\
|
filter(MyClass.name == 'some name', MyClass.id > 5)
|
|
The criterion is any SQL expression object applicable to the
|
WHERE clause of a select. String expressions are coerced
|
into SQL expression constructs via the :func:`_expression.text`
|
construct.
|
|
.. seealso::
|
|
:meth:`_query.Query.filter_by` - filter on keyword expressions.
|
|
:meth:`_sql.Select.where` - v2 equivalent method.
|
|
r= )r> r1 r¥ r3 ÚWhereHavingRoler )r rx Úcritr~ r~ r r9 \ s ÿz Query.filterz=Optional[Union[_InternalEntityType[Any], _JoinTargetElement]]c C s | j rt| j S d S d S r )r r r r~ r~ r rI s
|
ÿzQuery._last_joined_entityc C s: | j r| j}|dk r|S | jr0| jjs0| jd S | jd S )zfor the filter_by() method, return the target entity for which
|
we will attempt to derive an expression from based on string name.
|
|
Nr )r rI r r r» rª )r rI r~ r~ r Ú_filter_by_zero s
|
zQuery._filter_by_zeroc s( | ¡ fdd| ¡ D }| j| S )a Apply the given filtering criterion to a copy
|
of this :class:`_query.Query`, using keyword expressions.
|
|
e.g.::
|
|
session.query(MyClass).filter_by(name = 'some name')
|
|
Multiple criteria may be specified as comma separated; the effect
|
is that they will be joined together using the :func:`.and_`
|
function::
|
|
session.query(MyClass).\
|
filter_by(name = 'some name', id = 5)
|
|
The keyword expressions are extracted from the primary
|
entity of the query, or the last entity that was the
|
target of a call to :meth:`_query.Query.join`.
|
|
.. seealso::
|
|
:meth:`_query.Query.filter` - filter on SQL expressions.
|
|
:meth:`_sql.Select.filter_by` - v2 comparable method.
|
|
c s g | ]\}}t ||kqS r~ r9 )r§ Úkeyr ©r5 r~ r r© Ò s ÿz#Query.filter_by.<locals>.<listcomp>)r| Úitemsr9 )r rq Úclausesr~ r~ r Ú filter_by¶ s
|
|
þzQuery.filter_byzTUnion[Literal[None, False, _NoArg.NO_ARG], _ColumnExpressionOrStrLabelArgument[Any]]z(_ColumnExpressionOrStrLabelArgument[Any])Ú _Query__firstr r c G sj | j | jfD ] }|d q |s6|dks.|dkr6d| _n0|tjk rftdd |f| D }| j|7 _| S )aô Apply one or more ORDER BY criteria to the query and return
|
the newly resulting :class:`_query.Query`.
|
|
e.g.::
|
|
q = session.query(Entity).order_by(Entity.id, Entity.name)
|
|
Calling this method multiple times is equivalent to calling it once
|
with all the clauses concatenated. All existing ORDER BY criteria may
|
be cancelled by passing ``None`` by itself. New ORDER BY criteria may
|
then be added by invoking :meth:`_orm.Query.order_by` again, e.g.::
|
|
# will erase all ORDER BY and ORDER BY new_col alone
|
q = q.order_by(None).order_by(new_col)
|
|
.. seealso::
|
|
These sections describe ORDER BY in terms of :term:`2.0 style`
|
invocation but apply to :class:`_orm.Query` as well:
|
|
:ref:`tutorial_order_by` - in the :ref:`unified_tutorial`
|
|
:ref:`tutorial_order_by_label` - in the :ref:`unified_tutorial`
|
|
:meth:`_sql.Select.order_by` - v2 equivalent method.
|
|
rÆ NFr~ c s s | ]}t tj|¡V qd S r )r1 r¥ r3 Z OrderByRole©r§ Úclauser~ r~ r r- s ÿz!Query.order_by.<locals>.<genexpr>)rÒ rÓ r r< ÚNO_ARGr¼ ©r r r Z assertionrx r~ r~ r rÆ Ø s %
|
|
þzQuery.order_byc G sj | j | jfD ] }|d q |s6|dks.|dkr6d| _n0|tjk rftdd |f| D }| j|7 _| S )aª Apply one or more GROUP BY criterion to the query and return
|
the newly resulting :class:`_query.Query`.
|
|
All existing GROUP BY settings can be suppressed by
|
passing ``None`` - this will suppress any GROUP BY configured
|
on mappers as well.
|
|
.. seealso::
|
|
These sections describe GROUP BY in terms of :term:`2.0 style`
|
invocation but apply to :class:`_orm.Query` as well:
|
|
:ref:`tutorial_group_by_w_aggregates` - in the
|
:ref:`unified_tutorial`
|
|
:ref:`tutorial_order_by_label` - in the :ref:`unified_tutorial`
|
|
:meth:`_sql.Select.group_by` - v2 equivalent method.
|
|
Úgroup_byNFr~ c s s | ]}t tj|¡V qd S r )r1 r¥ r3 Z GroupByRoler r~ r~ r r- / s ÿz!Query.group_by.<locals>.<genexpr>)rÒ rÓ r r< r
r¼ r r~ r~ r r s
|
|
þzQuery.group_by)Úhavingr c G s, |D ]"}t tj|¡}| j|f7 _q| S )ao Apply a HAVING criterion to the query and return the
|
newly resulting :class:`_query.Query`.
|
|
:meth:`_query.Query.having` is used in conjunction with
|
:meth:`_query.Query.group_by`.
|
|
HAVING criterion makes it possible to use filters on aggregate
|
functions like COUNT, SUM, AVG, MAX, and MIN, eg.::
|
|
q = session.query(User.id).\
|
join(User.addresses).\
|
group_by(User.id).\
|
having(func.count(Address.id) > 2)
|
|
.. seealso::
|
|
:meth:`_sql.Select.having` - v2 equivalent method.
|
|
)r1 r¥ r3 rz r )r r rx Zhaving_criteriar~ r~ r r 6 s ÿz Query.having)Úexpr_fnrì r c G s | f| }| || ¡ ¡S r )rB r )r r rì Zlist_of_queriesr~ r~ r Ú_set_opT s
|
z Query._set_op)rì r c G s | j tjf| S )aé Produce a UNION of this Query against one or more queries.
|
|
e.g.::
|
|
q1 = sess.query(SomeClass).filter(SomeClass.foo=='bar')
|
q2 = sess.query(SomeClass).filter(SomeClass.bar=='foo')
|
|
q3 = q1.union(q2)
|
|
The method accepts multiple Query objects so as to control
|
the level of nesting. A series of ``union()`` calls such as::
|
|
x.union(y).union(z).all()
|
|
will nest on each ``union()``, and produces::
|
|
SELECT * FROM (SELECT * FROM (SELECT * FROM X UNION
|
SELECT * FROM y) UNION SELECT * FROM Z)
|
|
Whereas::
|
|
x.union(y, z).all()
|
|
produces::
|
|
SELECT * FROM (SELECT * FROM X UNION SELECT * FROM y UNION
|
SELECT * FROM Z)
|
|
Note that many database backends do not allow ORDER BY to
|
be rendered on a query called within UNION, EXCEPT, etc.
|
To disable all ORDER BY clauses including those configured
|
on mappers, issue ``query.order_by(None)`` - the resulting
|
:class:`_query.Query` object will not render ORDER BY within
|
its SELECT statement.
|
|
.. seealso::
|
|
:meth:`_sql.Select.union` - v2 equivalent method.
|
|
)r r2 r÷ ©r rì r~ r~ r r÷ X s )z Query.unionc G s | j tjf| S )a Produce a UNION ALL of this Query against one or more queries.
|
|
Works the same way as :meth:`~sqlalchemy.orm.query.Query.union`. See
|
that method for usage examples.
|
|
.. seealso::
|
|
:meth:`_sql.Select.union_all` - v2 equivalent method.
|
|
)r r2 Ú union_allr r~ r~ r r s zQuery.union_allc G s | j tjf| S )a Produce an INTERSECT of this Query against one or more queries.
|
|
Works the same way as :meth:`~sqlalchemy.orm.query.Query.union`. See
|
that method for usage examples.
|
|
.. seealso::
|
|
:meth:`_sql.Select.intersect` - v2 equivalent method.
|
|
)r r2 Ú intersectr r~ r~ r r s zQuery.intersectc G s | j tjf| S )a Produce an INTERSECT ALL of this Query against one or more queries.
|
|
Works the same way as :meth:`~sqlalchemy.orm.query.Query.union`. See
|
that method for usage examples.
|
|
.. seealso::
|
|
:meth:`_sql.Select.intersect_all` - v2 equivalent method.
|
|
)r r2 Ú intersect_allr r~ r~ r r s zQuery.intersect_allc G s | j tjf| S )a Produce an EXCEPT of this Query against one or more queries.
|
|
Works the same way as :meth:`~sqlalchemy.orm.query.Query.union`. See
|
that method for usage examples.
|
|
.. seealso::
|
|
:meth:`_sql.Select.except_` - v2 equivalent method.
|
|
)r r2 Úexcept_r r~ r~ r r ª s z Query.except_c G s | j tjf| S )a Produce an EXCEPT ALL of this Query against one or more queries.
|
|
Works the same way as :meth:`~sqlalchemy.orm.query.Query.union`. See
|
that method for usage examples.
|
|
.. seealso::
|
|
:meth:`_sql.Select.except_all` - v2 equivalent method.
|
|
)r r2 Ú
|
except_allr r~ r~ r r · s zQuery.except_all©ÚisouterÚfullr_ zOptional[_OnClauseArgument])ÚtargetÚonclauser r r c C sd t jtj|| dd}|dk r0t jtj|dd}nd}| j||d||dff7 _| j dd¡ | S )a Create a SQL JOIN against this :class:`_query.Query`
|
object's criterion
|
and apply generatively, returning the newly resulting
|
:class:`_query.Query`.
|
|
**Simple Relationship Joins**
|
|
Consider a mapping between two classes ``User`` and ``Address``,
|
with a relationship ``User.addresses`` representing a collection
|
of ``Address`` objects associated with each ``User``. The most
|
common usage of :meth:`_query.Query.join`
|
is to create a JOIN along this
|
relationship, using the ``User.addresses`` attribute as an indicator
|
for how this should occur::
|
|
q = session.query(User).join(User.addresses)
|
|
Where above, the call to :meth:`_query.Query.join` along
|
``User.addresses`` will result in SQL approximately equivalent to::
|
|
SELECT user.id, user.name
|
FROM user JOIN address ON user.id = address.user_id
|
|
In the above example we refer to ``User.addresses`` as passed to
|
:meth:`_query.Query.join` as the "on clause", that is, it indicates
|
how the "ON" portion of the JOIN should be constructed.
|
|
To construct a chain of joins, multiple :meth:`_query.Query.join`
|
calls may be used. The relationship-bound attribute implies both
|
the left and right side of the join at once::
|
|
q = session.query(User).\
|
join(User.orders).\
|
join(Order.items).\
|
join(Item.keywords)
|
|
.. note:: as seen in the above example, **the order in which each
|
call to the join() method occurs is important**. Query would not,
|
for example, know how to join correctly if we were to specify
|
``User``, then ``Item``, then ``Order``, in our chain of joins; in
|
such a case, depending on the arguments passed, it may raise an
|
error that it doesn't know how to join, or it may produce invalid
|
SQL in which case the database will raise an error. In correct
|
practice, the
|
:meth:`_query.Query.join` method is invoked in such a way that lines
|
up with how we would want the JOIN clauses in SQL to be
|
rendered, and each call should represent a clear link from what
|
precedes it.
|
|
**Joins to a Target Entity or Selectable**
|
|
A second form of :meth:`_query.Query.join` allows any mapped entity or
|
core selectable construct as a target. In this usage,
|
:meth:`_query.Query.join` will attempt to create a JOIN along the
|
natural foreign key relationship between two entities::
|
|
q = session.query(User).join(Address)
|
|
In the above calling form, :meth:`_query.Query.join` is called upon to
|
create the "on clause" automatically for us. This calling form will
|
ultimately raise an error if either there are no foreign keys between
|
the two entities, or if there are multiple foreign key linkages between
|
the target entity and the entity or entities already present on the
|
left side such that creating a join requires more information. Note
|
that when indicating a join to a target without any ON clause, ORM
|
configured relationships are not taken into account.
|
|
**Joins to a Target with an ON Clause**
|
|
The third calling form allows both the target entity as well
|
as the ON clause to be passed explicitly. A example that includes
|
a SQL expression as the ON clause is as follows::
|
|
q = session.query(User).join(Address, User.id==Address.user_id)
|
|
The above form may also use a relationship-bound attribute as the
|
ON clause as well::
|
|
q = session.query(User).join(Address, User.addresses)
|
|
The above syntax can be useful for the case where we wish
|
to join to an alias of a particular target entity. If we wanted
|
to join to ``Address`` twice, it could be achieved using two
|
aliases set up using the :func:`~sqlalchemy.orm.aliased` function::
|
|
a1 = aliased(Address)
|
a2 = aliased(Address)
|
|
q = session.query(User).\
|
join(a1, User.addresses).\
|
join(a2, User.addresses).\
|
filter(a1.email_address=='ed@foo.com').\
|
filter(a2.email_address=='ed@bar.com')
|
|
The relationship-bound calling form can also specify a target entity
|
using the :meth:`_orm.PropComparator.of_type` method; a query
|
equivalent to the one above would be::
|
|
a1 = aliased(Address)
|
a2 = aliased(Address)
|
|
q = session.query(User).\
|
join(User.addresses.of_type(a1)).\
|
join(User.addresses.of_type(a2)).\
|
filter(a1.email_address == 'ed@foo.com').\
|
filter(a2.email_address == 'ed@bar.com')
|
|
**Augmenting Built-in ON Clauses**
|
|
As a substitute for providing a full custom ON condition for an
|
existing relationship, the :meth:`_orm.PropComparator.and_` function
|
may be applied to a relationship attribute to augment additional
|
criteria into the ON clause; the additional criteria will be combined
|
with the default criteria using AND::
|
|
q = session.query(User).join(
|
User.addresses.and_(Address.email_address != 'foo@bar.com')
|
)
|
|
.. versionadded:: 1.4
|
|
**Joining to Tables and Subqueries**
|
|
|
The target of a join may also be any table or SELECT statement,
|
which may be related to a target entity or not. Use the
|
appropriate ``.subquery()`` method in order to make a subquery
|
out of a query::
|
|
subq = session.query(Address).\
|
filter(Address.email_address == 'ed@foo.com').\
|
subquery()
|
|
|
q = session.query(User).join(
|
subq, User.id == subq.c.user_id
|
)
|
|
Joining to a subquery in terms of a specific relationship and/or
|
target entity may be achieved by linking the subquery to the
|
entity using :func:`_orm.aliased`::
|
|
subq = session.query(Address).\
|
filter(Address.email_address == 'ed@foo.com').\
|
subquery()
|
|
address_subq = aliased(Address, subq)
|
|
q = session.query(User).join(
|
User.addresses.of_type(address_subq)
|
)
|
|
|
**Controlling what to Join From**
|
|
In cases where the left side of the current state of
|
:class:`_query.Query` is not in line with what we want to join from,
|
the :meth:`_query.Query.select_from` method may be used::
|
|
q = session.query(Address).select_from(User).\
|
join(User.addresses).\
|
filter(User.name == 'ed')
|
|
Which will produce SQL similar to::
|
|
SELECT address.* FROM user
|
JOIN address ON user.id=address.user_id
|
WHERE user.name = :name_1
|
|
.. seealso::
|
|
:meth:`_sql.Select.join` - v2 equivalent method.
|
|
:param \*props: Incoming arguments for :meth:`_query.Query.join`,
|
the props collection in modern use should be considered to be a one
|
or two argument form, either as a single "target" entity or ORM
|
attribute-bound relationship, or as a target entity plus an "on
|
clause" which may be a SQL expression or ORM attribute-bound
|
relationship.
|
|
:param isouter=False: If True, the join used will be a left outer join,
|
just as if the :meth:`_query.Query.outerjoin` method were called.
|
|
:param full=False: render FULL OUTER JOIN; implies ``isouter``.
|
|
T)r£ ÚlegacyN©r r rI )r1 r¥ r3 ZJoinTargetRoleZ OnClauseRoler rô rö )r r r r r Z join_targetZonclause_elementr~ r~ r ÚjoinÄ s2 Fü ÿþüÿ z
|
Query.join)r )r r r r c C s | j ||d|dS )a# Create a left outer join against this ``Query`` object's criterion
|
and apply generatively, returning the newly resulting ``Query``.
|
|
Usage is the same as the ``join()`` method.
|
|
.. seealso::
|
|
:meth:`_sql.Select.outerjoin` - v2 equivalent method.
|
|
T)r r r )r )r r r r r~ r~ r Ú outerjoin¥ s zQuery.outerjoinc C s
|
d| _ | S )aS Return a new :class:`.Query`, where the "join point" has
|
been reset back to the base FROM entities of the query.
|
|
This method is usually used in conjunction with the
|
``aliased=True`` feature of the :meth:`~.Query.join`
|
method. See the example in :meth:`~.Query.join` for how
|
this is used.
|
|
N)rI r r~ r~ r Úreset_joinpoint¸ s zQuery.reset_joinpointr6 )Úfrom_objr c G s | |d¡ | S )aR Set the FROM clause of this :class:`.Query` explicitly.
|
|
:meth:`.Query.select_from` is often used in conjunction with
|
:meth:`.Query.join` in order to control which entity is selected
|
from on the "left" side of the join.
|
|
The entity or selectable object here effectively replaces the
|
"left edge" of any calls to :meth:`~.Query.join`, when no
|
joinpoint is otherwise established - usually, the default "join
|
point" is the leftmost entity in the :class:`~.Query` object's
|
list of entities to be selected.
|
|
A typical example::
|
|
q = session.query(Address).select_from(User).\
|
join(User.addresses).\
|
filter(User.name == 'ed')
|
|
Which produces SQL equivalent to::
|
|
SELECT address.* FROM user
|
JOIN address ON user.id=address.user_id
|
WHERE user.name = :name_1
|
|
:param \*from_obj: collection of one or more entities to apply
|
to the FROM clause. Entities can be mapped classes,
|
:class:`.AliasedClass` objects, :class:`.Mapper` objects
|
as well as core :class:`.FromClause` elements like subqueries.
|
|
.. seealso::
|
|
:meth:`~.Query.join`
|
|
:meth:`.Query.select_entity_from`
|
|
:meth:`_sql.Select.select_from` - v2 equivalent method.
|
|
F)r¾ )r r r~ r~ r Ú select_fromÈ s * zQuery.select_from)Úitemr c C s t | |¡S r )Úorm_utilZ_getitem)r r r~ r~ r Ú __getitem__õ s þzQuery.__getitem__)ÚstartÚstopr c C s t | j| j||¡\| _| _| S )aL Computes the "slice" of the :class:`_query.Query` represented by
|
the given indices and returns the resulting :class:`_query.Query`.
|
|
The start and stop indices behave like the argument to Python's
|
built-in :func:`range` function. This method provides an
|
alternative to using ``LIMIT``/``OFFSET`` to get a slice of the
|
query.
|
|
For example, ::
|
|
session.query(User).order_by(User.id).slice(1, 3)
|
|
renders as
|
|
.. sourcecode:: sql
|
|
SELECT users.id AS users_id,
|
users.name AS users_name
|
FROM users ORDER BY users.id
|
LIMIT ? OFFSET ?
|
(2, 1)
|
|
.. seealso::
|
|
:meth:`_query.Query.limit`
|
|
:meth:`_query.Query.offset`
|
|
:meth:`_sql.Select.slice` - v2 equivalent method.
|
|
)Úsql_utilZ _make_slicer r )r r r¡ r~ r~ r Úsliceû s ' ÿ z Query.slicer` )Úlimitr c C s t |¡| _| S )z¯Apply a ``LIMIT`` to the query and return the newly resulting
|
``Query``.
|
|
.. seealso::
|
|
:meth:`_sql.Select.limit` - v2 equivalent method.
|
|
)r¢ Ú_offset_or_limit_clauser )r r¤ r~ r~ r r¤ '
|
s z Query.limit)Úoffsetr c C s t |¡| _| S )z±Apply an ``OFFSET`` to the query and return the newly resulting
|
``Query``.
|
|
.. seealso::
|
|
:meth:`_sql.Select.offset` - v2 equivalent method.
|
)r¢ r¥ r )r r¦ r~ r~ r r¦ 5
|
s
|
z Query.offset)Úexprr c G s0 |r&d| _ | jtdd |D | _nd| _ | S )aU Apply a ``DISTINCT`` to the query and return the newly resulting
|
``Query``.
|
|
|
.. note::
|
|
The ORM-level :meth:`.distinct` call includes logic that will
|
automatically add columns from the ORDER BY of the query to the
|
columns clause of the SELECT statement, to satisfy the common need
|
of the database backend that ORDER BY columns be part of the SELECT
|
list when DISTINCT is used. These columns *are not* added to the
|
list of columns actually fetched by the :class:`_query.Query`,
|
however,
|
so would not affect results. The columns are passed through when
|
using the :attr:`_query.Query.statement` accessor, however.
|
|
.. deprecated:: 2.0 This logic is deprecated and will be removed
|
in SQLAlchemy 2.0. See :ref:`migration_20_query_distinct`
|
for a description of this use case in 2.0.
|
|
.. seealso::
|
|
:meth:`_sql.Select.distinct` - v2 equivalent method.
|
|
:param \*expr: optional column expressions. When present,
|
the PostgreSQL dialect will render a ``DISTINCT ON (<expressions>)``
|
construct.
|
|
.. deprecated:: 1.4 Using \*expr in other dialects is deprecated
|
and will raise :class:`_exc.CompileError` in a future version.
|
|
Tc s s | ]}t tj|¡V qd S r )r1 r¥ r3 ZByOfRole)r§ Úer~ r~ r r- g
|
s z!Query.distinct.<locals>.<genexpr>)r r r¼ )r r§ r~ r~ r rÇ B
|
s # ÿzQuery.distinctzList[_T]c C s | ¡ ¡ S )a Return the results represented by this :class:`_query.Query`
|
as a list.
|
|
This results in an execution of the underlying SQL statement.
|
|
.. warning:: The :class:`_query.Query` object,
|
when asked to return either
|
a sequence or iterator that consists of full ORM-mapped entities,
|
will **deduplicate entries based on primary key**. See the FAQ for
|
more details.
|
|
.. seealso::
|
|
:ref:`faq_query_deduplicating`
|
|
.. seealso::
|
|
:meth:`_engine.Result.all` - v2 comparable method.
|
|
:meth:`_engine.Result.scalars` - v2 comparable method.
|
)Ú_iterÚallr r~ r~ r rª n
|
s z Query.allrw )râ r c C s t jtj|| d}|| _| S )a Execute the given SELECT statement and return results.
|
|
This method bypasses all internal statement compilation, and the
|
statement is executed without modification.
|
|
The statement is typically either a :func:`_expression.text`
|
or :func:`_expression.select` construct, and should return the set
|
of columns
|
appropriate to the entity class represented by this
|
:class:`_query.Query`.
|
|
.. seealso::
|
|
:meth:`_sql.Select.from_statement` - v2 comparable method.
|
|
r= )r1 r¥ r3 ZSelectStatementRoler )r râ r~ r~ r Úfrom_statement
|
s ÿzQuery.from_statementz Optional[_T]c C s, | j dk r| ¡ ¡ S | d¡ ¡ ¡ S dS )a½ Return the first result of this ``Query`` or
|
None if the result doesn't contain any row.
|
|
first() applies a limit of one within the generated SQL, so that
|
only one primary entity row is generated on the server side
|
(note this may consist of multiple result rows if join-loaded
|
collections are present).
|
|
Calling :meth:`_query.Query.first`
|
results in an execution of the underlying
|
query.
|
|
.. seealso::
|
|
:meth:`_query.Query.one`
|
|
:meth:`_query.Query.one_or_none`
|
|
:meth:`_engine.Result.first` - v2 comparable method.
|
|
:meth:`_engine.Result.scalars` - v2 comparable method.
|
|
Nr )r r© Úfirstr¤ r r~ r~ r r¬
|
s
|
z Query.firstc C s | ¡ ¡ S )aÚ Return at most one result or raise an exception.
|
|
Returns ``None`` if the query selects
|
no rows. Raises ``sqlalchemy.orm.exc.MultipleResultsFound``
|
if multiple object identities are returned, or if multiple
|
rows are returned for a query that returns only scalar values
|
as opposed to full identity-mapped entities.
|
|
Calling :meth:`_query.Query.one_or_none`
|
results in an execution of the
|
underlying query.
|
|
.. seealso::
|
|
:meth:`_query.Query.first`
|
|
:meth:`_query.Query.one`
|
|
:meth:`_engine.Result.one_or_none` - v2 comparable method.
|
|
:meth:`_engine.Result.scalar_one_or_none` - v2 comparable method.
|
|
)r© Ú one_or_noner r~ r~ r r ½
|
s zQuery.one_or_noner| c C s | ¡ ¡ S )aÉ Return exactly one result or raise an exception.
|
|
Raises ``sqlalchemy.orm.exc.NoResultFound`` if the query selects
|
no rows. Raises ``sqlalchemy.orm.exc.MultipleResultsFound``
|
if multiple object identities are returned, or if multiple
|
rows are returned for a query that returns only scalar values
|
as opposed to full identity-mapped entities.
|
|
Calling :meth:`.one` results in an execution of the underlying query.
|
|
.. seealso::
|
|
:meth:`_query.Query.first`
|
|
:meth:`_query.Query.one_or_none`
|
|
:meth:`_engine.Result.one` - v2 comparable method.
|
|
:meth:`_engine.Result.scalar_one` - v2 comparable method.
|
|
)r© Úoner r~ r~ r r® ×
|
s z Query.onec C sB z$| ¡ }t|tjs |W S |d W S tjk
|
r< Y dS X dS )a Return the first element of the first result or None
|
if no rows present. If multiple rows are returned,
|
raises MultipleResultsFound.
|
|
>>> session.query(Item).scalar()
|
<Item>
|
>>> session.query(Item.id).scalar()
|
1
|
>>> session.query(Item.id).filter(Item.id < 0).scalar()
|
None
|
>>> session.query(Item.id, Item.name).scalar()
|
1
|
>>> session.query(func.count(Parent.id)).scalar()
|
20
|
|
This results in an execution of the underlying query.
|
|
.. seealso::
|
|
:meth:`_engine.Result.scalar` - v2 comparable method.
|
|
r N)r® rÿ Úcollections_abcr rµ Z NoResultFound)r Úretr~ r~ r Úscalarï
|
s
|
z Query.scalarz Iterator[_T]c c s: | ¡ }z|E d H W n tk
|
r4 | ¡ Y nX d S r )r© Ú GeneratorExitZ _soft_close)r Úresultr~ r~ r Ú__iter__ s zQuery.__iter__z#Union[ScalarResult[_T], Result[_T]]c C sd | j }| ¡ }| jj||d| jid}|j dd¡rBtd| ¡ }|j dd¡r`| jj s`|
|
¡ }|S )NZ_sa_orm_load_options©r( r Fz
|
Result[_T]Úfiltered) r ræ r ÚexecuterÂ Ú _attributesrÄ r Úscalarsr Úunique)r rè râ r³ r~ r~ r r© s ý ÿþz Query._iterc C sP | ¡ }z | jr | || jj¡nd }W n tjk
|
r@ d }Y nX t| |¡S r )ræ r Ú_get_bind_argsZget_bindrµ ZUnboundExecutionErrorr² Úcompile)r râ Úbindr~ r~ r Ú__str__0 s ÿý
|
z Query.__str__)râ rø rÞ r c K s |f d|i|S )Nr r~ )r râ rø rÞ r~ r~ r r» > s zQuery._get_bind_argszList[ORMColumnDescription]c C s t | ddS )aà Return metadata about the columns which would be
|
returned by this :class:`_query.Query`.
|
|
Format is a list of dictionaries::
|
|
user_alias = aliased(User, name='user2')
|
q = sess.query(User, User.id, user_alias)
|
|
# this expression:
|
q.column_descriptions
|
|
# would return:
|
[
|
{
|
'name':'User',
|
'type':User,
|
'aliased':False,
|
'expr':User,
|
'entity': User
|
},
|
{
|
'name':'id',
|
'type':Integer(),
|
'aliased':False,
|
'expr':User.id,
|
'entity': User
|
},
|
{
|
'name':'user2',
|
'type':User,
|
'aliased':True,
|
'expr':user_alias,
|
'entity': user_alias
|
}
|
]
|
|
.. seealso::
|
|
This API is available using :term:`2.0 style` queries as well,
|
documented at:
|
|
* :ref:`queryguide_inspection`
|
|
* :attr:`.Select.column_descriptions`
|
|
Tr r r r~ r~ r Úcolumn_descriptionsA s 1zQuery.column_descriptionsz2.0zËThe :meth:`_orm.Query.instances` method is deprecated and will be removed in a future release. Use the Select.from_statement() method or aliased() construct in conjunction with Session.execute() instead.úCursorResult[Any]zOptional[QueryContext])Ú result_proxyÚcontextr c C sv |dkr:t jddd | jdd}t||j| j| j| j}t ||¡}|j
|
dd¡r\| ¡ }|j
|
dd¡rr| ¡ }|S ) zhReturn an ORM result given a :class:`_engine.CursorResult` and
|
:class:`.QueryContext`.
|
|
NzÞUsing the Query.instances() method without a context is deprecated and will be disallowed in a future release. Please make use of :meth:`_query.Query.from_statement` for linking ORM results to arbitrary select constructs.r )ÚversionFrä r r¶ )r Zwarn_deprecatedrç r! râ r r r r Ú instancesr¸ rÄ r¹ rº )r rÁ rÂ Ú compile_stater³ r~ r~ r rÄ t s& û û zQuery.instancesz :meth:`_orm.Query.merge_result`zJThe method is superseded by the :func:`_orm.merge_frozen_result` function.)r Zenable_warningszCUnion[FrozenResult[Any], Iterable[Sequence[Any]], Iterable[object]]z'Union[FrozenResult[Any], Iterable[Any]])ÚiteratorÚloadr c C s t | ||¡S )ak Merge a result into this :class:`_query.Query` object's Session.
|
|
Given an iterator returned by a :class:`_query.Query`
|
of the same structure
|
as this one, return an identical iterator of results, with all mapped
|
instances merged into the session using :meth:`.Session.merge`. This
|
is an optimized method which will merge all mapped instances,
|
preserving the structure of the result rows and unmapped columns with
|
less method overhead than that of calling :meth:`.Session.merge`
|
explicitly for each value.
|
|
The structure of the results is determined based on the column list of
|
this :class:`_query.Query` - if these do not correspond,
|
unchecked errors
|
will occur.
|
|
The 'load' argument is the same as that of :meth:`.Session.merge`.
|
|
For an example of how :meth:`_query.Query.merge_result` is used, see
|
the source code for the example :ref:`examples_caching`, where
|
:meth:`_query.Query.merge_result` is used to efficiently restore state
|
from a cache back into a target :class:`.Session`.
|
|
)r Ú merge_result)r rÆ rÇ r~ r~ r rÈ ¢ s &zQuery.merge_resultr@ c C sJ | d¡ t d¡¡ t¡ ¡ d¡}| ¡ }|dk r@| |¡}t
|
|¡S )aØ A convenience method that turns a query into an EXISTS subquery
|
of the form EXISTS (SELECT 1 FROM ... WHERE ...).
|
|
e.g.::
|
|
q = session.query(User).filter(User.name == 'fred')
|
session.query(q.exists())
|
|
Producing SQL similar to::
|
|
SELECT EXISTS (
|
SELECT 1 FROM users WHERE users.name = :name_1
|
) AS anon_1
|
|
The EXISTS construct is usually used in the WHERE clause::
|
|
session.query(User.id).filter(q.exists()).scalar()
|
|
Note that some databases such as SQL Server don't allow an
|
EXISTS expression to be present in the columns clause of a
|
SELECT. To select a simple boolean value based on the exists
|
as a WHERE, use :func:`.literal`::
|
|
from sqlalchemy import literal
|
|
session.query(literal(True)).filter(q.exists()).scalar()
|
|
.. seealso::
|
|
:meth:`_sql.Select.exists` - v2 comparable method.
|
|
FÚ1r N) rý rc r, Úliteral_columnrþ rG rã Zwith_only_columnsr± r Úexists)r ÚinnerZezeror~ r~ r rË Ê s )
|
ÿþüÿ
|
z Query.existsc C s& t j t d¡¡}| |¡ d¡ ¡ S )añ Return a count of rows this the SQL formed by this :class:`Query`
|
would return.
|
|
This generates the SQL for this Query as follows::
|
|
SELECT count(1) AS count_1 FROM (
|
SELECT <rest of query follows...>
|
) AS anon_1
|
|
The above SQL returns a single row, which is the aggregate value
|
of the count function; the :meth:`_query.Query.count`
|
method then returns
|
that single integer value.
|
|
.. warning::
|
|
It is important to note that the value returned by
|
count() is **not the same as the number of ORM objects that this
|
Query would return from a method such as the .all() method**.
|
The :class:`_query.Query` object,
|
when asked to return full entities,
|
will **deduplicate entries based on primary key**, meaning if the
|
same primary key value would appear in the results more than once,
|
only one object of that primary key would be present. This does
|
not apply to a query that is against individual columns.
|
|
.. seealso::
|
|
:ref:`faq_query_deduplicating`
|
|
For fine grained control over specific columns to count, to skip the
|
usage of a subquery or otherwise control of the FROM clause, or to use
|
other aggregate functions, use :attr:`~sqlalchemy.sql.expression.func`
|
expressions in conjunction with :meth:`~.Session.query`, i.e.::
|
|
from sqlalchemy import func
|
|
# count User records, without
|
# using a subquery.
|
session.query(func.count(User.id))
|
|
# return count of user "id" grouped
|
# by "name"
|
session.query(func.count(User.id)).\
|
group_by(User.name)
|
|
from sqlalchemy import distinct
|
|
# count distinct "name" values
|
session.query(func.count(distinct(User.name)))
|
|
.. seealso::
|
|
:ref:`migration_20_query_usage`
|
|
Ú*F)r, Úfuncr rÊ rD rý r± )r Úcolr~ r~ r r s 9ÿz Query.countÚautorN )Úsynchronize_sessionr c C s t | }| jjr>| jjD ]$}||j|}|dk r6||_|j} qtj| j }| j|_td| j j
|
|| j | j d|i¡d}||_| j j |¡ | ¡ |jS )aè Perform a DELETE with an arbitrary WHERE clause.
|
|
Deletes rows matched by this query from the database.
|
|
E.g.::
|
|
sess.query(User).filter(User.age == 25).\
|
delete(synchronize_session=False)
|
|
sess.query(User).filter(User.age == 25).\
|
delete(synchronize_session='evaluate')
|
|
.. warning::
|
|
See the section :ref:`orm_expression_update_delete` for important
|
caveats and warnings, including limitations when using bulk UPDATE
|
and DELETE with mapper inheritance configurations.
|
|
:param synchronize_session: chooses the strategy to update the
|
attributes on objects in the session. See the section
|
:ref:`orm_expression_update_delete` for a discussion of these
|
strategies.
|
|
:return: the count of rows matched as returned by the database's
|
"row count" feature.
|
|
.. seealso::
|
|
:ref:`orm_expression_update_delete`
|
|
NrÀ rÑ rµ )Ú
|
BulkDeleter Zbefore_compile_deleteÚqueryr, Údeleterª r r r r· r rñ r÷ r³ Zafter_bulk_deleteÚcloseÚrowcount)r rÑ Zbulk_delrø rù Zdelete_r³ r~ r~ r rÔ > s. # ÿýþ
|
z Query.deleteú Dict[_DMLColumnArgument, Any]úOptional[Dict[Any, Any]])r rÑ Ú update_argsr c
|
C sÜ |pi }t | ||}| jjrJ| jjD ] }||j|}|dk r$||_q$|j} tj| j }| dd¡}|rr|j| }n
|
| |¡}|r|j
|
f |}| j |_ t d| j j|| j| j d|i¡d} | |_| j j |¡ | ¡ | jS )aÉ Perform an UPDATE with an arbitrary WHERE clause.
|
|
Updates rows matched by this query in the database.
|
|
E.g.::
|
|
sess.query(User).filter(User.age == 25).\
|
update({User.age: User.age - 10}, synchronize_session=False)
|
|
sess.query(User).filter(User.age == 25).\
|
update({"age": User.age - 10}, synchronize_session='evaluate')
|
|
.. warning::
|
|
See the section :ref:`orm_expression_update_delete` for important
|
caveats and warnings, including limitations when using arbitrary
|
UPDATE and DELETE with mapper inheritance configurations.
|
|
:param values: a dictionary with attributes names, or alternatively
|
mapped attributes or SQL expressions, as keys, and literal
|
values or sql expressions as values. If :ref:`parameter-ordered
|
mode <tutorial_parameter_ordered_updates>` is desired, the values can
|
be passed as a list of 2-tuples; this requires that the
|
:paramref:`~sqlalchemy.sql.expression.update.preserve_parameter_order`
|
flag is passed to the :paramref:`.Query.update.update_args` dictionary
|
as well.
|
|
:param synchronize_session: chooses the strategy to update the
|
attributes on objects in the session. See the section
|
:ref:`orm_expression_update_delete` for a discussion of these
|
strategies.
|
|
:param update_args: Optional dictionary, if present will be passed
|
to the underlying :func:`_expression.update`
|
construct as the ``**kw`` for
|
the object. May be used to pass dialect-specific arguments such
|
as ``mysql_limit``, as well as other special arguments such as
|
:paramref:`~sqlalchemy.sql.expression.update.preserve_parameter_order`.
|
|
:return: the count of rows matched as returned by the database's
|
"row count" feature.
|
|
|
.. seealso::
|
|
:ref:`orm_expression_update_delete`
|
|
NZpreserve_parameter_orderFrÀ rÑ rµ )Ú
|
BulkUpdater Zbefore_compile_updaterÓ r, rõ rª rö Zordered_valuesr Zwith_dialect_optionsr r r r· r rñ r÷ r³ Zafter_bulk_updaterÕ rÖ )
|
r r rÑ rÙ Zbulk_udrø rù ZupdZppor³ r~ r~ r rõ | s< 7
|
ÿýþ
|
z Query.updater )rå rÞ r c K sB | j f d|i|}||jjks$tttt |d¡}| |d¡S )a Create an out-of-compiler ORMCompileState object.
|
|
The ORMCompileState object is normally created directly as a result
|
of the SQLCompiler.process() method being handed a Select()
|
or FromStatement() object that uses the "orm" plugin. This method
|
provides a means of creating this ORMCompileState object directly
|
without using the compiler.
|
|
This method is used only for deprecated cases, which include
|
the .from_self() method for a Query that has multiple levels
|
of .from_self() in use, as well as the instances() method. It is
|
also used within the test suite to generate ORMCompileState objects
|
for test purposes.
|
|
rå ró N)ræ r rï r r r Z _get_plugin_class_for_pluginZcreate_for_statement)r rå rÞ ré Zcompile_state_clsr~ r~ r rç Ø s
|
þzQuery._compile_stater! )rå r c C s( | j |d}t||j| j| j| j}|S )Nrä )rç r! râ r r r )r rå rÅ r r~ r~ r Ú_compile_contextù s ûzQuery._compile_context)N)TT)TT)NNNNN)T)FT)NFF)NFF)N)NN)N)T)N)N)N)N)T)rÐ )rÐ N)F)F)r7 Ú
|
__module__Ú __qualname__Ú__doc__r Ú__annotations__r r r r r r r r r r r r rH ZLABEL_STYLE_LEGACY_ORMr rJ r Zdefault_compile_optionsr r! Zdefault_load_optionsr r r r rÎ r Zmemoized_propertyr r r r r r± r· r¾ r; rà rÉ rË rÊ rÈ rÑ rÒ rÓ r4 rÔ rÝ rà rã râ rí ræ r r r r r Ú
|
deprecatedr r
|
r r¬ r rý r Zbecame_legacy_20rû Z apply_labelsr rþ r r r r! rÄ r# r* r r. r0 rÕ r1 Zpreload_moduler& r@ rA rD rG rB r Z_valuesrN r rV rc rd r' rg rh r( r& rè ry r r9 rI r| r r< r
rÆ r r r r÷ r r r r r r r r r r r£ r¤ r¦ rÇ rª r« r¬ r r® r± r´ r© r¾ r» r¿ rÄ rÈ rË r rÔ rõ rç rÛ r~ r~ r~ r r{ s
|
þ
|
ÿ ý( ÿ ÿ
|
|
ú ( ÿ6 ü/ üBþ þ ( þXü% þ úEýÿþ þ
|
$( ,
|
0 4 8'þ ó:0ô(Fÿ #
|
*"û 2û * + ýú* cýû$ + * *
|
2þ
|
ý 'ü û "6?ÿA ü"]ÿ !c @ s: e Zd ZdZe dd¡ddddZdd d
|
d d Zd S )Ú AliasOptionFr z¦The :class:`.AliasOption` object is not necessary for entities to be matched up to a query that is established via :meth:`.Query.from_statement` and now does nothing.zUnion[Alias, Subquery])r< c C s dS )zReturn a :class:`.MapperOption` that will indicate to the
|
:class:`_query.Query`
|
that the main table has been aliased.
|
|
Nr~ )r r< r~ r~ r r s zAliasOption.__init__r r¡ )rÅ r c C s d S r r~ )r rÅ r~ r~ r Úprocess_compile_state s z!AliasOption.process_compile_stateN)r7 rÜ rÝ Z inherit_cacher rà r râ r~ r~ r~ r rá s þrá c @ s> e Zd ZdZddddZdddd Zed
|
dd d Zd S )ÚBulkUDzrState used for the orm.Query version of update() / delete().
|
|
This object is now specific to Query only.
|
|
r )rÓ c C s$ | d¡| _| ¡ | j ¡ | _d S )NF)rý rÓ Ú_validate_query_stater± r) )r rÓ r~ r~ r r ! s zBulkUD.__init__r¡ r c
|
C s ddd t jfddd t jfdddt jfdd dt jfd
|
d d t jfd ddt jfdddt jffD ].\}}}}|t| j||sXt d|f ¡qXd S )Nr zlimit()r zoffset()r z
|
order_by()r~ r z
|
group_by()r z
|
distinct()Fr z2join(), outerjoin(), select_from(), or from_self()r zCCan't call Query.update() or Query.delete() when %s has been called)ÚoperatorÚis_ÚeqÚgetattrrÓ rµ r¶ )r rL r³ ZnotsetÚopr~ r~ r rä & s, üüôÿÿz BulkUD._validate_query_staterR c C s | j jS r )rÓ r r r~ r~ r r @ s zBulkUD.sessionN)r7 rÜ rÝ rÞ r rä r4 r r~ r~ r~ r rã s
|
rã c s* e Zd ZdZdddd fdd Z ZS )rÚ z BulkUD which handles UPDATEs.r r× rØ )rÓ r Ú update_kwargsc s t |¡ || _|| _d S r )Úsuperr r rê )r rÓ r rê ©r8 r~ r r H s zBulkUpdate.__init__)r7 rÜ rÝ rÞ r Ú __classcell__r~ r~ rì r rÚ E s rÚ c @ s e Zd ZdZdS )rÒ z BulkUD which handles DELETEs.N)r7 rÜ rÝ rÞ r~ r~ r~ r rÒ S s rÒ c @ s e Zd ZerddddZdS )ÚRowReturningQueryz
|
Query[_TP]r c C s d S r r~ r r~ r~ r r Z s zRowReturningQuery.tuplesN)r7 rÜ rÝ r r r~ r~ r~ r rî W s rî ) rÞ Ú
|
__future__r Úcollections.abcÚabcr¯ rå Útypingr r r r r r r r
|
r r r r r r r r r Ú r r r r r Ú_typingr Úbaser r r r r r r r! r" r# r$ r% r& r( rµ r) r* r+ r, Zenginer- r. Úeventr/ r0 r1 r2 r3 r4 r¢ r5 Z sql._typingr6 r7 Zsql.annotationr8 Zsql.baser: r; r< r= r> Z sql.elementsr? Zsql.expressionr@ Zsql.selectablerA rB rC rD rE rF rG rH Z util.typingrI rJ rK rL rM rN r) rO Z path_registryrP r rQ rR r¿ rS Z engine.cursorrT Zengine.interfacesrU rV rW rX Z engine.resultrY rZ r[ r\ r] r^ r_ r` ra rb rc rd re rf rg rh ri rj rk rl rm rn Z_TCCAro rp rq rr rs rt ru rv rw rx ry rz Ú__all__r| Z_self_inspectsZ class_loggerZ
|
Identifiedr{ Z LoaderOptionrá rã rÚ rÒ rî r~ r~ r~ r Ú<module> sP
|
ö +
|
