,h޶SrSSKJr SSKJr SSKJr SSKrSSKrSSK r SSK r SSK J r SSK J r SSK J r SS K Jr SS K Jr SS K Jr SS K Jr SS K Jr SSK Jr SSK Jr SSK Jr SSK Jr SSK Jr SSK Jr SSK Jr SSK Jr SSK Jr SSK Jr SSK Jr SSK Jr SSK J!r! SSK J"r" SSK J#r# SSK J$r$ SSK J%r% SS K&J'r' SS!K&J(r( SS"K&J)r) SS#K&J*r* SS$K+J,r, SS%K+J-r- SS&K.J/r/ SS'K.J0r0 SS(K.J1r1 SS)K.J2r2 SS*K.J3r3 SS+K.J4r4 SS,K.J5r5 SS-K.J6r6 SS.K.J7r7 SS/K.J8r8 SS0K9J:r: SS1K9J;r; SS2K!Jr> SS5K?J@r@ SS6K?JArA SS7K?JBrB SS8K?JCrC SS9K?JDrD S:S;K JErE S:SKGJHrH S:S?KGJIrI S:S@KJJKrK S:SAKJJLrL S:SBKJJMrM \ R:(aSSCK&JNrN SSDK&JOrO SSEK&JPrP SSFK&JQrQ SSGK&JRrR SSHK&JSrS SSIK&JTrT SSJK.JUrU SSKK9JVrV SSLK9JWrW SSMKXJYrY SSNKXJZrZ SSOK[J\r\ SSPK"J]r] SSQK^J_r_ SSRK^J`r` SSSK^Jara SSTK^Jbrb SSUKcJdrd SSVKcJere SSWKcJfrf SSXKcJgrg SSYKhJiri SSZK%Jjrj SS[K?Jkrk SS\K?Jlrl SS]K?Jmrm S:S^KnJoro S:S_KnJprp S:S`KqJrrr S:SaKqJsrs S:SbKqJtrt S:ScKqJuru S:SdKqJvrv S:SeKwJxrx \\y\4rz\\y\{\4r|\"SfSgSh9r}\"Si\ SjSk9r~\"SlSgSh9r\"SmSnSh9r\"SoSpSh9r\SSSqjj5r\SSSrjj5r\SSSsjj5rSSStjjrSSSujjr"SvSw\D5r\FGR "SxSy\-\:\>\A\55r"SzS{\5r"S|S}\#GR\#GR\#GR\5r"S~S\\~\=\I5r"SS\\~\#GR\~\I5r\r"SS\#GR \#GR"\#GR$\#GR&\}\#GR(\#GR\#GR*\#GR\#GR\#GR,\\}\5r"SS\\}5r"SS\\}5r"SS\#GR4\\}5r"SS\5r"SS\#GR\#GR,\#GR"\#GR$\#GR(\#GR:\#GR<\#GR4\4\3\\#GR&\ \FGR>S5r"SS\8\#GRBS\S5r\GRG5 "SS\8\#GRB\\\5r\GRG5 "SS\8\#GRB\\\5r\GRG5 "SS\#GR4\#GR(\#GR\#GR\5r"SS\\}5r"SS\\}5r"SS\\5r\GRVr\GRXr"SS\\\\ S45r"SS\\}5r"SS\\}5r"SS\\}5r"SS\\}5r"SS\\{5r"SS\\}5r"SS\\ 5r"SS\\}5r"SS\\}5r"SS\\\\5r"SS\\}5r"SS\\ 5r"SS\\ 5r"SS\5r"SS\\\}5r"SS\\}5r"SS\5r\GR|r\GR~r\\{\4r"SS\\}5r"SS\\}5r"SS\4\\}5r"SS\\}5r\L"S5r"SS\#GR\}\\}5r"SS\#GR\#GR\}\#GR\6\\}5r"SS\\}5r"SS\\5r"SS\3\5r"SS\5r"SS\5r"SS\5r"SS\GGR\5rSSjrSSjrSSjr"SS\GGRS5r"SS\,5r"SS\5r"SS\5r\r"SS\5rg)zCore SQL expression elements, including :class:`_expression.ClauseElement`, :class:`_expression.ColumnElement`, and derived classes. ) annotations)Decimal)EnumN) AbstractSet)Any)Callable)cast)Dict) FrozenSet)Generic)Iterable)Iterator)List)Mapping)Optional)overload)Sequence)Set)Tuple)Type) TYPE_CHECKING)TypeVar)Union) coercions) operators)roles) traversals)type_api)has_schema_attr)is_named_from_clause)is_quoted_name) is_tuple_type) Annotated)SupportsWrappingAnnotations)_clone)_expand_cloned) _generative)_NoArg) Executable) Generative) HasMemoized) Immutable)NO_ARG)SingletonConstant)MemoizedHasCacheKey)NO_CACHE)_document_text_coercion)ColumnOperators)HasCopyInternals)cloned_traverse)ExternallyTraversible)InternalTraversal)traverse) Visitable)exc) inspection)util)!HasMemoized_ro_memoized_attribute) TypingOnly)Literal) ParamSpec)Self) _ByArgument)_ColumnExpressionArgument)#_ColumnExpressionOrStrLabelArgument) _HasDialect) _InfoType)_PropagateAttrsType)_TypeEngineArgument) ColumnSet)_CacheKeyTraversalType)CacheKey)Compiled) SQLCompiler)FunctionElement) OperatorType)Column)DefaultGenerator) FetchedValue) ForeignKey)_SelectIterable) FromClause)NamedFromClause) TextualSelect) TupleType) TypeEngine)_CloneCallableType)_TraverseInternalsType)anon_map) Connection)Dialect)_CoreMultiExecuteParams) CacheStats)CompiledCacheType)CoreExecuteOptionsParameter)SchemaTranslateMapType)Result_Tr)bound_T_coT)rg covariant_OPT_NT_NUMERIC_NMT_NUMBERcgNvaluetype_literal_executes O/var/www/auris/envauris/lib/python3.13/site-packages/sqlalchemy/sql/elements.pyliteralrw cgrprqrrs rvrwrwrxrycgrprqrrs rvrwrws rycL[R"[RUUUS9$)aReturn a literal clause, bound to a bind parameter. Literal clauses are created automatically when non- :class:`_expression.ClauseElement` objects (such as strings, ints, dates, etc.) are used in a comparison operation with a :class:`_expression.ColumnElement` subclass, such as a :class:`~sqlalchemy.schema.Column` object. Use this function to force the generation of a literal clause, which will be created as a :class:`BindParameter` with a bound value. :param value: the value to be bound. Can be any Python object supported by the underlying DB-API, or is translatable via the given type argument. :param type\_: an optional :class:`~sqlalchemy.types.TypeEngine` which will provide bind-parameter translation for this literal. :param literal_execute: optional bool, when True, the SQL engine will attempt to render the bound value directly in the SQL statement at execution time rather than providing as a parameter value. .. versionadded:: 2.0 )rtru)rexpectrLiteralValueRolerrs rvrwrws):     '  ryc[XSS9$)a@Produce a :class:`.ColumnClause` object that has the :paramref:`_expression.column.is_literal` flag set to True. :func:`_expression.literal_column` is similar to :func:`_expression.column`, except that it is more often used as a "standalone" column expression that renders exactly as stated; while :func:`_expression.column` stores a string name that will be assumed to be part of a table and may be quoted as such, :func:`_expression.literal_column` can be that, or any other arbitrary column-oriented expression. :param text: the text of the expression; can be any SQL expression. Quoting rules will not be applied. To specify a column-name expression which should be subject to quoting rules, use the :func:`column` function. :param type\_: an optional :class:`~sqlalchemy.types.TypeEngine` object which will provide result-set translation and additional expression semantics for this column. If left as ``None`` the type will be :class:`.NullType`. .. seealso:: :func:`_expression.column` :func:`_expression.text` :ref:`tutorial_select_arbitrary_text` T)rt is_literal) ColumnClause)textrts rvliteral_columnrsF d ;;ryc\rSrSrSrSrSrSrSr\ R"S5\ R"S5SSS jj55r S r SS jr SS jrSrg )CompilerElementzbbase class for SQL elements that can be compiled to produce a SQL string. .. versionadded:: 2.0 rqcompiler_elementFdefaultzsqlalchemy.engine.defaultzsqlalchemy.engine.urlNc <UcU(a URnOsURS:XaUR5nOR[RR nUR RUR5R5"5nUR"U40UD6$)aCompile this SQL expression. The return value is a :class:`~.Compiled` object. Calling ``str()`` or ``unicode()`` on the returned value will yield a string representation of the result. The :class:`~.Compiled` object also can return a dictionary of bind parameter names and values using the ``params`` accessor. :param bind: An :class:`.Connection` or :class:`.Engine` which can provide a :class:`.Dialect` in order to generate a :class:`.Compiled` object. If the ``bind`` and ``dialect`` parameters are both omitted, a default SQL compiler is used. :param column_keys: Used for INSERT and UPDATE statements, a list of column names which should be present in the VALUES clause of the compiled statement. If ``None``, all columns from the target table object are rendered. :param dialect: A :class:`.Dialect` instance which can generate a :class:`.Compiled` object. This argument takes precedence over the ``bind`` argument. :param compile_kwargs: optional dictionary of additional parameters that will be passed through to the compiler within all "visit" methods. This allows any custom flag to be passed through to a custom compilation construct, for example. It is also used for the case of passing the ``literal_binds`` flag through:: from sqlalchemy.sql import table, column, select t = table("t", column("x")) s = select(t).where(t.c.x == 5) print(s.compile(compile_kwargs={"literal_binds": True})) .. seealso:: :ref:`faq_sql_expression_string` r) dialectstringify_dialect_default_dialectr= preloaded engine_urlURLcreate get_dialect _compiler)selfbindrkwurls rvcompileCompilerElement.compilesh ?,,''94//1nn//''..**+- "~~g,,,rycV[RRnUR5$rp)r=rengine_defaultStrCompileDialect)rrs rvr CompilerElement._default_dialect6s ..//((**ryc l[(a[U[5(deUR"X40UD6$)FReturn a compiler appropriate for this ClauseElement, given a Dialect.)r isinstance ClauseElementstatement_compilerrrrs rvrCompilerElement._compiler:s2 =dM22 22))'>2>>ryc4[UR55$rp)strrrs rv__str__CompilerElement.__str__Bs4<<>""ryNN)rOptional[_HasDialect]rOptional[Dialect]rrreturnrM)rr_rrrrMrr)__name__ __module__ __qualname____firstlineno____doc__ __slots____visit_name__supports_executionrr=preload_modulerrrr__static_attributes__rqryrvrrsI'N! 45 01'+%)=-#=-#=- =-  =-26=-~+?#ryrc\rSrSr%SrSr\(a\RS.Sj5r O \Rr \RS/Sj5r Sr S\S'S rS rS rS rS rS rS rS rS rS rS rS rS rS rS rS rS rS r S r!S r"S r#\$S0S j5r%Sr&S \S 'S\S'\'R (aSS.S1Sjjr(\RRS2Sj5r*S3Sjr+S4Sjr,S5Sjr-Sr.Sr/\$S5r0\1RdS5r3Sr4\$S5r5Sr6S6Sjr7S7Sjr8S8S jr9S9S:S!jjr:S9S;S"jjr;SS%jjr>S?S&jr?S SS'.S@S(jjr@S)rAS?S*jrBS+rCS,rDS-rEg)AriFzKBase class for elements of a programmatically constructed SQL expression. clausecg)zlike annotations, however these propagate outwards liberally as SQL constructs are built, and are set up at construction time. Nrqrs rv_propagate_attrsClauseElement._propagate_attrsWs rycgrprqrs rv descriptionClauseElement.descriptionbryNzOptional[Self] _is_clone_ofTFcgrprqrs rv_order_by_label_element%ClauseElement._order_by_label_element~rryrK_cache_key_traversalColumnElement[bool]negation_clause.) omit_attrsc grprq)rrrs rv get_childrenClauseElement.get_childrens&)ryc/$rprqrs rv _from_objectsClauseElement._from_objects ryc<[R"U5UlU$rp)r= immutabledictr)rvaluess rv_set_propagate_attrs"ClauseElement._set_propagate_attrss!% 2 26 : rycDUR5nURX5$rp)rr)rrs rv_default_compilerClauseElement._default_compilers!'')))'88ryc URnURRUR5nU(aJURR 5R 5VVs0sHupEXB;dM XE_M snnUlOURR 5UlUR nUbXclU$UUlU$s snnf)zCreate a shallow copy of this ClauseElement. This method may be used by a generative API. Its also used as part of the "deep" copy afforded by a traversal that combines the _copy_internals() method. )_memoized_keys __class____new____dict__copyitemsr)rrskipckvccs rvr&ClauseElement._clones"" NN " "4>> 2 "&!3!3!5!;!;!=!=!=AJ++-AJ  !~48s $ C3CcU$)za hook to allow the right side of a binary expression to respond to a negation of the binary expression. Used for the special case of expanding bind parameter with IN. rq)r negated_op original_ops rv_negate_in_binaryClauseElement._negate_in_binary  rycU$)zin the context of binary expression, convert the type of this object to the one given. applies only to :class:`_expression.ColumnElement` classes. rqrrts rv_with_binary_element_type'ClauseElement._with_binary_element_typerrycUR$)areturn the 'constructor' for this ClauseElement. This is for the purposes for creating a new object of this type. Usually, its just the element's __class__. However, the "Annotated" version of the object overrides to return the class of its proxied element. rrs rv _constructorClauseElement._constructors~~ryc~[R"5nUnUb"URU5 URnUbM"U$)zReturn the set consisting all cloned ancestors of this ClauseElement. Includes this ClauseElement. This accessor tends to be used for FromClause objects to identify 'equivalent' FROM clauses, regardless of transformative operations. )r= column_setaddr)rsfs rv _cloned_setClauseElement._cloned_sets> OO %)m EE!HAmrycVURbURnURbMU$rp)rrs rv _de_cloneClauseElement._de_clones,+$$D+ ryc[S5e)NzFThis SQL expression has no entity namespace with which to filter from.)AttributeErrorrs rventity_namespaceClauseElement.entity_namespaces )  rycURR5nURSS5 URSS5 U$)Nr_generate_cache_key)rrpop)rds rv __getstate__ClauseElement.__getstate__s6 MM    nd# #T*rycUR(a4[(a[U[5(deUR XU5$[ R "U5erp)rrrr*_execute_clauseelementr;ObjectNotExecutableErrorr connectiondistilled_paramsexecution_optionss rv_execute_on_connection$ClauseElement._execute_on_connectionsQ  " "}!$ 333344(9 ..t4 4rycBURXU5R5$)zan additional hook for subclasses to provide a different implementation for connection.scalar() vs. connection.execute(). .. versionadded:: 2.0 )rscalarr s rv_execute_on_scalar ClauseElement._execute_on_scalars$** *; &( ryczUR5nUc/n[U0SUR05 U$UR$)aSReturn the list of :class:`.BindParameter` objects embedded in the object. This accomplishes the same purpose as ``visitors.traverse()`` or similar would provide, however by making use of the cache key it takes advantage of memoization of the key to result in fewer net method calls, assuming the statement is also going to be executed. bindparam)rr8append bindparams)rkeyrs rv_get_embedded_bindparams&ClauseElement._get_embedded_bindparams!sE&&( ;35J T2 Z->->? @ >> !ryc &URSX5$)zReturn a copy with :func:`_expression.bindparam` elements replaced. Same functionality as :meth:`_expression.ClauseElement.params`, except adds `unique=True` to affected bind parameters so that multiple statements can be used. T_replace_paramsr_ClauseElement__optionaldictkwargss rv unique_paramsClauseElement.unique_params7s##D.AAryc &URSX5$)auReturn a copy with :func:`_expression.bindparam` elements replaced. Returns a copy of this ClauseElement with :func:`_expression.bindparam` elements replaced with values taken from the given dictionary:: >>> clause = column("x") + bindparam("foo") >>> print(clause.compile().params) {'foo':None} >>> print(clause.params({"foo": 7}).compile().params) {'foo':7} Frrs rvparamsClauseElement.paramsGs&##E>BBrycl^^U(aTRU5 SUU4Sjjn[USSS.SU05$)Nc>URT;aTURUlSUlT(aUR5 ggNF)rrsrequired_convert_to_unique)rr uniques rvvisit_bindparam6ClauseElement._replace_params..visit_bindparames:xx6!#DHH- % '')ryT) maintain_keydetect_subquery_colsr)rBindParameter[Any]rNone)updater5)rr+ optionaldictr r,s ` ` rvrClauseElement._replace_params\s@  MM, ' * * !4 @ / *  ryc 0[R"X40UD6$)a]Compare this :class:`_expression.ClauseElement` to the given :class:`_expression.ClauseElement`. Subclasses should override the default behavior, which is a straight identity comparison. \**kw are arguments consumed by subclass ``compare()`` methods and may be used to modify the criteria for comparison (see :class:`_expression.ColumnElement`). )rcomparerotherrs rvr6ClauseElement.comparers!!$444rycU$)aApply a 'grouping' to this :class:`_expression.ClauseElement`. This method is overridden by subclasses to return a "grouping" construct, i.e. parenthesis. In particular it's used by "binary" expressions to provide a grouping around themselves when placed into a larger expression, as well as by :func:`_expression.select` constructs when placed into the FROM clause of another :func:`_expression.select`. (Note that subqueries should be normally created using the :meth:`_expression.Select.alias` method, as many platforms require nested SELECT statements to be named). As expressions are composed together, the application of :meth:`self_group` is automatic - end-user code should never need to use this method directly. Note that SQLAlchemy's clause constructs take operator precedence into account - so parenthesis might not be needed, for example, in an expression like ``x OR (y AND z)`` - AND takes precedence over OR. The base :meth:`self_group` method of :class:`_expression.ClauseElement` just returns self. rqragainsts rv self_groupClauseElement.self_groups 6 rycU$)zFReturn this :class:`_expression.ClauseElement` without any groupings. rqrs rv_ungroupClauseElement._ungroups  ry)for_executemanyschema_translate_mapc Ub"UR(aUR5nOSnUbw[(aUceUupUU[U5[ U5U4n UR U 5n U c)UR n UR"U4UUUUS.UD6n XU 'OaURn OTSn UR"U4UUUUS.UD6n UR(d URn OUc URn O URn XU 4$)N) cache_key column_keysrBrC) _supports_statement_cacherrtupleboolget CACHE_MISSr CACHE_HITNO_DIALECT_SUPPORTCACHING_DISABLED NO_CACHE_KEY) rrcompiled_cacherFrBrCrelem_cache_keyrEextracted_paramsr compiled_sql cache_hits rv_compile_w_cacheClauseElement._compile_w_caches8  %'*K*K!557N!N  %}%111*8 'Ik")* C*--c2L##.. #~~ , +$3)=      '3s##-- # >>(' /%9   L44#66 '#44 #00 y88ryc\[US5(a UR$UR5$)Nr)hasattrr_negaters rv __invert__ClauseElement.__invert__s* 4* + +'' '<<> !rycUR[RS9n[U[5(de[ U[RS9$)Nr<)operatorr=rinvr ColumnElementUnaryExpressionrgroupeds rvrYClauseElement._negates://)--/8'=1111w??ryc[S5e)N+Boolean value of this clause is not defined) TypeErrorrs rv__bool__ClauseElement.__bool__sEFFrycURnUc[RU5$SURURR [ U5U4-$)Nz<%s.%s at 0x%x; %s>)robject__repr__rrrid)rfriendlys rvrmClauseElement.__repr__sR##  ??4( ((''4 , ry)rrrHr Optional[str]rzOptional[Label[Any]])rztyping_Tuple[str, ...]rrrzIterable[ClauseElement]rzList[FromClause])rMapping[str, Any]rrB)rrN)rrrrB)r r^r r`r rcrz Result[Any])r r^r r`r rcrr)rSequence[BindParameter[Any]]rp)rzOptional[Dict[str, Any]]r rrrB)rOptional[Mapping[str, Any]]r rrrB)r+rIr3rxr zDict[str, Any]rrB)r8rrrrrI)r<Optional[OperatorType]rr)rr)rr_rPzOptional[CompiledCacheType]rFz List[str]rBrIrCz Optional[SchemaTranslateMapType]rrrzJtyping_Tuple[Compiled, Optional[Sequence[BindParameter[Any]]], CacheStats])Frrrrrrrr=memoized_propertyr EMPTY_DICTro_memoized_propertyrr__annotations__is_clause_element is_selectableis_dml_is_column_element_is_keyed_column_element _is_table!_gen_static_annotations_cache_key _is_textual_is_from_clause_is_returns_rows_is_text_clause_is_from_container_is_select_container_is_select_base_is_select_statement_is_bind_parameter_is_clause_list_is_lambda_element_is_singleton_constant _is_immutable_is_starpropertyrrtypingrro_non_memoized_propertyrrrr&rrrr,memoized_attributerrrrrrrr!r$rr6r=r@rUrZrYrirmrrqryrvrrFs  N      ?? $(L.'M F$I(-%KOO O O"MH 4807(( ;> *!7 *EH * $ * ""#9:  ##$,    5 52 57 5  527   "048B0BB  B$7;C3CC  C*  2     , 515- :!&AE@9@94 @9  @9  @9?@9@9 @9D"@ G ryrcj\rSrSrSr\R (aSSjrSS SjjrSr gSr g) DQLDMLClauseElementizprepresents a :class:`.ClauseElement` that compiles to a DQL or DML expression, not DDL. .. versionadded:: 2.0 c g)rNrqrs rvrDQLDMLClauseElement._compiler s ryNc grprq)rrrrs rvrDQLDMLClauseElement.compiles ryrq)rr_rrrrNr)rrrrrrrrN) rrrrrrrrrrrqryrvrrsT +/)- ' '       ryrc8\rSrSrSrSr\RrSr Sr g)CompilerColumnElementiz\A compiler-only column element used for ad-hoc string compilations. .. versionadded:: 2.0 rqFN) rrrrrrr=r{r_is_collection_aggregaterrqryrvrrs  I$ryrc\rSrSrSr\R (Ga\RSpSj5r SqSjr SqSjr \ SrSS.SsSjjj5r \ StSuS jj5r SvSuS jjr SwSxS jjrSyS jrSyS jrSzSjrS{SjrS{SjrS|SjrS{SjrS{SjrS{SjrS{SjrS{SjrS{SjrS}SjrS{SjrS~Sjr\ SSj5r\ SSj5rSSjr\ SSj5r\ SSj5rSS jr\ SS!j5r \ SS"j5r SS#jr SSS$jjr!SSS%jjr"SS&jr#SS'jr$SS(jr%S}S)jr&SS*jr'SS+jr(SS,jr)SS-jr*SS.jr+SSS/jjr,SSS0jjr-SSS1jjr.SSS2jjr/SS3jr0SS4jr1SS5jr2SSS6jjr3SSS7jjr4SSS8jjr5SSS9jjr6SS:jr7SS;jr8SS<jr9SSS=jjr:SSS>jjr;S}S?jrS}SBjr?S}SCjr@S}SDjrASSEjrBSSSFjjrCSSGjrDSSHjrESSIjrF\ SSJj5rG\ SSKj5rG\ SSLj5rGSSMjrG\ SSNj5rH\ SSOj5rHSSPjrH\ SSQj5rI\ SSRj5rISSSjrI\ SSTj5rJ\ SSUj5rJSSVjrJ\ SSWj5rK\ SSXj5rKSSYjrK\ SSZj5rL\ SS[j5rLSS\jrL\ SS]j5rM\ SS^j5rMSS_jrM\ SS`j5rN\ SSaj5rNSSbjrN\ SScj5rO\ SSdj5rO\ SSej5rOSSfjrO\ SSgj5rP\ SShj5rPSSijrP\ SSjj5rQ\ SSkj5rQSSljrQ\ SSmj5rR\ SSnj5rRSSojrRSrSgSrSg)SQLCoreOperationsi/rqcgrprqrs rvr"SQLCoreOperations._propagate_attrs7s;>rycgrprqropr8r s rvoperateSQLCoreOperations.operate:!$ryc grprqrs rvreverse_operate!SQLCoreOperations.reverse_operate>rryN) python_implcgrprqropstring precedence is_comparison return_typers rvrSQLCoreOperations.opBs7:rycgrprqrs rvrrMs69rycgrprqrs rvrrWs69rycgrprq)rrrrs rvbool_opSQLCoreOperations.bool_op`s 7:rycgrprqrr8s rv__and__SQLCoreOperations.__and__gCrycgrprqrs rv__or__SQLCoreOperations.__or__is3rycgrprqrs rvrZSQLCoreOperations.__invert__kscrycgrprqrs rv__lt__SQLCoreOperations.__lt__mSrycgrprqrs rv__le__SQLCoreOperations.__le__orrycgrprqrs rv__hash__SQLCoreOperations.__hash__us3rycgrprqrs rv__eq__SQLCoreOperations.__eq__w rycgrprqrs rv__ne__SQLCoreOperations.__ne__zrrycgrprqrs rvis_distinct_from"SQLCoreOperations.is_distinct_from}srycgrprqrs rvis_not_distinct_from&SQLCoreOperations.is_not_distinct_from3rycgrprqrs rv__gt__SQLCoreOperations.__gt__rrycgrprqrs rv__ge__SQLCoreOperations.__ge__rrycgrprqrs rv__neg__SQLCoreOperations.__neg__sSrycgrprqrs rv __contains__SQLCoreOperations.__contains__3rycgrprq)rindexs rv __getitem__SQLCoreOperations.__getitem__rycgrprqrs rv __lshift__SQLCoreOperations.__lshift__KNrycgrprqrs rvrr@Crycgrprqrs rvrrrycgrprqrs rv __rshift__SQLCoreOperations.__rshift__rrycgrprqrs rvrrrrycgrprqrs rvrrrrycgrprqrs rvconcatSQLCoreOperations.concatsGJrycgrprqrs rvrrss rv istartswithSQLCoreOperations.istartswithrBrycgrprqr>s rvendswithSQLCoreOperations.endswithrBrycgrprqr>s rv iendswithSQLCoreOperations.iendswithrBryc grprqr7s rvcontainsSQLCoreOperations.containss#ryc grprqr7s rv icontainsSQLCoreOperations.icontainsrryc grprq)rr8r s rvmatchSQLCoreOperations.matchrrycgrprq)rpatternflagss rv regexp_matchSQLCoreOperations.regexp_matchs"%rycgrprq)rrV replacementrWs rvregexp_replace SQLCoreOperations.regexp_replacerrycgrprqrs rvdescSQLCoreOperations.desc s#rycgrprqrs rvascSQLCoreOperations.ascsrycgrprqrs rv nulls_firstSQLCoreOperations.nulls_firstrrycgrprqrs rv nullsfirstSQLCoreOperations.nullsfirstrycgrprqrs rv nulls_lastSQLCoreOperations.nulls_lastrjrycgrprqrs rv nullslastSQLCoreOperations.nullslastssrycgrprqr collations rvcollateSQLCoreOperations.collatecrycgrprq)rcleftcright symmetrics rvbetweenSQLCoreOperations.betweenrrycgrprqrs rvdistinctSQLCoreOperations.distinctrrycgrprqrs rvany_SQLCoreOperations.any_ Crycgrprqrs rvall_SQLCoreOperations.all_"rrycgrprqrs rv__add__SQLCoreOperations.__add__)#&rycgrprqrs rvrr/s"%rycgrprqrs rvrr5=@rycgrprqrs rvrr8rrycgrprqrs rv__radd__SQLCoreOperations.__radd__:rrycgrprqrs rvrr=sILrycgrprqrs rvrr@rvrycgrprqrs rv__sub__SQLCoreOperations.__sub__Brrycgrprqrs rvrrHrrycgrprqrs rvrrKrrycgrprqrs rv__rsub__SQLCoreOperations.__rsub__Mrrycgrprqrs rvrrS>Arycgrprqrs rvrrVrvrycgrprqrs rv__mul__SQLCoreOperations.__mul__Xrrycgrprqrs rvrr^rrycgrprqrs rvrrarrycgrprqrs rv__rmul__SQLCoreOperations.__rmul__crrycgrprqrs rvrrirrycgrprqrs rvrrlrvrycgrprqrs rv__mod__SQLCoreOperations.__mod__nsJMrycgrprqrs rvrrqrrycgrprqrs rvrrtrrycgrprqrs rv__rmod__SQLCoreOperations.__rmod__vrrycgrprqrs rvrryrrycgrprqrs rvrr|rvrycgrprqrs rv __truediv__SQLCoreOperations.__truediv__~'*rycgrprqrs rvrrsLOrycgrprqrs rvrrsADrycgrprqrs rvrrrrycgrprqrs rv __rtruediv__SQLCoreOperations.__rtruediv__rrycgrprqrs rvrrBErycgrprqrs rvrr#rycgrprqrs rv __floordiv__SQLCoreOperations.__floordiv__#&rycgrprqrs rvrrrrycgrprqrs rvrrrrycgrprqrs rv __rfloordiv__SQLCoreOperations.__rfloordiv__rrycgrprqrs rvrrCFrycgrprqrs rvrrrryrq)rrPr8rr rrColumnElement[Any])..) rrrintrrIr_TypeEngineArgument[_OPT]rOptional[Callable[..., Any]]rz'Callable[[Any], BinaryExpression[_OPT]])....) rrrrrrIr"Optional[_TypeEngineArgument[Any]]rrrz&Callable[[Any], BinaryExpression[Any]])rFNN)rN)rrrrrrrz'Callable[[Any], BinaryExpression[bool]])r8rrBooleanClauseList)rzColumnElement[_T_co])r8rrrrr)rUnaryExpression[_T_co])rrrr)r _SQO[int]r8rrzColumnElement[int])r8rrr)rz _SQO[str]r8rrColumnElement[str]rp)r8rrrsrBinaryExpression[bool])r8rrzBinaryExpression[Any])r8z=Union[Iterable[Any], BindParameter[Any], roles.InElementRole]rr)r8rrrr()r8rrrsr?rIrr)r8rrrrr)r8rr rrr)rVrrWrsrr)rVrr[rrWrsrr)rsrrCollationClauseF)rxrryrrzrIrr)rz _SQO[_T_co]rr)rzCollectionAggregate[Any])r _SQO[_NMT]r8rrzColumnElement[_NMT])rrr8rrColumnElement[_NUMERIC])rz _SQO[_NT]r8rrzColumnElement[_NT])rrr8rrr)Trrrrrrrr=non_memoized_propertyrrrrrrrrrZrrrrrrrrrrrrrrrrrr rrrrrrr#r&r)r,r/r2r5r8r;r@rDrGrJrMrPrSrXr\r_rbrerhrlrortr{r~rrrrrrrrrrrrrrrrqryrvrr/sI  # #> $> %" %,/ %;> %  % %" %+. %:= %  % ""%  :9= : : :  : 3  :6 :5 :  : ""%>A8;  9 9 9  9 <  9 6  94 9  9 "'>B8<  9 9 9  9 <  9 6  94 9 8<  : : :6  : 5  : @>9@@ '   KN@@8FD N N C CC N N C CC J J ? ??7; ) )&3 ) # ) 7; ) )&3 ) # ) HFG<JJ ) ) $  ) ) ) $  ) ) ) $  )7; ) )&3 ) # ) 7; ) )&3 ) # ) 7; ) )&3 ) # ) 7; ) )&3 ) # ) ACB %)$  & &" &  & !  &%)$  & &" &  & !  &%)$  & &" &  & !  &%)$  & &" &  & !  & NNN8< & &'4 &  & JN % %-0 %9F %  % 64<;;:A>C ) )&) )6: ) # ) G77  & & &! &  &  % % %  %  % @ @@ N N L LA  & & &! &  & @ @@  & & &! &  & A AA  & & &! &  & @ @@  & & &! &  & A AA M M @ @@ N N A AA  * *$' * $ *  * O O D DD  * *%( * $ *  * E EE  & &%( &  &  & E EE  & &%( &  &  & F FFe ryrc\rSrSrSrSrSrg)SQLColumnExpressioniaA type that may be used to indicate any SQL column element or object that acts in place of one. :class:`.SQLColumnExpression` is a base of :class:`.ColumnElement`, as well as within the bases of ORM elements such as :class:`.InstrumentedAttribute`, and may be used in :pep:`484` typing to indicate arguments or return values that should behave as column expressions. .. versionadded:: 2.0.0b4 rqNrrrrrrrrqryrvrrs IryrcD\rSrSr%SrSrSrS\S'S\S'S rSr S\S 'Sr Sr \ "5r S \S '\RSBS j5r\R"SCSj5rSrS\S'\R*SCSj5r\SCSj5r\SCSj5r\SCSj5rS rS rSrSrS\S'\SDSESjj5r \SDSFSjj5r SDSFSjjr \SGSj5r!\SHSj5r!SISjr!S\S '\"(d\RSJS!j5r#\R*SKS"j5r$S#r%SLS$jr&SMS%jr'SMS&jr(SNSOS'jjr)\SIS(j5r*\SPS)j5r+\RSQS*j5r,\RSQS+j5r-\RSQS,j5r.SBS-jr/SRS.jr0SSS/jr1\R*SCS0j5r2\R*SCS1j5r3SSSSS2.STS3jjr4SUS4jr5SVS5jr6SDSWS6jjr7\RSXS7j5r8\RSYS8j5r9\\Rt"S9S:5SXS;j55r;\\Rt"S9S<5SXS=j55rjr=\RSYS?j5r>\RSYS@j5r?S[SAjr@SrAg)\raiaRepresent a column-oriented SQL expression suitable for usage in the "columns" clause, WHERE clause etc. of a statement. While the most familiar kind of :class:`_expression.ColumnElement` is the :class:`_schema.Column` object, :class:`_expression.ColumnElement` serves as the basis for any unit that may be present in a SQL expression, including the expressions themselves, SQL functions, bound parameters, literal expressions, keywords such as ``NULL``, etc. :class:`_expression.ColumnElement` is the ultimate base class for all such elements. A wide variety of SQLAlchemy Core functions work at the SQL expression level, and are intended to accept instances of :class:`_expression.ColumnElement` as arguments. These functions will typically document that they accept a "SQL expression" as an argument. What this means in terms of SQLAlchemy usually refers to an input which is either already in the form of a :class:`_expression.ColumnElement` object, or a value which can be **coerced** into one. The coercion rules followed by most, but not all, SQLAlchemy Core functions with regards to SQL expressions are as follows: * a literal Python value, such as a string, integer or floating point value, boolean, datetime, ``Decimal`` object, or virtually any other Python object, will be coerced into a "literal bound value". This generally means that a :func:`.bindparam` will be produced featuring the given value embedded into the construct; the resulting :class:`.BindParameter` object is an instance of :class:`_expression.ColumnElement`. The Python value will ultimately be sent to the DBAPI at execution time as a parameterized argument to the ``execute()`` or ``executemany()`` methods, after SQLAlchemy type-specific converters (e.g. those provided by any associated :class:`.TypeEngine` objects) are applied to the value. * any special object value, typically ORM-level constructs, which feature an accessor called ``__clause_element__()``. The Core expression system looks for this method when an object of otherwise unknown type is passed to a function that is looking to coerce the argument into a :class:`_expression.ColumnElement` and sometimes a :class:`_expression.SelectBase` expression. It is used within the ORM to convert from ORM-specific objects like mapped classes and mapped attributes into Core expression objects. * The Python ``None`` value is typically interpreted as ``NULL``, which in SQLAlchemy Core produces an instance of :func:`.null`. A :class:`_expression.ColumnElement` provides the ability to generate new :class:`_expression.ColumnElement` objects using Python expressions. This means that Python operators such as ``==``, ``!=`` and ``<`` are overloaded to mimic SQL operations, and allow the instantiation of further :class:`_expression.ColumnElement` instances which are composed from other, more fundamental :class:`_expression.ColumnElement` objects. For example, two :class:`.ColumnClause` objects can be added together with the addition operator ``+`` to produce a :class:`.BinaryExpression`. Both :class:`.ColumnClause` and :class:`.BinaryExpression` are subclasses of :class:`_expression.ColumnElement`: .. sourcecode:: pycon+sql >>> from sqlalchemy.sql import column >>> column("a") + column("b") >>> print(column("a") + column("b")) {printsql}a + b .. seealso:: :class:`_schema.Column` :func:`_expression.column` column_elementFrI primary_keyOptional[ColumnElement[_T]]rT_insert_sentinelzAbstractSet[ForeignKey] foreign_keysc/$rprqrs rv_proxiesColumnElement._proxies)rryrscg)a-The named label that can be used to target this column in a result set in a "table qualified" context. This label is almost always the label used when rendering AS