-h SrSSKJr SSKrSSKrSSKrSSKJr SSKJr SSKJ r SSKJ r SS KJ r SS K J r SS K Jr SS KJr SS KJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSK Jr SSK Jr SSK Jr SSKJr SSKJr SSKJr SSKJ r SSKJ!r! SSKJ"r" SSKJ#r# S r$SS!jr%SS"jr&SS#jr'S$r(\"RR"S%S&\ RT\\\\ 55r+"S'S(\ RX\ RZ\ R\\ R^\ R`\ Rb\ Rd\ Rf\ Rh\ Rj\Rl\+5r7"S)S*\85r9"S+S,\ Rt\75r;"S-S.\+5r<"S/S0\ Rh\ Rj\ RZ\ R\\ R`\ Rz\ R|\ R^\ Rt\\+5 r?"S1S2\\ R\75rA\AR5 "S3S4\\ R\75rC\CR5 "S5S6\\ R\75rD\DR5 "S7S8\ Rt\ R`\ Rb\ Rf\+5rE"S9S:\E\75rF\FRrG\FRrH"S;S<\E\75rI"S=S>\75rJSS?jrK"S@SA\9\75rL"SBSC\9\75rM"SDSE\75rN"SFSG\75rO"SHSI\75rP"SJSK\75rQ"SLSM\Q5rR"SNSO\9\Q5rS"SPSQ\75rT"SRSS\75rU"STSU\T5rV"SVSW\+5rW"SXSY\W\75rX\#R"SZ5rZ\#R"S[5r["S\S]\75r\"S^S_\75r]"S`Sa\75r^"SbSc\ R\75r`"SdSe\75ra"SfSg\ R\ R\ R\\a5rd"ShSi\a5re"SjSk\75rf"SlSm\\+5rg"SnSo\g5rh"SpSq\g5ri"SrSs\g5rj"StSu\#R\#R5rmSvrnSwroSSxjrp"SySz\ 5rq"S{S|\m5rr"S}S~\r5rs\#R"S5rt\rru"SS\r5rvg)zCore SQL expression elements, including :class:`_expression.ClauseElement`, :class:`_expression.ColumnElement`, and derived classes. )unicode_literalsN) coercions) operators)roles) traversals)type_api) Annotated)SupportsWrappingAnnotations)_clone) _generative) Executable) HasMemoized) Immutable)NO_ARG)PARSE_AUTOCOMMIT)SingletonConstant)_document_text_coercion)HasCopyInternals)MemoizedHasCacheKey)NO_CACHE)cloned_traverse)InternalTraversal)traverse) Traversible)exc) inspection)utilc[R"[RU5n[ U[ U5[ RURS9$)anReturn the clause ``expression COLLATE collation``. e.g.:: collate(mycolumn, 'utf8_bin') produces:: mycolumn COLLATE utf8_bin The collation expression is also quoted if it is a case sensitive identifier, e.g. contains uppercase characters. .. versionchanged:: 1.2 quoting is automatically applied to COLLATE expressions if they are case sensitive. type_) rexpectrExpressionElementRoleBinaryExpressionCollationClausercollatetype) expression collationexprs lC:\Users\ROHAN GUPTA\OneDrive\Desktop\mathbuddy-assessment\venv\Lib\site-packages\sqlalchemy/sql/elements.pyr'r'/sA&   E77 DD  oi()*;*;499 cl[R"[RU5nUR XUS9$)aProduce a ``BETWEEN`` predicate clause. E.g.:: from sqlalchemy import between stmt = select(users_table).where(between(users_table.c.id, 5, 7)) Would produce SQL resembling:: SELECT id, name FROM user WHERE id BETWEEN :id_1 AND :id_2 The :func:`.between` function is a standalone version of the :meth:`_expression.ColumnElement.between` method available on all SQL expressions, as in:: stmt = select(users_table).where(users_table.c.id.between(5, 7)) All arguments passed to :func:`.between`, including the left side column expression, are coerced from Python scalar values if a the value is not a :class:`_expression.ColumnElement` subclass. For example, three fixed values can be compared as in:: print(between(5, 3, 7)) Which would produce:: :param_1 BETWEEN :param_2 AND :param_3 :param expr: a column expression, typically a :class:`_expression.ColumnElement` instance or alternatively a Python scalar expression to be coerced into a column expression, serving as the left side of the ``BETWEEN`` expression. :param lower_bound: a column or Python scalar expression serving as the lower bound of the right side of the ``BETWEEN`` expression. :param upper_bound: a column or Python scalar expression serving as the upper bound of the right side of the ``BETWEEN`` expression. :param symmetric: if True, will render " BETWEEN SYMMETRIC ". Note that not all databases support this syntax. .. versionadded:: 0.9.5 .. seealso:: :meth:`_expression.ColumnElement.between` ) symmetric)rr#rr$between)r+ lower_bound upper_boundr/s r,r0r0Hs0h   E77 >D << I< FFr-cH[R"[RXS9$)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. r!)rr#rLiteralValueRole)valuer"s r,literalr6s&   E22E GGr-c[USUSSS9$)a`Create an 'OUT' parameter for usage in functions (stored procedures), for databases which support them. The ``outparam`` can be used like a regular function parameter. The "output" value will be available from the :class:`~sqlalchemy.engine.CursorResult` object via its ``out_parameters`` attribute, which returns a dictionary containing the values. NFT)r"unique isoutparam) BindParameter)keyr"s r,outparamr<s d%$ OOr-ct[R"[R"[R U55$)zReturn a negation of the given clause, i.e. ``NOT(clause)``. The ``~`` operator is also overloaded on all :class:`_expression.ColumnElement` subclasses to produce the same result. )rinvrr#rr$clauses r,not_rAs& ==))%*E*EvN OOr-c\rSrSrSrSr\R"5rSr Sr /r Sr Sr SrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSr Sr!Sr"S r#S r$S r%\&S 5r'\(RRS 5r*\&S5r+Sr,S"Sjr-Sr.Sr/Sr0Sr1S#Sjr2Sr3\Rh"S5\Rh"S5S$Sj55r5S%Sjr6Sr7Sr8Sr9Sr:Sr;\;rg)& ClauseElementzKBase class for elements of a programmatically constructed SQL expression. r@FdefaultNTc<[R"U5UlU$N)r immutabledict_propagate_attrs)selfvaluess r,_set_propagate_attrs"ClauseElement._set_propagate_attrss!% 2 26 : r-c 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__copyitems _is_clone_of)rJkwskipckvccs r,r 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. )rJ negated_op original_ops r,_negate_in_binaryClauseElement._negate_in_binary  r-cU$)zin the context of binary expression, convert the type of this object to the one given. applies only to :class:`_expression.ColumnElement` classes. r^rJr"s r,_with_binary_element_type'ClauseElement._with_binary_element_typercr-cUR$)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. rPrJs r, _constructorClauseElement._constructors~~r-c~[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_setaddrU)rJsfs r, _cloned_setClauseElement._cloned_set&s> OO  m EE!HAmr-c[S5e)NzFThis SQL expression has no entity namespace with which to filter from.)AttributeErrorrjs r,entity_namespaceClauseElement.entity_namespace=s )  r-cURR5nURSS5 URSS5 U$)NrU_generate_cache_key)rRrSpop)rJds r, __getstate__ClauseElement.__getstate__Ds6 MM    nd# #T*r-cU(dUR(aURXX45$[R"U5erG)supports_execution_execute_clauseelementrObjectNotExecutableError)rJ connection multiparamsparamsexecution_options_forces r,_execute_on_connection$ClauseElement._execute_on_connectionJs: T,,446 ..t4 4r-c&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_paramsrJ optionaldictkwargss r, unique_paramsClauseElement.unique_paramsTs##D,??r-c&URSX5$)atReturn 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 r,rClauseElement.params`s##E<@@r-c^^[U5S:XaTRUS5 O%[U5S:a[R"S5eUU4Sjn[ USSS.SU05$)Nrrz9params() takes zero or one positional dictionary argumentc>URT;aTURUlSUlT(aUR5 ggNF)r;r5required_convert_to_unique)bindrr8s r,visit_bindparam6ClauseElement._replace_params..visit_bindparamzs:xx6!#DHH- % '')r-T) maintain_keydetect_subquery_cols bindparam)lenupdater ArgumentErrorr)rJr8rrrs ` ` r,rClauseElement._replace_paramsqsj |  ! MM,q/ *   "##K  * !4 @ / *  r-c 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`). )rcompare)rJotherrVs r,rClauseElement.compares!!$444r-cU$)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. r^rJagainsts r, self_groupClauseElement.self_groups 2 r-cU$)zFReturn this :class:`_expression.ClauseElement` without any groupings. r^rjs r,_ungroupClauseElement._ungroups  r-zsqlalchemy.engine.defaultzsqlalchemy.engine.urlc U(dU(a URnOUR(aURRnOURS:Xa+[RR nUR 5nOR[RRnURRUR5R5"5nUR"U40UD6$)a;Compile 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 ``Engine`` or ``Connection`` from which a ``Compiled`` will be acquired. This argument takes precedence over this :class:`_expression.ClauseElement`'s bound engine, if any. :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 ``Dialect`` instance from which a ``Compiled`` will be acquired. This argument takes precedence over the `bind` argument as well as this :class:`_expression.ClauseElement` 's bound engine, if any. :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})) .. versionadded:: 0.9.0 .. seealso:: :ref:`faq_sql_expression_string` rE) dialectrstringify_dialectr preloadedengine_defaultStrCompileDialect engine_urlURLcreate get_dialect _compiler)rJrrrVrEurls r,compileClauseElement.compilesb,,))++))Y6"nn;;G%779G..33C!ggnn..!km$&G~~g,,,r-c Ub"UR(aUR5nOSnU(agUupUU[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_keysfor_executemanyschema_translate_map) _supports_statement_cacherytupleboolget CACHE_MISSr CACHE_HITNO_DIALECT_SUPPORTCACHING_DISABLED NO_CACHE_KEY) rJrcompiled_cacherrrrVelem_cache_keyrextracted_paramsr; compiled_sql cache_hits r,_compile_w_cacheClauseElement._compile_w_caches$  %'*K*K!557N!N *8 'Ik")* C*--c2L##.. #~~ , +$3)=      '3s##-- # >>(' /%9   L44#66 '#44 #00 y88r-c (UR"X40UD6$)zFReturn a compiler appropriate for this ClauseElement, given a Dialect.)statement_compiler)rJrrVs r,rClauseElement._compiler3s))'>2>>r-c[R(a[UR55$[ UR55R SS5$Nasciibackslashreplace)rpy3kstrrunicodeencoderjs r,__str__ClauseElement.__str__9s> 99t||~& &4<<>*11+ r-c\[US5(a UR$UR5$)Nnegation_clause)hasattrr_negaterjs r, __invert__ClauseElement.__invert__As* 4* + +'' '<<> !r-ch[UR[RS9[RS9$)Nr)operator)UnaryExpressionrrr>rjs r,rClauseElement._negateIs' OOIMMO 2Y]]  r-c[S5eNz+Boolean value of this clause is not defined) TypeErrorrjs r,__bool__ClauseElement.__bool__NsEFFr-cURnUc[RU5$SURURR [ U5U4-$)Nz<%s.%s at 0x%x; %s>) descriptionobject__repr__ __module__rP__name__id)rJfriendlys r,rClauseElement.__repr__SsR##  ??4( ((''4 , r-)rIFrG)NN)NNFN)?rr __qualname____firstlineno____doc____visit_name__rrHrIrr _from_objectsrrrUis_clause_element is_selectable!_gen_static_annotations_cache_key _is_table _is_textual_is_from_clause_is_returns_rows_is_text_clause_is_from_container_is_select_container_is_select_statement_is_bind_parameter_is_clause_list_is_lambda_element_is_singleton_constant _is_immutable_is_star_order_by_label_element_cache_key_traversalrLr rarfpropertyrkrmemoized_attributerrrvr|rrrrrrrpreload_modulerrrrrrr __nonzero__r__static_attributes__r^r-r,rCrCs N))+ !M DKLM(-%IKOO  O"MH"8  ##$,  JO5 @A" , 56 45 01>-26>-F! 89t? " GK r-rCc^\rSrSrSrSrSr/rSrSr Sr \ RS5r \S5r\S 5r\S 5rS rS rSrSrS-S jrU4S jr\R2S5r\ RS5rSrSrSrSrS.Sjr \S5r!\S5r"\R2S5r#\R2S5r$Sr%Sr&Sr'\ RS5r(\ RS5r)S/Sjr*Sr+S r,S-S!jr-\R2S"5r.\R2S#5r/\\R`"S$S%5S&55r1\\R`"S$S'5S(55r2S)r3\R2S*5r4\R2S+5r5S,r6Sr7U=r8$)0 ColumnElementi`a Represent 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`:: >>> from sqlalchemy.sql import column >>> column('a') + column('b') >>> print(column('a') + column('b')) a + b .. seealso:: :class:`_schema.Column` :func:`_expression.column` column_elementFr^NcUR$)a$A label-based version of 'key' that in some circumstances refers to this object in a Python namespace. _tq_key_label comes into play when a select() statement is constructed with apply_labels(); in this case, all Column objects in the ``.c`` collection are rendered as _ in SQL; this is essentially the value of ._label. But to locate those columns in the ``.c`` collection, the name is along the lines of _; that's the typical value of .key_label. .. versionchanged:: 1.4.21 renamed from ``._key_label`` ) _proxy_keyrjs r, _tq_key_labelColumnElement._tq_key_labels r-cUR$)z legacy; renamed to _tq_key_label)rrjs r, _key_labelColumnElement._key_labels!!!r-cUR$)zlegacy; renamed to _tq_label) _tq_labelrjs r,_labelColumnElement._labels~~r-c[USS5$)athe 'name' that naturally applies this element when rendered in SQL. Concretely, this is the "name" of a column or a label in a SELECT statement; ```` and ```` below:: SELECT FROM table SELECT column AS FROM table Above, the two names noted will be what's present in the DBAPI ``cursor.description`` as the names. If this attribute returns ``None``, it means that the SQL element as written does not have a 100% fully predictable "name" that would appear in the ``cursor.description``. Examples include SQL functions, CAST functions, etc. While such things do return names in ``cursor.description``, they are only predictable on a database-specific basis; e.g. an expression like ``MAX(table.col)`` may appear as the string ``max`` on one database (like PostgreSQL) or may appear as the whole expression ``max(table.col)`` on SQLite. The default implementation looks for a ``.name`` attribute on the object, as has been the precedent established in SQLAlchemy for many years. An exception is made on the ``FunctionElement`` subclass so that the return value is always ``None``. .. versionadded:: 1.4.21 nameN)getattrrjs r,_non_anon_labelColumnElement._non_anon_labelsDtVT**r-Tc~U[R[R[R4;aZURR [ RR La)[U[R[R5$U[R[R4;a [U5$U$rG)rand_or__asboolr(_type_affinityr BOOLEANTYPE AsBooleanis_trueis_falseany_opall_opGroupingrs r,rColumnElement.self_group1s   y7H7HI I ((H,@,@,O,OOT9#4#4i6H6HI I ))9+;+;< <D> !Kr-c>URR[RRLa)[ U[ R [ R5$[[U]+5$rG) r(r,r r-r.rr0r/superrrrJrPs r,rColumnElement._negate<sL 99 # #x';';'J'J JT9#5#5y7H7HI I57 7r-c"[R$rGr NULLTYPErjs r,r(ColumnElement.typeB   r-cURRnU"U5$![a5n[R"[ SUR-5US9 SnAgSnAff=f)NzOObject %r associated with '.type' attribute is not a TypeEngine class or objectreplace_context)r(comparator_factoryrurraise_r)rJrAerrs r, comparatorColumnElement.comparatorFsa ,!%!=!= &d+ +  KK:<@IIF!$   s A+AAc:URRU5 grG)rRrrJstates r, __setstate__ColumnElement.__setstate__Us U#r-c [URU5$![adn[R"[S[ U5R <S[ UR5R <SU<35US9 SnAgSnAff=f)NzNeither z object nor z object has an attribute r?)r%rDrurrBr(r)rJr;rCs r, __getattr__ColumnElement.__getattr__Xsj 4??C0 0  KKT ++T__-66 !$  s BABBc.U"UR/UQ70UD6$rGrDrJoprrs r,operateColumnElement.operatehs$//4E4V44r-c (U"X R40UD6$rGrOrPs r,reverse_operateColumnElement.reverse_operateks%3F33r-c 4[SUUUURSUS9$)NT)_compared_to_operatorr"_compared_to_typer8 expanding)r:r(rJrobjr"rZs r, _bind_paramColumnElement._bind_paramns(  "*"ii  r-cU$)zNReturn a column expression. Part of the inspection interface; returns self. r^rjs r,r)ColumnElement.expressionyrcr-cU4$rGr^rjs r,_select_iterableColumnElement._select_iterable wr-cP[R"SUR55$)Nc3J# UHoR(aMUv M g7frG)_proxies).0rXs r, -ColumnElement.base_columns..sK.Q qq.s# #)rrn proxy_setrjs r, base_columnsColumnElement.base_columnssK$..KKKr-c[R"UR5/5nURHnUR UR 5 M U$rG)rrn _deannotatergrrkrJrprXs r,rkColumnElement.proxy_sets? OOT--/0 1A HHQ[[ !r-cpU/nURH"nURUR55 M$ U$)zAn 'uncached' version of proxy set. This is so that we can read annotations from the list of columns without breaking the caching of the above proxy_set. )rgextend_uncached_proxy_listrps r,rt"ColumnElement._uncached_proxy_lists3FA HHQ++- .r-c^[URRUR55$)z}Return True if the given :class:`_expression.ColumnElement` has a common ancestor to this :class:`_expression.ColumnElement`.)rrk intersection)rJ othercolumns r,shares_lineageColumnElement.shares_lineages$DNN// 0E0EFGGr-c[US5=(a, [US5=(a URUR:H$)z`Return True if the given column element compares to this one when targeting within a result row.r$)rr$rJrs r,_compare_name_for_result&ColumnElement._compare_name_for_results7 E6 " (f% ( dii' r-cUR(aSUR;aURS$URnU(d URn[U[5(agU$)N proxy_key) _annotationsr;r& isinstance_anonymous_labelrJr$s r,rColumnElement._proxy_keysX   0A0A!A$$[1 1xx ''D d, - -Kr-c[USS5bgUR(aSUR;aURS$g)a4a suggested label to use in the case that the column has no name, which should be used if possible as the explicit 'AS