HEX

File: //usr/local/lib/python3.10/dist-packages/sqlalchemy/sql/__pycache__/elements.cpython-310.pyc
o

���g/��@s�
dZddlmZddlmZddlmZddlZddlZddl	Z	ddl
Z
ddl
mZddl
mZddl
m
Z
dd	l
mZdd
l
mZddl
mZddl
mZdd
l
mZddl
mZddl
mZddl
mZddl
mZddl
mZddl
mZddl
mZddl
mZddl
mZddl
mZddl
mZddl
mZddl m!Z!ddl m"Z"ddl m#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&l.m/Z/dd'l.m0Z0dd(l.m1Z1dd)l.m2Z2dd*l.m3Z3dd+l.m4Z4dd,l.m5Z5dd-l.m6Z6dd.l.m7Z7dd/l.m8Z8dd0l9m:Z:dd1l9m;Z;dd2l!m<Z<dd3l"m=Z=dd4l$m>Z>dd5l?m@Z@dd6l?mAZAdd7l?mBZBdd8l?mCZCdd9l?mDZDd:d;l mEZEd:d<l mFZFd:d=l mGZGd:d>lGmHZHd:d?lGmIZId:d@lJmKZKd:dAlJmLZLd:dBlJmMZMe
j�r\ddCl&mNZNddDl&mOZOddEl&mPZPddFl&mQZQddGl&mRZRddHl&mSZSddIl&mTZTddJl.mUZUddKl9mVZVddLl9mWZWddMlXmYZYddNlXmZZZddOl[m\Z\ddPl"m]Z]ddQl^m_Z_ddRl^m`Z`ddSl^maZaddTl^mbZbddUlcmdZdddVlcmeZeddWlcmfZfddXlcmgZgddYlhmiZiddZl%mjZjdd[l?mkZkdd\l?mlZldd]l?mmZmd:d^lnmoZod:d_lnmpZpd:d`lqmrZrd:dalqmsZsd:dblqmtZtd:dclqmuZud:ddlqmvZvd:delwmxZxeeyefZzeeye{efZ|edfdgdh�Z}ediedjdk�Z~edldgdh�Zedmdndh�Z�edodpdh�Z�e	q�d�ddydz��Z�e		q�d�dd|dz��Z�e		q�d�dddz��Z�		q�d�dd�dz�Z�	�d�dd�d��Z�Gd�d��d�eD�Z�eFj�Gd�d��d�e-e:e>eAe���Z�Gd�d��d�e��Z�Gd�d��d�e#j�e#j�e#j�e��Z�Gd�d��d�ee~e=eI�Z�Gd�d��d�e�e~e#j�e~eI�Z�e�Z�Gd�d��d�e#j�e#j�e#j�e#j�e}e#j�e#j�e#j�e#j�e#j�e#j�e�e}e��Z�Gd�d��d�e�e}�Z�Gd�d��d�e�e}�Z�Gd�d��d�e#j�e�e}�Z�Gd�d��d�e��Z�Gd�d��d�e#j�e#j�e#j�e#j�e#j�e#j�e#j�e#j�e4e3e�e#j�eeFj�d��Z�Gd�d��d�e8e#j�de�d�Z�e����Gd�d��d�e8e#j�e�e�e��Z�e����Gd�d��d�e8e#j�e�e�e��Z�e����Gd�d��d�e#j�e#j�e#j�e#j�e��Z�Gd�d��d�e�e}�Z�Gd�d��d�e�e}�Z�Gd�d��d�e�e��Z�e�j�Z�e�j�Z�Gd�d��d�e�e�eed�f�ZGd�d��d�e�e}�Z�Gd�d��d�e�e}�Z�Gd�d��d�e�e}�Z�Gd�d��d�e�e}�Z�Gd�d��d�e�e{�Z�Gd�d��d�e�e}�Z�Gd�d��d�e�e�Z�Gd�d��d�e�e}�Z�Gd�d��d�e�e}�Z�Gd�dÄd�e�e�e�e��Z�Gd�dńd�e�e}�Z�Gd�dǄd�e�e�Z�Gd�dɄd�e�e�Z�Gd�d˄d�e��Z�Gd�d̈́d�e�e�e}�Z�Gd�dτd�e�e}�Z�Gd�dфd�e�Z�e�j�Z�e�j�Z�ee{e�fZ�Gd�dӄd�e�e}�Z�Gd�dՄd�e�e}�Z�Gd�dׄd�e4e�e}�Z�Gd�dلd�e�e}�Z�eLdڃZ�Gd�d܄d�e#j�e}e�e}�Z�Gd�dބd�e#j�e#j�e}e#j�e6e�e}�Z�Gd�d�d�e�e}�Z�Gd�d�d�e�e��Z�Gd�d�d�e3e��Z�Gd�d�d�e΃Z�Gd�d�d�e΃Z�Gd�d�d�e΃Z�Gd�d�d�eGj�ẽZӐd	d�d�ZԐd
d�d��ZՐdd�d��Z�Gd�d��d�eGj�d��Z�Gd�d��d�e,�Z�Gd�d��d�eӃZ�Gd�d��d�eڃZ�e�Z�G�d�d��deڃZ�dS(z�Core 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)rf�	covariant�_OPT�_NT�_NUMERIC�_NMT�_NUMBERF�value�type_�_TypeEngineArgument[_T]�literal_execute�bool�return�BindParameter[_T]cC�dS�N��rnrorqrwrw�B/usr/local/lib/python3.10/dist-packages/sqlalchemy/sql/elements.py�literal��rz�NonecCrurvrwrxrwrwryrz�r{�"Optional[_TypeEngineArgument[Any]]�BindParameter[Any]cCrurvrwrxrwrwryrz�r{cCstjtj|||d�S)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

    )rorq)r�expectr�LiteralValueRolerxrwrwryrz�s��text�str�!Optional[_TypeEngineArgument[_T]]�ColumnClause[_T]cCst||dd�S)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)ro�
is_literal��ColumnClause)r�rorwrwry�literal_column�s#r�c@sXeZdZdZdZdZdZdZe�	d�e�	d�		dddd���Z
ddd�Zddd�ZdS)�CompilerElementznbase class for SQL elements that can be compiled to produce a
    SQL string.

    .. versionadded:: 2.0

    rw�compiler_elementF�defaultzsqlalchemy.engine.defaultzsqlalchemy.engine.urlN�bind�Optional[_HasDialect]�dialect�Optional[Dialect]�kwrrsrLcKs^|dur&|r
|j}n|jdkrtjj}|��}ntjj}|j�|j��	��}|j
|fi|��S)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 :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`

        Nr�)r��stringify_dialectr<�	preloaded�engine_default�StrCompileDialect�
engine_url�URL�create�get_dialect�	_compiler)�selfr�r�r�r��urlrwrwry�compile�s4

��zCompilerElement.compiler^cKs&tr	t|t�s	J�|j||fi|��S)zNReturn a compiler appropriate for this ClauseElement, given a
        Dialect.)r�
isinstance�
ClauseElement�statement_compiler�r�r�r�rwrwryr�7szCompilerElement._compilerr�cCst|���Srv)r�r��r�rwrwry�__str__?�zCompilerElement.__str__�NN)r�r�r�r�r�rrsrL)r�r^r�rrsrL�rsr�)
�__name__�
__module__�__qualname__�__doc__�	__slots__�__visit_name__�supports_executionr�r<�preload_moduler�r�r�rwrwrwryr��s�
@r�c@s�eZdZUdZdZerejdqdd��Znej	Zej
drdd	��Zd
Zde
d<d
ZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZ dZ!dZ"e#dsdd��Z$d
Z%de
d<de
d<e&jrkdd�dtdd�Z'ej(dud d!��Z)dvd%d&�Z*dwd'd(�Z+d)d*�Z,d+d,�Z-e#d-d.��Z.e/j0d/d0��Z1d1d2�Z2e#d3d4��Z3d5d6�Z4dxd>d?�Z5dyd@dA�Z6dzdCdD�Z7	
d{d|dHdI�Z8	
d{d}dKdL�Z9d~dQdR�Z:ddTdU�Z;	
d{d�dXdY�Z<d�dZd[�Z=dd
d\�d�dgdh�Z>didj�Z?d�dkdl�Z@dmdn�ZAdodp�ZBd
S)�r�zSBase class for elements of a programmatically constructed SQL
    expression.

    �clausersrGcC�dS)z�like annotations, however these propagate outwards liberally
            as SQL constructs are built, and are set up at construction time.

            Nrwr�rwrwry�_propagate_attrsTszClauseElement._propagate_attrs�
Optional[str]cCrurvrwr�rwrwry�description_�zClauseElement.descriptionNzOptional[Self]�_is_clone_ofTF�Optional[Label[Any]]cCrurvrwr�rwrwry�_order_by_label_element{r�z%ClauseElement._order_by_label_elementrJ�_cache_key_traversal�ColumnElement[bool]�negation_clause.)�
omit_attrsr��typing_Tuple[str, ...]r�r�Iterable[ClauseElement]cKrurvrw)r�r�r�rwrwry�get_children�r�zClauseElement.get_children�List[FromClause]cC�gSrvrwr�rwrwry�
_from_objects�r�zClauseElement._from_objects�values�Mapping[str, Any]rAcCst�|�|_|Srv)r<�
immutabledictr�)r�r�rwrwry�_set_propagate_attrs�sz"ClauseElement._set_propagate_attrscsf|j�|j�|j�}�r�fdd�|j����D�|_n|j��|_|j}|dur.||_|S||_|S)z�Create 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.

        csi|]\}}|�vr||�qSrwrw��.0�k�v��skiprwry�
<dictcomp>�sz(ClauseElement._clone.<locals>.<dictcomp>N)�_memoized_keys�	__class__�__new__�__dict__�copy�itemsr�)r�r��c�ccrwr�ryr%�s	

��zClauseElement._clonecC�|S)z�a 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.

        rw)r��
negated_op�original_oprwrwry�_negate_in_binary��zClauseElement._negate_in_binarycCr�)z�in the context of binary expression, convert the type of this
        object to the one given.

        applies only to :class:`_expression.ColumnElement` classes.

        rw�r�rorwrwry�_with_binary_element_type�r�z'ClauseElement._with_binary_element_typecC�|jS)a.return 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.

        �r�r�rwrwry�_constructor�s
zClauseElement._constructorcCs0t��}|}|dur|�|�|j}|dus
|S)aReturn 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.

        N)r<�
column_set�addr�)r��s�frwrwry�_cloned_set�s

�zClauseElement._cloned_setcCs|jdur
|j}|jdus|Srv)r�r�rwrwry�	_de_clone�s

�zClauseElement._de_clonecC�td��)NzFThis SQL expression has no entity namespace with which to filter from.)�AttributeErrorr�rwrwry�entity_namespace�s�zClauseElement.entity_namespacecCs&|j��}|�dd�|�dd�|S)Nr��_generate_cache_key)r�r��pop)r��drwrwry�__getstate__�s
zClauseElement.__getstate__�
connectionr]�distilled_paramsr_�execution_optionsrb�Result[Any]cCs0|jrtrt|t�sJ�|�|||�St�|��rv)r�rr�r)�_execute_clauseelementr:�ObjectNotExecutableError�r�r�r�r�rwrwry�_execute_on_connection�s�
z$ClauseElement._execute_on_connectioncCs|�|||���S)z�an additional hook for subclasses to provide a different
        implementation for connection.scalar() vs. connection.execute().

        .. versionadded:: 2.0

        )r��scalarr�rwrwry�_execute_on_scalar
s
��z ClauseElement._execute_on_scalar�Sequence[BindParameter[Any]]cCs0|��}|durg}t|id|ji�|S|jS)a�Return 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.

        N�	bindparam)r�r7�append�
bindparams)r��keyr�rwrwry�_get_embedded_bindparamssz&ClauseElement._get_embedded_bindparams�_ClauseElement__optionaldict�Optional[Dict[str, Any]]�kwargscK�|�d||�S)aReturn 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_params�r�r�r�rwrwry�
unique_params0szClauseElement.unique_params�Optional[Mapping[str, Any]]cKr�)a�Return 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}

        Fr�rrwrwry�params@szClauseElement.params�uniquerr�optionaldict�Dict[str, Any]cs4|r��|�d
��fdd�}t|ddd�d	|i�S)Nr�r~rsr|cs0|j�vr�|j|_d|_�r|��dSdS�NF)r�rn�required�_convert_to_unique)r��r�rrwry�visit_bindparam^s
�z6ClauseElement._replace_params.<locals>.visit_bindparamT)�maintain_key�detect_subquery_colsr�)r�r~rsr|)�updater4)r�rrr�rrwrryrUs
�zClauseElement._replace_params�othercKstj||fi|��S)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`).

        )r�compare�r�rr�rwrwryrkszClauseElement.compare�against�Optional[OperatorType]cCr�)a�Apply 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.
        rw�r�rrwrwry�
self_groupyszClauseElement.self_groupcCr�)zVReturn this :class:`_expression.ClauseElement`
        without any groupings.
        rwr�rwrwry�_ungroup�r{zClauseElement._ungroup)�for_executemany�schema_translate_mapr�r^�compiled_cache�Optional[CompiledCacheType]�column_keys�	List[str]rr� Optional[SchemaTranslateMapType]�Jtyping_Tuple[Compiled, Optional[Sequence[BindParameter[Any]]], CacheStats]c
Ks�|dur|jr|��}nd}|durLtr|dusJ�|\}}	||t|�t|�|f}
|�|
�}|durH|j}|j|f||||d�|��}|||
<n&|j}n"d}	|j|f||||d�|��}|jsc|j	}n|durk|j
}n|j}||	|fS)N)�	cache_keyrrr)�_supports_statement_cacher�r�tuplerr�get�
CACHE_MISSr��	CACHE_HIT�NO_DIALECT_SUPPORT�CACHING_DISABLED�NO_CACHE_KEY)
r�r�rrrrr��elem_cache_keyr �extracted_paramsr��compiled_sql�	cache_hitrwrwry�_compile_w_cache�sZ
�
���
���	
zClauseElement._compile_w_cachecCst|d�r|jS|��S)Nr�)�hasattrr��_negater�rwrwry�
__invert__�s
zClauseElement.__invert__cCs*|jtjd�}t|t�sJ�t|tjd�S)N�r��operator�rr�invr��
ColumnElement�UnaryExpression�r��groupedrwrwryr/�szClauseElement._negatecCr�)N�+Boolean value of this clause is not defined)�	TypeErrorr�rwrwry�__bool__�szClauseElement.__bool__cCs2|j}|durt�|�Sd|j|jjt|�|fS)Nz<%s.%s at 0x%x; %s>)r��object�__repr__r�r�r��id)r��friendlyrwrwryr>�s
�zClauseElement.__repr__�rsrG�rsr��rsr�)r�r�r�rrsr��rsr�)r�r�rsrA)r�rrsrA)r�r]r�r_r�rbrsr�)r�r]r�r_r�rbrsr)rsr�rv)r�r�r�rrsrA)r�rr�rrsrA)rrrrrr�rrsrA)rr�r�rrsrr)rrrsr�)rsr�)r�r^rrrrrrrrrr�rrsr)Cr�r�r�r�r�rr<�memoized_propertyr��
EMPTY_DICT�ro_memoized_propertyr�r��__annotations__�is_clause_element�
is_selectable�is_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_star�propertyr�r��typingr��ro_non_memoized_propertyr�r�r%r�r�r�r+�memoized_attributer�r�r�r�r�r�r�rrrrrrr-r0r/r<r>rwrwrwryr�Cs�
�


		





��

�

�B
r�c@s4eZdZdZejrddd	�Z	
	
dddd�Zd
Sd
S)�DQLDMLClauseElementz|represents a :class:`.ClauseElement` that compiles to a DQL or DML
    expression, not DDL.

    .. versionadded:: 2.0

    r�r^r�rrsrMcKr�)zRReturn a compiler appropriate for this ClauseElement, given a
            Dialect.Nrwr�rwrwryr��zDQLDMLClauseElement._compilerNr�r�r�cKrurvrw)r�r�r�r�rwrwryr�r{zDQLDMLClauseElement.compile)r�r^r�rrsrMr�)r�r�r�r�r�rrsrM)r�r�r�r�r_rr�r�rwrwrwryrb�s
��rbc@seZdZdZdZejZdZdS)�CompilerColumnElementzdA compiler-only column element used for ad-hoc string compilations.

    .. versionadded:: 2.0

    rwFN)	r�r�r�r�r�r<rFr��_is_collection_aggregaterwrwrwryrds
rdc@s�eZdZdZej�r�ejd�dd��Zd�dd
�Z	d�dd�Z
e		d�dd�d�dd��Ze				d�d�d"d��Z	#	$		d�d�d%d�Z	#	d�d�d'd(�Z
d�d*d+�Zd�d,d-�Zd�d/d0�Zd�d2d3�Zd�d4d5�Zd�d6d7�Zd�d8d9�Zd�d:d;�Zd�d<d=�Zd�d>d?�Zd�d@dA�Zd�dBdC�Zd�dEdF�Zd�dGdH�Zd�dJdK�Ze�ddOdP��Ze�ddQdP��Z�ddRdP�Ze�ddSdT��Ze�ddUdT��Z�ddVdT�Ze�ddYdZ��Ze�dd[dZ��Z�dd\dZ�Z	�d�dd`da�Z 	�d�ddbdc�Z!�ddedf�Z"�ddgdh�Z#�ddidj�Z$d�dkdl�Z%�ddmdn�Z&�ddodp�Z'�ddrds�Z(�ddtdu�Z)�ddvdw�Z*	�d�ddxdy�Z+	�d�ddzd{�Z,	�d�dd|d}�Z-	�d�dd~d�Z.�dd�d��Z/�dd�d��Z0�dd�d��Z1		$�d�d	d�d��Z2		$�d�d	d�d��Z3		$�d�d	d�d��Z4		$�d�d	d�d��Z5�d
d�d��Z6�d
d�d��Z7�dd�d��Z8	�d�dd�d��Z9	�d�d
d�d��Z:d�d�d��Z;d�d�d��Z<d�d�d��Z=d�d�d��Z>d�d�d��Z?d�d�d��Z@�dd�d��ZA	$�d�dd�d��ZB�dd�d��ZC�dd�d��ZD�dd�d��ZEe�dd�d���ZFe�dd�d���ZFe�dd�d���ZF�dd�d��ZFe�dd�d�ZGe�dd�d�ZG�dd�dZGe�dd�dƄ�ZHe�dd�dƄ�ZH�dd�dƄZHe�dd�dʄ�ZIe�dd�dʄ�ZI�dd�dʄZIe�dd�d΄�ZJe�dd�d΄�ZJ�dd�d΄ZJe�dd�d҄�ZKe�dd�d҄�ZK�dd�d҄ZKe�dd�dք�ZLe�dd�dք�ZL�dd�dքZLe�dd�dڄ�ZMe�dd�dڄ�ZM�dd�dڄZMe�dd�d߄�ZNe�dd�d߄�ZNe�dd�d߄�ZN�dd�d߄ZNe�dd�d��ZOe�dd�d��ZO�dd�d�ZOe�dd�d��ZPe�dd�d��ZP�dd�d�ZPe�dd�d��ZQe�dd�d��ZQ�dd�d�ZQdSdS(�SQLCoreOperationsrwrsrGcCrurvrwr�rwrwryr�0�z"SQLCoreOperations._propagate_attrs�oprOrrr��ColumnElement[Any]cOrurvrw�r�rhrr�rwrwry�operate3r�zSQLCoreOperations.operatecKrurvrwrjrwrwry�reverse_operate7r�z!SQLCoreOperations.reverse_operate.N)�python_impl�opstringr��
precedence�int�
is_comparisonrr�return_type�_TypeEngineArgument[_OPT]rm�Optional[Callable[..., Any]]�'Callable[[Any], BinaryExpression[_OPT]]cCrurvrw�r�rnrorqrrrmrwrwryrh;s	zSQLCoreOperations.opr}�&Callable[[Any], BinaryExpression[Any]]cCrurvrwrvrwrwryrhFsrFcCrurvrwrvrwrwryrhPr��'Callable[[Any], BinaryExpression[bool]]cCrurvrw)r�rnrormrwrwry�bool_opYr{zSQLCoreOperations.bool_op�BooleanClauseListcCrurvrw�r�rrwrwry�__and__`�zSQLCoreOperations.__and__cCrurvrwr{rwrwry�__or__br}zSQLCoreOperations.__or__�ColumnElement[_T_co]cCrurvrwr�rwrwryr0dr}zSQLCoreOperations.__invert__r�cCrurvrwr{rwrwry�__lt__fr}zSQLCoreOperations.__lt__cCrurvrwr{rwrwry�__le__hr}zSQLCoreOperations.__le__cCrurvrwr�rwrwry�__hash__nr}zSQLCoreOperations.__hash__cCrurvrwr{rwrwry�__eq__prgzSQLCoreOperations.__eq__cCrurvrwr{rwrwry�__ne__srgzSQLCoreOperations.__ne__cCrurvrwr{rwrwry�is_distinct_fromvr}z"SQLCoreOperations.is_distinct_fromcCrurvrwr{rwrwry�is_not_distinct_fromxr}z&SQLCoreOperations.is_not_distinct_fromcCrurvrwr{rwrwry�__gt__zr}zSQLCoreOperations.__gt__cCrurvrwr{rwrwry�__ge__|r}zSQLCoreOperations.__ge__�UnaryExpression[_T_co]cCrurvrwr�rwrwry�__neg__~r}zSQLCoreOperations.__neg__cCrurvrwr{rwrwry�__contains__�r}zSQLCoreOperations.__contains__�indexcCrurvrw)r�r�rwrwry�__getitem__�r}zSQLCoreOperations.__getitem__r��	_SQO[int]�ColumnElement[int]cCrurvrwr{rwrwry�
__lshift__�rgzSQLCoreOperations.__lshift__cCrurvrwr{rwrwryr��rgcCrurvrwr{rwrwryr��r}cCrurvrwr{rwrwry�
__rshift__�rgzSQLCoreOperations.__rshift__cCrurvrwr{rwrwryr��rgcCrurvrwr{rwrwryr��r}�	_SQO[str]�ColumnElement[str]cCrurvrwr{rwrwry�concat�rgzSQLCoreOperations.concatcCrurvrwr{rwrwryr��rgcCrurvrwr{rwrwryr��r}�escaper��BinaryExpression[bool]cCrurvrw�r�rr�rwrwry�like�r�zSQLCoreOperations.likecCrurvrwr�rwrwry�ilike�r�zSQLCoreOperations.ilike�BinaryExpression[Any]cCrurvrwr{rwrwry�bitwise_xor�r}zSQLCoreOperations.bitwise_xorcCrurvrwr{rwrwry�
bitwise_or�r}zSQLCoreOperations.bitwise_orcCrurvrwr{rwrwry�bitwise_and�r}zSQLCoreOperations.bitwise_andcCrurvrwr�rwrwry�bitwise_not�r}zSQLCoreOperations.bitwise_notcCrurvrwr{rwrwry�bitwise_lshift�r}z SQLCoreOperations.bitwise_lshiftcCrurvrwr{rwrwry�bitwise_rshift�r}z SQLCoreOperations.bitwise_rshift�=Union[Iterable[Any], BindParameter[Any], roles.InElementRole]cCrurvrwr{rwrwry�in_�r{zSQLCoreOperations.in_cCrurvrwr{rwrwry�not_in�r{zSQLCoreOperations.not_incCrurvrwr{rwrwry�notin_�r{zSQLCoreOperations.notin_cCrurvrwr�rwrwry�not_like�r�zSQLCoreOperations.not_likecCrurvrwr�rwrwry�notlike�r�zSQLCoreOperations.notlikecCrurvrwr�rwrwry�	not_ilike�r�zSQLCoreOperations.not_ilikecCrurvrwr�rwrwry�notilike�r�zSQLCoreOperations.notilikecCrurvrwr{rwrwry�is_�r}zSQLCoreOperations.is_cCrurvrwr{rwrwry�is_not�r}zSQLCoreOperations.is_notcCrurvrwr{rwrwry�isnot�r}zSQLCoreOperations.isnot�
autoescapecCrurvrw�r�rr�r�rwrwry�
startswith�r{zSQLCoreOperations.startswithcCrurvrwr�rwrwry�istartswith�r{zSQLCoreOperations.istartswithcCrurvrwr�rwrwry�endswith�r{zSQLCoreOperations.endswithcCrurvrwr�rwrwry�	iendswith�r{zSQLCoreOperations.iendswithr�cKrurvrwrrwrwry�contains�r}zSQLCoreOperations.containscKrurvrwrrwrwry�	icontains�r}zSQLCoreOperations.icontainscKrurvrw)r�rr�rwrwry�match�r}zSQLCoreOperations.match�pattern�flagscCrurvrw)r�r�r�rwrwry�regexp_match�r�zSQLCoreOperations.regexp_match�replacementcCrurvrw)r�r�r�r�rwrwry�regexp_replacer�z SQLCoreOperations.regexp_replacecCrurvrwr�rwrwry�descr}zSQLCoreOperations.desccCrurvrwr�rwrwry�ascr}zSQLCoreOperations.asccCrurvrwr�rwrwry�nulls_first	r}zSQLCoreOperations.nulls_firstcCrurvrwr�rwrwry�
nullsfirstr}zSQLCoreOperations.nullsfirstcCrurvrwr�rwrwry�
nulls_last
r}zSQLCoreOperations.nulls_lastcCrurvrwr�rwrwry�	nullslastr}zSQLCoreOperations.nullslast�	collation�CollationClausecCrurvrw�r�r�rwrwry�collater}zSQLCoreOperations.collate�cleft�cright�	symmetriccCrurvrw)r�r�r�r�rwrwry�betweenr�zSQLCoreOperations.between�_SQO[_T_co]cCrurvrwr�rwrwry�distinctr}zSQLCoreOperations.distinct�CollectionAggregate[Any]cCrurvrwr�rwrwry�any_r}zSQLCoreOperations.any_cCrurvrwr�rwrwry�all_r}zSQLCoreOperations.all_�
_SQO[_NMT]�ColumnElement[_NMT]cCrurvrwr{rwrwry�__add__"�zSQLCoreOperations.__add__cCrurvrwr{rwrwryr�(r�cCrurvrwr{rwrwryr�.rgcCrurvrwr{rwrwryr�1r}cCrurvrwr{rwrwry�__radd__3rgzSQLCoreOperations.__radd__cCrurvrwr{rwrwryr�6rgcCrurvrwr{rwrwryr�9r}cCrurvrwr{rwrwry�__sub__;r�zSQLCoreOperations.__sub__cCrurvrwr{rwrwryr�ArgcCrurvrwr{rwrwryr�Dr}cCrurvrwr{rwrwry�__rsub__Fr�zSQLCoreOperations.__rsub__cCrurvrwr{rwrwryr�LrgcCrurvrwr{rwrwryr�Or}cCrurvrwr{rwrwry�__mul__Qr�zSQLCoreOperations.__mul__cCrurvrwr{rwrwryr�WrgcCrurvrwr{rwrwryr�Zr}cCrurvrwr{rwrwry�__rmul__\r�zSQLCoreOperations.__rmul__cCrurvrwr{rwrwryr�brgcCrurvrwr{rwrwryr�er}cCrurvrwr{rwrwry�__mod__grgzSQLCoreOperations.__mod__cCrurvrwr{rwrwryr�jrgcCrurvrwr{rwrwryr�mr}cCrurvrwr{rwrwry�__rmod__orgzSQLCoreOperations.__rmod__cCrurvrwr{rwrwryr�rrgcCrurvrwr{rwrwryr�ur}�ColumnElement[_NUMERIC]cCrurvrwr{rwrwry�__truediv__wrczSQLCoreOperations.__truediv__�	_SQO[_NT]�ColumnElement[_NT]cCrurvrwr{rwrwryr�|rgcCrurvrwr{rwrwryr�rgcCrurvrwr{rwrwryr��r}cCrurvrwr{rwrwry�__rtruediv__�rczSQLCoreOperations.__rtruediv__cCrurvrwr{rwrwryr��rgcCrurvrwr{rwrwryr��r}cCrurvrwr{rwrwry�__floordiv__�rczSQLCoreOperations.__floordiv__cCrurvrwr{rwrwryr��rgcCrurvrwr{rwrwryr��r}cCrurvrwr{rwrwry�
__rfloordiv__�rczSQLCoreOperations.__rfloordiv__cCrurvrwr{rwrwryr��rgcCrurvrwr{rwrwryr��r}rA)rhrOrrr�rrsri)..)rnr�rorprqrrrrrsrmrtrsru)....)rnr�rorprqrrrrr}rmrtrsrw)rFNN)rN)rnr�rorprmrtrsrx)rrrsrz)rsr)rrrsr��rsrp)rsr�)r�rrsri)r�r�rrrsr�)rrrsri)r�r�rrrsr�rv)rrr�r�rsr�)rrrsr�)rr�rsr�)rrrsr�r)rrr�r�r�rrrsr�)rrr�rrsr�)rrr�rrsr�)r�rr�r�rsr�)r�rr�rr�r�rsr�)r�r�rsr��F)r�rr�rr�rrrsr�)r�r�rsr�)rsr�)r�r�rrrsr�)r�r�rrrsr�)r�r�rrrsr�)r�r�rrrsr�)Rr�r�r�r�r_rr<�non_memoized_propertyr�rkrlrrhryr|r~r0r�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�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rwrwrwryrf(sf

��
���














��
�����
�
�
���





����rfc@�eZdZdZdZdS)�SQLColumnExpressiona�A 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


    rwN�r�r�r�r�r�rwrwrwryr��sr�c@s�eZdZUdZdZdZded<ded<dZdZded	<dZ	dZ
e�Zd
ed<e
jd�dd��Ze
jd�dd��ZdZded<	ejd�dd��Zed�dd��Zed�dd��Zed�dd��ZdZ	dZ	dZdZded<ed�d�d#d$��Ze	d�d�d'd$��Z	d�d�d(d$�Zed�d+d,��Z ed�d-d,��Z d�d.d,�Z d/ed0<e!s�e
jd�d1d2��Z"ejd�d4d5��Z#d6d7�Z$d�d:d;�Z%d�d@dA�Z&d�dBdC�Z'		d�d�dJdK�Z(ed�dLdM��Z)ed�dOdP��Z*e
jd�dRdS��Z+e
jd�dTdU��Z,e
jd�dVdW��Z-d�dXdY�Z.d�d[d\�Z/d�d]d^�Z0ejd�d_d`��Z1ejd�dadb��Z2dddddc�d�dndo�Z3d�drds�Z4d�dudv�Z5	d�d�d{d|�Z6e
jd�d}d~��Z7e
jd�dd���Z8ee
�9d�d��d�d�d����Z:ee
�9d�d��d�d�d����Z;d�d�d��Z<e
jd�d�d���Z=e
jd�d�d���Z>d�d�d��Z?dS)�r6aRepresent 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")
        <sqlalchemy.sql.expression.BinaryExpression object at 0x101029dd0>
        >>> print(column("a") + column("b"))
        {printsql}a + b

    .. seealso::

        :class:`_schema.Column`

        :func:`_expression.column`

    �column_elementFrr�primary_key�Optional[ColumnElement[_T]]r�T�_insert_sentinelzAbstractSet[ForeignKey]�foreign_keysrs�List[ColumnElement[Any]]cCr�rvrwr�rwrwry�_proxies"r�zColumnElement._proxiesr�cCr�)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 <expr> AS <label> in a SELECT statement when using
        the LABEL_STYLE_TABLENAME_PLUS_COL label style, which is what the
        legacy ORM ``Query`` object uses as well.

        For a regular Column bound to a Table, this is typically the label
        <tablename>_<columnname>.  For other constructs, different rules
        may apply, such as anonymized labels and others.

        .. versionchanged:: 1.4.21 renamed from ``._label``

        Nrwr�rwrwry�	_tq_label&szColumnElement._tq_labelNr�cCr�)alA 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 <tablename>_<columnname> 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 <tablename>_<key>;
        that's the typical value of .key_label.

        .. versionchanged:: 1.4.21 renamed from ``._key_label``

        )�
_proxy_keyr�rwrwry�
_tq_key_labelCszColumnElement._tq_key_labelcCr�)z legacy; renamed to _tq_key_label)r�r�rwrwry�
_key_labelU�zColumnElement._key_labelcCr�)zlegacy; renamed to _tq_label�r�r�rwrwry�_labelZr�zColumnElement._labelcCst|dd�S)aVthe '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; ``<columnname>`` and ``<labelname>`` below:

        .. sourcecode:: sql

            SELECT <columnmame> FROM table

            SELECT column AS <labelname> 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)�getattrr�rwrwry�_non_anon_label_s$zColumnElement._non_anon_labelrwz
Sequence[str]�
_alt_namesrr|�ColumnElement[_T]cCrurvrwrrwrwryr�rgzColumnElement.self_grouprricCrurvrwrrwrwryr�rccCsP|tjtjtjfvr|jjtjjurt|tj	tj
�S|tjtjfvr&t
|�S|Srv)r�and_�or_�_asbool�type�_type_affinityr�BOOLEANTYPE�	AsBoolean�is_true�is_false�any_op�all_op�Groupingrrwrwryr�sr�r�cCrurvrwr�rwrwryr/�rgzColumnElement._negatecCrurvrwr�rwrwryr/�rgcCsL|jjtjjurt|tjtj�S|jtj	d�}t
|t�sJ�t|tj	dd�S�Nr1T)r3�wraps_column_expression)
r�r�rr�r�rrr�rr5r�r6r7r8rwrwryr/�s��TypeEngine[_T]r�cC�tjSrv�r�NULLTYPEr�rwrwryr���zColumnElement.type�TypeEngine.Comparator[_T]c
Cs<z	|jj}W||�Sty}ztd|j�|�d}~ww)NzOObject %r associated with '.type' attribute is not a TypeEngine class or object)r��comparator_factoryr�r;)r�r�errrwrwry�
comparator�s
������zColumnElement.comparatorcCs|j�|�dSrv)r�r�r��staterwrwry�__setstate__�szColumnElement.__setstate__r�rc
CsJzt|j|�WSty$}ztdt|�jt|j�j|f�|�d}~ww)Nz3Neither %r object nor %r object has an attribute %r)r�rr�r�r�)r�r�r
rwrwry�__getattr__�s
������zColumnElement.__getattr__rh�operators.OperatorTyperr�cOs||jg|�Ri|��Srv�rrjrwrwryrk�szColumnElement.operatecKs|||jfi|��Srvrrjrwrwryrl�szColumnElement.reverse_operater3�objro�Optional[TypeEngine[_T]]�	expandingrtc	C�td||||jd|d�S�NT)�_compared_to_operatorro�_compared_to_typerr��
BindParameterr��r�r3rrorrwrwry�_bind_param�s�zColumnElement._bind_paramcCr�)z^Return a column expression.

        Part of the inspection interface; returns self.

        rwr�rwrwry�
expressionr�zColumnElement.expressionrTcC�|fSrvrwr�rwrwry�_select_iterable
�zColumnElement._select_iterable�FrozenSet[ColumnElement[Any]]cCstdd�|jD��S)Ncss�|]}|js|VqdSrv)r��r�r�rwrwry�	<genexpr>s�z-ColumnElement.base_columns.<locals>.<genexpr>)�	frozenset�	proxy_setr�rwrwry�base_columnsszColumnElement.base_columnscCs&t|��g��tjdd�|jD���S)aFset of all columns we are proxying

        as of 2.0 this is explicitly deannotated columns.  previously it was
        effectively deannotated columns but wasn't enforced.  annotated
        columns should basically not go into sets if at all possible because
        their hashing behavior is very non-performant.

        cS�g|]}|j�qSrw)r(r%rwrwry�
<listcomp> �z+ColumnElement.proxy_set.<locals>.<listcomp>)r'�_deannotate�union�	itertools�chainr�r�rwrwryr(s
�zColumnElement.proxy_setcCstt|j��Srv)r'r&r(r�rwrwry�_expanded_proxy_set#sz!ColumnElement._expanded_proxy_setcCs |gttjdd�|jD���S)z�An 'uncached' version of proxy set.

        This list includes annotated columns which perform very poorly in
        set operations.

        cSsg|]}|���qSrw)�_uncached_proxy_listr%rwrwryr+0sz6ColumnElement._uncached_proxy_list.<locals>.<listcomp>)�listr/r0r�r�rwrwryr2's�z"ColumnElement._uncached_proxy_list�othercolumncCst|j�|j��S)z�Return True if the given :class:`_expression.ColumnElement`
        has a common ancestor to this :class:`_expression.ColumnElement`.)rrr(�intersection)r�r4rwrwry�shares_lineage3szColumnElement.shares_lineagecCs t|d�ot|d�o|j|jkS)zhReturn True if the given column element compares to this one
        when targeting within a result row.r�)r.r�r{rwrwry�_compare_name_for_result9s

�
�z&ColumnElement._compare_name_for_resultcCsB|jrd|jvrtt|jd�S|j}|s|j}t|t�rdS|S)N�	proxy_key)�_annotationsrr�r�r�r��_anonymous_label�r�r�rwrwryr�Cs
zColumnElement._proxy_keycCs8t|dd�dur
dS|jrd|jvrtt|jd�SdS)a\a suggested label to use in the case that the column has no name,
        which should be used if possible as the explicit 'AS <label>'
        where this expression would normally have an anon label.

        this is essentially mostly what _proxy_key does except it returns
        None if the column has a normal name that can be used.

        r�Nr8)r�r9rr�r�rwrwry�_expression_labelUs
zColumnElement._expression_label)r�r��name_is_truncatable�compound_select_cols�
selectablerUrI�Set[KeyedColumnElement[Any]]r�r=r>�&Optional[Sequence[ColumnElement[Any]]]r��#typing_Tuple[str, ColumnClause[_T]]c
Ks�|dur|j}|dur|j}n|}|dusJ�t|r!t�tj|�n|t|dd�|d�}	|j|	_|r7t	|�|	_
n|g|	_
|jdurH|jj�
|�|	_||	fS)z�Create a new :class:`_expression.ColumnElement` representing this
        :class:`_expression.ColumnElement` as it appears in the select list of
        a descending selectable.

        Nr�)ro�_selectable)�_anon_name_labelr�r�rrr�TruncatedLabelRoler�r�r3r�r��columnsr#)
r�r?r�r�r�r�r=r>r��corwrwry�_make_proxygs*��
�

zColumnElement._make_proxyrs�
Cast[_OPT]cC�
t||�S)aProduce a type cast, i.e. ``CAST(<expression> AS <type>)``.

        This is a shortcut to the :func:`_expression.cast` function.

        .. seealso::

            :ref:`tutorial_casts`

            :func:`_expression.cast`

            :func:`_expression.type_coerce`

        )�Castr�rwrwryr�s
zColumnElement.cast�	Label[_T]cCst|||j�S)z�Produce a column label, i.e. ``<columnname> AS <name>``.

        This is a shortcut to the :func:`_expression.label` function.

        If 'name' is ``None``, an anonymous label name will be generated.

        )�Labelr�r;rwrwry�label�szColumnElement.label�seed�add_hash�
Optional[int]r:cCsx|jdur
|j}|jdust|�}|r'|dksJ�|sJ�|d>|B}|d}t|t�r4tj|d|d�St�||p:d�S)Ni��_�)�enclosing_label�anon)r��hashr�r:�safe_construct)r�rOrP�
hash_valuerwrwry�_anon_label�s

�
�zColumnElement._anon_labelcCst|dd�}|�|�S)a�Provides a constant 'anonymous label' for this ColumnElement.

        This is a label() expression which will be named at compile time.
        The same label() is returned each time ``anon_label`` is called so
        that expressions can reference ``anon_label`` multiple times,
        producing the same label name at compile time.

        The compiler uses this function automatically at compile time
        for expressions that are known to be 'unnamed' like binary
        expressions and function calls.

        .. versionchanged:: 1.4.9 - this attribute was not intended to be
           public and is renamed to _anon_name_label.  anon_name exists
           for backwards compat

        r�N�r�rZr;rwrwryrD�s
zColumnElement._anon_name_labelcC�|�|j�S)a�Provides a constant 'anonymous key label' for this ColumnElement.

        Compare to ``anon_label``, except that the "key" of the column,
        if available, is used to generate the label.

        This is used when a deduplicating key is placed into the columns
        collection of a selectable.

        .. versionchanged:: 1.4.9 - this attribute was not intended to be
           public and is renamed to _anon_key_label.  anon_key_label exists
           for backwards compat

        )rZr�r�rwrwry�_anon_key_label�szColumnElement._anon_key_label�1.4zqThe :attr:`_expression.ColumnElement.anon_label` attribute is now private, and the public accessor is deprecated.cCr�rv)rDr�rwrwry�
anon_label��zColumnElement.anon_labelzuThe :attr:`_expression.ColumnElement.anon_key_label` attribute is now private, and the public accessor is deprecated.cCr�rv)r]r�rwrwry�anon_key_labelr`zColumnElement.anon_key_label�idxrpcCs,t|dd�}|dur|�|�S|j||d�S)a)label to apply to a column that is anon labeled, but repeated
        in the SELECT, so that we have to make an "extra anon" label that
        disambiguates it from the previous appearance.

        these labels come out like "foo_bar_id__1" and have double underscores
        in them.

        r�N�rP)r��_dedupe_anon_tq_label_idxrZ�r�rbrNrwrwry�_dedupe_anon_label_idx
s		
z$ColumnElement._dedupe_anon_label_idxcC�|�t|dd��S�Nr��rZr�r�rwrwry�_anon_tq_label!�zColumnElement._anon_tq_labelcCrg)Nr�rir�rwrwry�_anon_tq_key_label%rkz ColumnElement._anon_tq_key_labelcCst|dd�pd}|j||d�S)Nr�rVrcr[rerwrwryrd)sz'ColumnElement._dedupe_anon_tq_label_idx�rsr�rBrv)rr|rsr�)rrrsri)r�r�rsr�)r�r�rsr�)rsri�rsr)rsr)r�r�rsr)rhrrrr�rrsrir)
r3rrrrorrrrrsrt�rsrT)rsr$)r4rirsrr)rrirsrr)r?rUr�rIr�r@r�r�r�r�r=rrr>rAr�rrsrB)rorsrsrI)r�r�rsrL)rOr�rPrQrsr:r�)rsr:�rbrprsr�)rbrprsr:)@r�r�r�r�r�r�rHrLr��_omit_from_statementsrer'r�r<rEr�r�r�r�r+rar�r^r�r�r��_render_label_in_columns_clause�_allow_label_resolve�_is_implicitly_booleanr�rrr/rr�rrrrkrlrr r"r)r(r1r2r6r7r�r<rHrrNrZrDr]�
deprecatedr_rarfrjrlrdrwrwrwryr6�s�
O	%	��





	�




�
-
�$��
r6c@seZdZUdZdZded<dS)�KeyedColumnElementz)ColumnElement where ``.key`` is non-None.Tr�r�N)r�r�r�r�rMrHrwrwrwryrv/s
rvcs|eZdZdZeddd��Zejddd��Zedd	d
��Z	eddd��Z
ejd�fdd��Zddd�Ze�fdd��Z
�ZS)�WrapsColumnExpressionz�Mixin that defines a :class:`_expression.ColumnElement`
    as a wrapper with special
    labeling behavior for an expression that already has a name.

    .. versionadded:: 1.4

    .. seealso::

        :ref:`change_4449`


    rsr�cC�t��rv��NotImplementedErrorr�rwrwry�wrapped_column_expressionEr#z/WrapsColumnExpression.wrapped_column_expressionr�cCs|j}t|d�r|jSdSrh)r{r.r��r��wcerwrwryr�Is
zWrapsColumnExpression._tq_labelcCr�rvr�r�rwrwryr�Qr#zWrapsColumnExpression._labelcCrurvrwr�rwrwryr�Ur�z%WrapsColumnExpression._non_anon_labelr�cs2|j}|js|j}|r
|St|d�r|jSt�jS)NrD)r{rSr�r.rD�super)r�r}�nalr�rwryrDYs
z&WrapsColumnExpression._anon_name_labelrbrpcCs(|j}|j}|r|�|d�S|�|�S)NrS)r{r�rZrd)r�rbr}rrwrwryrfhs

z,WrapsColumnExpression._dedupe_anon_label_idxcs|j}|js	|jSt�jSrv)r{rSr�r~r|r�rwryr�psz WrapsColumnExpression._proxy_key�rsr�rBr�rp)r�r�r�r�r^r{r<r�r�r�r�rDrfr��
__classcell__rwrwr�ryrw7s

rwc@seZdZUdZdZdejfdejfdejfdej	fdej
fgZded	<d
ed<ded<ded<d
Z
dZd
ZdZejdd
ejddd
d
d
ddd
fd@d#d$�Zd
efd%d&�ZedAd(d)��ZdBd+d,�Zd-d.�Zd/d0�ZdCdDd4d5�Zd6d7�Zd8d9�Zd:d;�Zd<d=�Zd>d?�ZdS)Era�Represent a "bound expression".

    :class:`.BindParameter` is invoked explicitly using the
    :func:`.bindparam` function, as in::

        from sqlalchemy import bindparam

        stmt = select(users_table).where(
            users_table.c.name == bindparam("username")
        )

    Detailed discussion of how :class:`.BindParameter` is used is
    at :func:`.bindparam`.

    .. seealso::

        :func:`.bindparam`

    r�r�r��callablernrqr[�_traverse_internalsr�r�Optional[_T]FTNr�rror�rrrr	�#Union[bool, Literal[_NoArg.NO_ARG]]�quote�Optional[bool]�	callable_�Optional[Callable[[], Any]]r�
isoutparamrrr�Optional[TypeEngine[Any]]�_is_crudcCs�|tjur|tjuo
|du}|tjurd}|durt�||�}|r;tjt|�|dur1t|t�s1|nddd�|_d|_	n|rA||_nt�t|�d�|_d|_	|j|_
|pTd|_||_||_
||_|	|_||_||_d|_|
|_|
rsd|_|dur�|r�|r�|d}ntj}n|}|dur�|�||�|_dSt�|�|_dSt|t�r�|�|_dSt|�r�|r�|r�|d}n|}|�|�td|�_dS|td|�_dS||_dS)N�paramT��sanitize_keyrz%BindParameter[typing_Tuple[Any, ...]])r(r-�quoted_name�	constructr:rXr?r�r��_key_is_anon�_identifying_key�	_orig_keyrrnr�r�r	r�	expand_oprqr�r�_NO_VALUE_IN_LIST�coerce_compared_valuer��_resolve_value_to_typer"�_resolve_values_to_typesr)r�r�rnrorr	r�r�rr�rqrrr��check_valuerwrwry�__init__�sp

���



�

��
zBindParameter.__init__cCsH|j|d�}||_d|_|tur|n|j|_|jtjur"t�|�|_|S)zXReturn a copy of this :class:`.BindParameter` with the given value
        set.
        )r
N)	r%rnr�r-r	r�rr	r�)r�rnr
r	�clonedrwrwry�_with_valueszBindParameter._with_valuerscCs|jr|��S|jS)z�Return the value of this bound parameter,
        taking into account if the ``callable`` parameter
        was set.

        The ``callable`` value will be evaluated
        and returned if present, else ``value``.

        )r�rnr�rwrwry�effective_values
zBindParameter.effective_valuertcCst�|�}d|_|S)ahProduce a copy of this bound parameter that will enable the
        :paramref:`_sql.BindParameter.literal_execute` flag.

        The :paramref:`_sql.BindParameter.literal_execute` flag will
        have the effect of the parameter rendered in the compiled SQL
        string using ``[POSTCOMPILE]`` form, which is a special form that
        is converted to be a rendering of the literal value of the parameter
        at SQL execution time.    The rationale is to support caching
        of SQL statement strings that can embed per-statement literal values,
        such as LIMIT and OFFSET parameters, in the final SQL string that
        is passed to the DBAPI.   Dialects in particular may want to use
        this method within custom compilation schemes.

        .. versionadded:: 1.4.5

        .. seealso::

            :ref:`engine_thirdparty_caching`

        T)r�r%rq)r�r�rwrwry�render_literal_execute's
z$BindParameter.render_literal_executecCs |j|ur|��}||_|S|Srv)r�r%)r�r�r�r�rwrwryr�@s

zBindParameter._negate_in_binarycCst�|�}||_|Srv)r�r%r�)r�ror�rwrwryr�Hs
z'BindParameter._with_binary_element_typer
r�rAcKsJtj|fi|��}|j�|j�|s#|jr#tjt|�|jpddd�|_	|S)Nr�Tr�)
r�r%r�rrr:rXr?r�r�)r�r
r�r�rwrwryr%Ms	
�zBindParameter._clonecCs�|jj�dd�}|s|durd|t<dS|�|�\}}|r"||jfS|dur+|�|�||j|jj|jr<|j	||j
fS|j	|j
fS)N�
inherit_cacheFT)r�r�r#r0�get_anonr�r��_static_cache_keyr�r�rq)r�r\r��
_gen_cache_ok�id_�foundrwrwry�_gen_cache_key^s&

��zBindParameter._gen_cache_keycCs0|jsd|_tjt|�|jpddd�|_dSdS)NTr�r�)rr:rXr?r�r�r�rwrwryr
us��z BindParameter._convert_to_uniquecCs2|j��}|j}|jr|��}d|d<||d<|S)z4execute a deferred value for serialization purposes.Nr�rn)r�r�rnr�)r�r�r�rwrwryr�|s
zBindParameter.__getstate__cCs<|�dd�rtjt|�|�dd�dd�|d<|j�|�dS)NrFr�r�Tr�r�)r#r:rXr?r�rrrwrwryr�s

�zBindParameter.__setstate__cCsd|jj|j|j|jfS)Nz%s(%r, %r, type_=%r))r�r�r�rnr�r�rwrwryr>�s�zBindParameter.__repr__)r�r�rnrror�rrrr	r�r�r�r�r�rrrr�rrrqrrrrrr�r�rr)rsr�)rsrtr�)r
rrr�rrsrA) r�r�r�r�r�r6�dp_anon_name�dp_type�
dp_plain_dict�dp_plain_obj�
dp_booleanr�rHr�rXr�r�r(r-r�r�r^r�r�r�r�r%r�r
r�rr>rwrwrwryrysR
��g
rc@s2eZdZUdZdZdejfgZded<dd�Z	dS)	�
TypeClausezTHandle a type keyword in a SQL statement.

    Used by the ``Case`` statement.

    �
typeclauser�r[r�cC�
||_dSrv�r�r�rwrwryr���
zTypeClause.__init__N)
r�r�r�r�r�r6r�r�rHr�rwrwrwryr��s
�r�c@s�eZdZUdZdZdejfdejfgZde	d<dZ
dZe�
dej�Zd	Zd	Zd	Zd	Zed5dd
��Zdd�Zed6dd��ZdZde	d<dZde	d<d	Zedd��Zd7dd�Zed8d!d"��Ze� d#�d9d)d*��Z!ed:d,d-��Z"ed.d/��Z#	d;d<d3d4�Z$dS)=�
TextClauseaRepresent a literal SQL text fragment.

    E.g.::

        from sqlalchemy import text

        t = text("SELECT * FROM users")
        result = connection.execute(t)

    The :class:`_expression.TextClause` construct is produced using the
    :func:`_expression.text`
    function; see that function for full documentation.

    .. seealso::

        :func:`_expression.text`

    �
textclause�_bindparamsr�r[r�Tz(?<![:\w\x5c]):(\w+)(?!:)Frs�Iterable[FromClause]cCr��Nrwrwr�rwrwry�_hide_froms�r�zTextClause._hide_fromscCrJrv)r�r{rwrwryr|��
zTextClause.__and__rTcCr!rvrwr�rwrwryr"�r#zTextClause._select_iterableNr�r�r�cCs
|jdkS�N�*)r�r�rwrwryr]�r�zTextClause._is_starr�cs&i�_�fdd�}�j�||��_dS)Ncs(t|�d���j|�d�<d|�d�S)Nrz:%s)r�groupr�)�mr�rwry�repl�sz!TextClause.__init__.<locals>.repl)r��_bind_params_regex�subr�)r�r�r�rwr�ryr��szTextClause.__init__�bindsr~�names_to_valuesrrAc	Os�|j��|_}|D]$}z||j}Wnty(}z	t�d|j�|�d}~ww|||j<q
|��D](\}}z||}WntyQ}zt�d|�|�d}~ww|j|dd�||<q3|S)a�Establish the values and/or types of bound parameters within
        this :class:`_expression.TextClause` construct.

        Given a text construct such as::

            from sqlalchemy import text

            stmt = text(
                "SELECT id, name FROM user WHERE name=:name AND timestamp=:timestamp"
            )

        the :meth:`_expression.TextClause.bindparams`
        method can be used to establish
        the initial value of ``:name`` and ``:timestamp``,
        using simple keyword arguments::

            stmt = stmt.bindparams(
                name="jack", timestamp=datetime.datetime(2012, 10, 8, 15, 12, 5)
            )

        Where above, new :class:`.BindParameter` objects
        will be generated with the names ``name`` and ``timestamp``, and
        values of ``jack`` and ``datetime.datetime(2012, 10, 8, 15, 12, 5)``,
        respectively.  The types will be
        inferred from the values given, in this case :class:`.String` and
        :class:`.DateTime`.

        When specific typing behavior is needed, the positional ``*binds``
        argument can be used in which to specify :func:`.bindparam` constructs
        directly.  These constructs must include at least the ``key``
        argument, then an optional value and type::

            from sqlalchemy import bindparam

            stmt = stmt.bindparams(
                bindparam("name", value="jack", type_=String),
                bindparam("timestamp", type_=DateTime),
            )

        Above, we specified the type of :class:`.DateTime` for the
        ``timestamp`` bind, and the type of :class:`.String` for the ``name``
        bind.  In the case of ``name`` we also set the default value of
        ``"jack"``.

        Additional bound parameters can be supplied at statement execution
        time, e.g.::

            result = connection.execute(
                stmt, timestamp=datetime.datetime(2012, 10, 8, 15, 12, 5)
            )

        The :meth:`_expression.TextClause.bindparams`
        method can be called repeatedly,
        where it will re-use existing :class:`.BindParameter` objects to add
        new information.  For example, we can call
        :meth:`_expression.TextClause.bindparams`
        first with typing information, and a
        second time with value information, and it will be combined::

            stmt = text(
                "SELECT id, name FROM user WHERE name=:name "
                "AND timestamp=:timestamp"
            )
            stmt = stmt.bindparams(
                bindparam("name", type_=String), bindparam("timestamp", type_=DateTime)
            )
            stmt = stmt.bindparams(
                name="jack", timestamp=datetime.datetime(2012, 10, 8, 15, 12, 5)
            )

        The :meth:`_expression.TextClause.bindparams`
        method also supports the concept of
        **unique** bound parameters.  These are parameters that are
        "uniquified" on name at statement compilation time, so that  multiple
        :func:`_expression.text`
        constructs may be combined together without the names
        conflicting.  To use this feature, specify the
        :paramref:`.BindParameter.unique` flag on each :func:`.bindparam`
        object::

            stmt1 = text("select id from table where name=:name").bindparams(
                bindparam("name", value="name1", unique=True)
            )
            stmt2 = text("select id from table where name=:name").bindparams(
                bindparam("name", value="name2", unique=True)
            )

            union = union_all(stmt1.columns(column("id")), stmt2.columns(column("id")))

        The above statement will render as:

        .. sourcecode:: sql

            select id from table where name=:name_1
            UNION ALL select id from table where name=:name_2

        .. versionadded:: 1.3.11  Added support for the
           :paramref:`.BindParameter.unique` flag to work with
           :func:`_expression.text`
           constructs.

        z?This text() construct doesn't define a bound parameter named %rNF)r	)r�r�r��KeyErrorr:�
ArgumentErrorr�r�)	r�r�r��
new_paramsr��existingr
r�rnrwrwryr�	s<l����������zTextClause.bindparamszsqlalchemy.sql.selectable�cols�_ColumnExpressionArgument[Any]�types�_TypeEngineArgument[Any]rWcsjtjj}dd�|D�}�fdd�|D�}dd����D�}|j�|j�}|j|||t|�o0|d�|S)a�Turn this :class:`_expression.TextClause` object into a
        :class:`_expression.TextualSelect`
        object that serves the same role as a SELECT
        statement.

        The :class:`_expression.TextualSelect` is part of the
        :class:`_expression.SelectBase`
        hierarchy and can be embedded into another statement by using the
        :meth:`_expression.TextualSelect.subquery` method to produce a
        :class:`.Subquery`
        object, which can then be SELECTed from.

        This function essentially bridges the gap between an entirely
        textual SELECT statement and the SQL expression language concept
        of a "selectable"::

            from sqlalchemy.sql import column, text

            stmt = text("SELECT id, name FROM some_table")
            stmt = stmt.columns(column("id"), column("name")).subquery("st")

            stmt = (
                select(mytable)
                .select_from(mytable.join(stmt, mytable.c.name == stmt.c.name))
                .where(stmt.c.id > 5)
            )

        Above, we pass a series of :func:`_expression.column` elements to the
        :meth:`_expression.TextClause.columns` method positionally.  These
        :func:`_expression.column`
        elements now become first class elements upon the
        :attr:`_expression.TextualSelect.selected_columns` column collection,
        which then
        become part of the :attr:`.Subquery.c` collection after
        :meth:`_expression.TextualSelect.subquery` is invoked.

        The column expressions we pass to
        :meth:`_expression.TextClause.columns` may
        also be typed; when we do so, these :class:`.TypeEngine` objects become
        the effective return type of the column, so that SQLAlchemy's
        result-set-processing systems may be used on the return values.
        This is often needed for types such as date or boolean types, as well
        as for unicode processing on some dialect configurations::

            stmt = text("SELECT id, name, timestamp FROM some_table")
            stmt = stmt.columns(
                column("id", Integer),
                column("name", Unicode),
                column("timestamp", DateTime),
            )

            for id, name, timestamp in connection.execute(stmt):
                print(id, name, timestamp)

        As a shortcut to the above syntax, keyword arguments referring to
        types alone may be used, if only type conversion is needed::

            stmt = text("SELECT id, name, timestamp FROM some_table")
            stmt = stmt.columns(id=Integer, name=Unicode, timestamp=DateTime)

            for id, name, timestamp in connection.execute(stmt):
                print(id, name, timestamp)

        The positional form of :meth:`_expression.TextClause.columns`
        also provides the
        unique feature of **positional column targeting**, which is
        particularly useful when using the ORM with complex textual queries. If
        we specify the columns from our model to
        :meth:`_expression.TextClause.columns`,
        the result set will match to those columns positionally, meaning the
        name or origin of the column in the textual SQL doesn't matter::

            stmt = text(
                "SELECT users.id, addresses.id, users.id, "
                "users.name, addresses.email_address AS email "
                "FROM users JOIN addresses ON users.id=addresses.user_id "
                "WHERE users.id = 1"
            ).columns(
                User.id,
                Address.id,
                Address.user_id,
                User.name,
                Address.email_address,
            )

            query = (
                session.query(User)
                .from_statement(stmt)
                .options(contains_eager(User.addresses))
            )

        The :meth:`_expression.TextClause.columns` method provides a direct
        route to calling :meth:`_expression.FromClause.subquery` as well as
        :meth:`_expression.SelectBase.cte`
        against a textual SELECT statement::

            stmt = stmt.columns(id=Integer, name=String).cte("st")

            stmt = select(sometable).where(sometable.c.id == stmt.c.id)

        :param \*cols: A series of :class:`_expression.ColumnElement` objects,
         typically
         :class:`_schema.Column` objects from a :class:`_schema.Table`
         or ORM level
         column-mapped attributes, representing a set of columns that this
         textual string will SELECT from.

        :param \**types: A mapping of string names to :class:`.TypeEngine`
         type objects indicating the datatypes to use for names that are
         SELECTed from the textual string.  Prefer to use the ``*cols``
         argument as it also indicates positional ordering.

        cS�g|]	}t�tj|��qSrw)rrr�LabeledColumnExprRole�r��colrwrwryr+
��z&TextClause.columns.<locals>.<listcomp>cs.g|]}|j�vrt|j��|j��n|�qSrw)r�r�r�r��r�rwryr+
s
���cSsg|]	\}}t||��qSrwr�)r�r�rorwrwryr+
r�)�
positional)r<r��sql_selectabler�rWr��_initrr)r�r�r�r?�
input_cols�positional_input_cols�keyed_input_cols�elemrwr�ryrF�	s"w�
���zTextClause.columns�TypeEngine[Any]cCrrvrr�rwrwryr�
r#zTextClause.typecCs|j�|�Srv)r�rr�rwrwryr
�zTextClause.comparatorrr�Union[Self, Grouping[Any]]cCs|tjur	t|�S|Srv)r�in_oprrrwrwryr#
s
zTextClause.self_group)rsr�ro)r�r�)r�r~r�rrsrA)r�r�r�r�rsrW)rsr�rv�rrrsr�)%r�r�r�r�r�r6�dp_string_clauseelement_dict�	dp_stringr�rHrSrP�rer��UNICODEr�rtrrrqrer^r�r|r"r�r�rsr]r�r'r�r<r�rFr�rrrwrwrwryr��sH
�


�r�c@sLeZdZUdZdZgZded<ded<esej	d
dd	��Z
edd
d��ZdS)�Nullz�Represent the NULL keyword in a SQL statement.

    :class:`.Null` is accessed as a constant via the
    :func:`.null` function.

    �nullr[r��
_singletonrsrcCrrvrr�rwrwryr�;
r#z	Null.typecCr)z+Return a constant :class:`.Null` construct.)r�r���clsrwrwry�	_instance?
r
zNull._instanceNrn)rsr�)
r�r�r�r�r�r�rHrr<rEr��classmethodr�rwrwrwryr�,
s
r�c@sVeZdZUdZdZgZded<ded<esej	ddd	��Z
ddd�Zedd
d��Z
dS)�False_z�Represent the ``false`` keyword, or equivalent, in a SQL statement.

    :class:`.False_` is accessed as a constant via the
    :func:`.false` function.

    �falser[r�r�rsrcCrrv�rr�r�rwrwryr�Y
r#zFalse_.type�True_cCrrv�r�r�r�rwrwryr/]
�zFalse_._negatecCrrv�r�r�r�rwrwryr�`
r#zFalse_._instanceNrn�rsr��rsr�)r�r�r�r�r�r�rHrr<rEr�r/r�r�rwrwrwryr�I
s

r�c@sdeZdZUdZdZgZded<ded<esej	ddd	��Z
ddd�Zeddd��Z
eddd��ZdS)r�z�Represent the ``true`` keyword, or equivalent, in a SQL statement.

    :class:`.True_` is accessed as a constant via the
    :func:`.true` function.

    �truer[r�r�rsrcCrrvr�r�rwrwryr�w
r#z
True_.typer�cCrrvr�r�rwrwryr/{
r�z
True_._negater�Optional[ColumnElement[Any]]ricCs|dur|��S|Srv)r�)r�rrwrwry�_ifnone~
sz
True_._ifnonecCrrvr�r�rwrwryr��
r#zTrue_._instanceNrnr�)rr�rsrir�)r�r�r�r�r�r�rHrr<rEr�r/r�r�r�rwrwrwryr�h
s

r�c@s�eZdZUdZdZdZdejfdejfgZ	de
d<de
d<ejdde
jd	�d+dd�Ze	d,d-dd��Zd.dd�Zd/dd�Zed0dd ��Zd!d"�Zejd1d$d%��Z	d,d2d)d*�ZdS)3�
ClauseListzzDescribe a list of clauses, separated by an operator.

    By default, is comma-separated, such as a column listing.

    �
clauselistT�clausesr3r[r�r�)r3r��group_contents�_literal_as_text_roler�rOr�rrr�r��Type[roles.SQLRole]csf|�_|�_|�_|}|���_�jr��fdd�|D��_n��fdd�|D��_t��j��_dS)Ncs&g|]}tj�|�d�j�jd��qS)��apply_propagate_attrsr1)rrrr3�r�r��r��text_converter_rolerwryr+�
s����z'ClauseList.__init__.<locals>.<listcomp>csg|]
}tj�|�d��qS�r�)rrr�r�rwryr+�
s���)r3r�r��_text_converter_roler�r�
is_booleanrt)r�r3r�r�r�r��clauses_iteratorrwr�ryr��
s
��zClauseList.__init__NrArscCs8|�|�}|rt|�ng|_d|_||_d|_d|_|S)NTF)r�r3r�r�r3r�rt�r�r3r�r�rwrwry�_construct_raw�
s
zClauseList._construct_raw�Iterator[ColumnElement[Any]]cC�
t|j�Srv��iterr�r�rwrwry�__iter__�
r�zClauseList.__iter__rpcCrrv��lenr�r�rwrwry�__len__�
r�zClauseList.__len__rTcCstj�dd�|jD��S)NcSr*rw)r")r�r�rwrwryr+�
r,z/ClauseList._select_iterable.<locals>.<listcomp>)r/r0�
from_iterabler�r�rwrwryr"�
s�zClauseList._select_iterablecCsD|jr|j�t�|j|�j|jd��dS|j�t�|j|��dS�Nr1)r�r�r�rrr�rr3�r�r�rwrwryr��
s���zClauseList.appendr�cC�ttjdd�|jD���S)NcSr*rw�r�r%rwrwryr+�
r,z,ClauseList._from_objects.<locals>.<listcomp>�r3r/r0r�r�rwrwryr��
�zClauseList._from_objectsrrr�cCs |jrt�|j|�rt|�S|Srv)r�r�is_precedentr3rrrwrwryr�
�zClauseList.self_group)
r�r�r3rOr�rrr�rrr�r�rv)r3rOr�rArsr��rsrr�rorDr�)r�r�r�r�r�rYr6�dp_clauseelement_list�dp_operatorr�rHr�comma_opr�WhereHavingRoler�r�rrr
r^r"r�r<r`r�rrwrwrwryr��
s2
���

�r�c@sleZdZUdZded<ded<dZded<ed	d
��Z	d!d"dd�Zed#dd��Z	e
ddd�d$dd ��ZdS)%�OperatorExpressionz[base for expressions that contain an operator and operands

    .. versionadded:: 2.0

    rOr3rr�Trrr�cCst�|j�Srv)rrqr3r�rwrwryrqsz OperatorExpression.is_comparisonNrrrs�Union[Self, Grouping[_T]]cCs6|jr
t�|j|�s|tjurt�|j�st|�S|Srv)r�rrr3r5r�rrrwrwryrs��

�zOperatorExpression.self_group�%typing_Tuple[ColumnElement[Any], ...]cCrxrvryr�rwrwry�_flattened_operator_clausesr
z.OperatorExpression._flattened_operator_clauses)�negate�	modifiers�leftri�rightrhrorrr�OperatorExpression[_T]c
Cs�t�|�rN|dusJd|����d}t|dd�|ur&|�|j�r&d}|j}n|f}t|dd�|ur=|�|j�r=d}|j}	n|f}	|rNtj||g||	�R�S|jrSd}t	||||||d�S)Nz.negate not supported for associative operator Fr3T)rorr)
r�is_associativer��_compare_type_affinityr�r�ExpressionClauseList�_construct_for_listre�BinaryExpression)
r�rr rhrorr�multi�left_flattened�right_flattenedrwrwry�_construct_for_op#sJ

���
���
����z$OperatorExpression._construct_for_oprv�rrrsr�rsr)rrir rirhrOrorrrrrrsr!)r�r�r�r�rHr�r^rqrrr�r*rwrwrwryr�
s

��rc@s�eZdZUdZdZdejfdejfgZde	d<de	d<de	d	<d
d�d/dd�Z
ed0dd��Zd1dd�Z
d2dd�Zed3dd��Zejd4dd ��Zd5d$d%�Zed&d'�d6d*d+��Zd7d-d.�Zd
S)8r$a9Describe a list of clauses, separated by an operator,
    in a column expression context.

    :class:`.ExpressionClauseList` differs from :class:`.ClauseList` in that
    it represents a column-oriented DQL expression only, not an open ended
    list of anything comma separated.

    .. versionadded:: 2.0

    �expression_clauselistr�r3r[r�rrrr�N�rorOr�ror�cs<|�_t�fdd�|D���_t��j��_t�|��_dS)Nc3s"�|]}tjtj|�d�VqdS)r�N�rrr�ExpressionElementRoler�r�rwryr&rs���
�z0ExpressionClauseList.__init__.<locals>.<genexpr>)	r3r"r�rr�rtr�to_instancer�)r�r3ror�rwr�ryr�js
�zExpressionClauseList.__init__rscCr�rv�r�r�rwrwryr{r
z0ExpressionClauseList._flattened_operator_clausesrcCrrvrr�rwrwryr�r�zExpressionClauseList.__iter__rpcCrrvrr�rwrwryr
�r�zExpressionClauseList.__len__rTcCr!rvrwr�rwrwryr"�r#z%ExpressionClauseList._select_iterabler�cCr)NcSr*rwrr%rwrwryr+�r,z6ExpressionClauseList._from_objects.<locals>.<listcomp>rr�rwrwryr��rz"ExpressionClauseList._from_objectsr�rir|cCs|j|f7_dSrvr2r
rwrwry�_append_inplace��z$ExpressionClauseList._append_inplaceT)r�r�ExpressionClauseList[_T]csD|�|�}||_|rt�fdd�|D��|_n||_�|_||_|S)Nc3s�|]	}|j�d�VqdS)r1N�rr%r2rwryr&�s�
�z;ExpressionClauseList._construct_for_list.<locals>.<genexpr>)r�r�r"r�r3r�)r�r3ror�r�r�rwr2ryr%�s
�z(ExpressionClauseList._construct_for_listrcCs,|jtjd�}t|t�sJ�t|tjdd�Srr4r8rwrwryr/�s
�zExpressionClauseList._negate)r3rOr�r�ror�r,rr�rorD)r�rirsr|)
r3rOrorr�rir�rrrsr5�rsr)r�r�r�r�r�r6�dp_clauseelement_tuplerr�rHr�r^rrr
r"r<r`r�r3r�r%r/rwrwrwryr$Ss.
��


�r$cs�eZdZdZdZdd�Zed,dd��Zeej	fd-dd��Z
ed.dd��Ze	d/d0dd��Zeej	fd1dd ��Z
eej	fd2d"d#��Zed3d%d&��Z	d/d4�fd*d+�
Z�ZS)5rzr-TcOr�)Nz+BooleanClauseList has a private constructorry)r��argr�rwrwryr��s�zBooleanClauseList.__init__r3rO�continue_onr�skip_onr��Iterable[ColumnElement[Any]]rs�+typing_Tuple[int, List[ColumnElement[Any]]]c	s�d}g}tj�d}|D]"}||ur|}q||ur|g}d}n|s$d}n|�d}|�|�q|s9|dur9|g}d}|�fdd�|D�fS)Nrrr9csg|]}|j�d��qS)r1r6r%r1rwryr+�szBBooleanClauseList._process_clauses_for_boolean.<locals>.<listcomp>)rr�r�)	r�r3r:r;r��has_continue_on�convert_clauses�lccr�rwr1ry�_process_clauses_for_boolean�s(z.BooleanClauseList._process_clauses_for_boolean�initial_clauser�rics�|tjur5�j}tjd|�d|�d|�d|tjurdnd�d|�d|tjur(dnd	�d
�
dd�|���S|��||d
d�t�	|f|�D��\}}	|dkrat
j��fdd�|	D��}
|��|
�S|seJ�|	dS)Nz	Invoking z_() without arguments is deprecated, and will be disallowed in a future release.   For an empty z() construct, use '�(ztrue()zfalse()z, *args)' or '�True�Falsez
, *args)'.r^)�versioncSr�rw)rrrrr�rwrwryr+���z0BooleanClauseList._construct.<locals>.<listcomp>rc3s6�|]}t|dd��urdd�|jD�n|fVqdS)r3Ncss�|]}|VqdSrvrwr%rwrwryr&s�z9BooleanClauseList._construct.<locals>.<genexpr>.<genexpr>)r�r)r��to_flatr2rwryr&s���
�z/BooleanClauseList._construct.<locals>.<genexpr>r)
r(r-r�r<�warn_deprecatedr�r�rrA�coerce_generator_argr/r0r)r�r3r:r;rBr�r�r�r@r?�flattened_clausesrwr2ry�
_construct�sD

������
����	zBooleanClauseList._construct�Optional[ColumnElement[bool]]cCsRtjtjtj}}}|�||||�\}}|dkr|�||�S|dkr'|dSdS)Nrr)rr�r�r�r�rAr)r�r�r3r:r;r@r?rwrwry�_construct_for_whereclauses
��z,BooleanClauseList._construct_for_whereclauseNrAcCs:|�|�}|rt|�nd|_d|_||_tj|_d|_|S)NrwT)	r�r"r�r�r3rr�r�rtrrwrwryr;s
z BooleanClauseList._construct_raw�=Union[Literal[True], _ColumnExpressionArgument[bool], _NoArg]�_ColumnExpressionArgument[bool]r�cG�|jtjtjtj|g|�R�S)zwProduce a conjunction of expressions joined by ``AND``.

        See :func:`_sql.and_` for full documentation.
        )rLrr�r�r�r��r�rBr�rwrwryr�I���zBooleanClauseList.and_�>Union[Literal[False], _ColumnExpressionArgument[bool], _NoArg]cGrQ)zuProduce a conjunction of expressions joined by ``OR``.

        See :func:`_sql.or_` for full documentation.
        )rLrr�r�r�r�rRrwrwryr�]rSzBooleanClauseList.or_rTcCr!rvrwr�rwrwryr"qr#z"BooleanClauseList._select_iterablerr�Union[Self, Grouping[bool]]cs|js|St�j|d�Sr)r�r~rrr�rwryruszBooleanClauseList.self_group)
r3rOr:rr;rr�r<rsr=)r3rOr:rr;rrBrr�rr�rrsri)r�r<rsrMrv)r3rOr�rArsrz)rBrOr�rPrsr�)rBrTr�rPrsr�ro)rrrsrU)r�r�r�r�r�r�r�rAr(r-rLrNrr�r�r^r"rr�rwrwr�ryrz�s0*�<�
���rzcsveZdZUdZdZejgZded<ded<e�	d�dd	�d�fdd��Z
eddd��Zddd�Z
dd dd�Z�ZS)!rzRepresent a SQL tuple.r"r[r�rXr��sqlalchemy.sql.sqltypesNr�r�r�r��,Optional[Sequence[_TypeEngineArgument[Any]]]cs�tjj}|durdd�|D�}nt|�t|�kr#t�dt|�|f��dd�t||�D�}|jdd�|D��|_t	�j
|�dS)NcSr�rwr/r%rwrwryr+�rGz"Tuple.__init__.<locals>.<listcomp>z*Wrong number of elements for %d-tuple: %r cSs,g|]\}}tjtj||js|ndd��qS�Nr.)rrrr0�_isnull)r��typr�rwrwryr+�s���cSr*rwr�)r�r9rwrwryr+�r,)r<r��sql_sqltypesr	r:r��ziprXr�r~r�)r�r�r��sqltypes�init_clausesr�rwryr��s �
���	zTuple.__init__rsrTcCr!rvrwr�rwrwryr"�r#zTuple._select_iterableFc	s>|rtd|�dd�|jd�St��fdd�t||jj�D��S)NT)rnrrrrorc
s$g|]\}}td|�|d�d��qS)NT)rrrro)r)r��o�compared_to_type�r3rorwryr+�s	���z%Tuple._bind_param.<locals>.<listcomp>)rr�rr\r�rrwraryr�s�
	��zTuple._bind_paramrrrAcCr�rvrwrrwrwryr�r�zTuple.self_group)r�r�r�rWrorrv�rrrsrA)r�r�r�r�r�r�r�rHr<r�r�r^r"rrr�rwrwr�ryr�s

��
r.c@steZdZUdZdZdejfdejfdejfgZde	d<de	d<d	e	d<d
e	d<ddd�ddd�Z
ejddd��Z
dS)�Casea�Represent a ``CASE`` expression.

    :class:`.Case` is produced using the :func:`.case` factory function,
    as in::

        from sqlalchemy import case

        stmt = select(users_table).where(
            case(
                (users_table.c.name == "wendy", "W"),
                (users_table.c.name == "jack", "J"),
                else_="E",
            )
        )

    Details on :class:`.Case` usage is at :func:`.case`.

    .. seealso::

        :func:`.case`

    �casern�whens�else_r[r�z:List[typing_Tuple[ColumnElement[bool], ColumnElement[_T]]]r�r�N)rnrf�LUnion[typing_Tuple[_ColumnExpressionArgument[bool], Any], Mapping[Any, Any]]�
Optional[Any]cs�t�dd|�}zt�|�}Wn	tyYnw�fdd�|D��_|dur*d�_nt�tj	|��_|dur?t�tj	|��_
nd�_
tdd�t�j�D��j
durU�j
j
ntj�}tt|��_
dS)Nrerdcs4g|]\}}tjtj|�d���t�tj|�f�qSr�)rrrr0r)r�r��rr�rwryr+
s	����z!Case.__init__.<locals>.<listcomp>css$�|]
�^}}|jjs|jVqdSrv)r�rY)r�rS�thenrwrwryr&
s��
�z Case.__init__.<locals>.<genexpr>)r�!_expression_collection_was_a_listr<�dictlike_iteritemsr;rernrrr0rf�next�reversedr�rr	rre)r�rnrfre�	new_whensrorwr�ryr��s0	��
	���
z
Case.__init__rsr�cCsttjdd�|��D���S)NcSr*rwr)r��xrwrwryr+,
r,z&Case._from_objects.<locals>.<listcomp>)r3r/r0r�r�rwrwryr�)
s�zCase._from_objects)rergrnrhrfrhrD)r�r�r�r�r�r6�dp_clauseelement�dp_clauseelement_tuplesr�rHr�r<r`r�rwrwrwryrc�s
�	�3rcc@speZdZUdZdZdejfdejfgZde	d<de	d<de	d<d	e	d
<ddd�Z
ejddd��Z
edd��ZdS)rKaORepresent a ``CAST`` expression.

    :class:`.Cast` is produced using the :func:`.cast` factory function,
    as in::

        from sqlalchemy import cast, Numeric

        stmt = select(cast(product_table.c.unit_price, Numeric(10, 4)))

    Details on :class:`.Cast` usage is at :func:`.cast`.

    .. seealso::

        :ref:`tutorial_casts`

        :func:`.cast`

        :func:`.try_cast`

        :func:`.type_coerce` - an alternative to CAST that coerces the type
        on the Python side only, which is often sufficient to generate the
        correct SQL and data coercion.

    rr�r�r[r�rirr�r�r r�rorpcCs4t�|�|_tjtj||j|d�|_t|j�|_	dS�N)ror�)
rr1r�rrrr0r�r�r��r�r rorwrwryr�U
s�z
Cast.__init__rsr�cC�|jjSrv�r�r�r�rwrwryr�c
�zCast._from_objectscCr�rv�r�r�rwrwryr{g
r#zCast.wrapped_column_expressionN�r r�rorprD)r�r�r�r�r�r6rqr�r�rHr�r<r`r�r^r{rwrwrwryrK0
s
�
rKc@seZdZdZdZdZdS)�TryCastz�Represent a TRY_CAST expression.

    Details on :class:`.TryCast` usage is at :func:`.try_cast`.

    .. seealso::

        :func:`.try_cast`

        :ref:`tutorial_casts`
    �try_castTN)r�r�r�r�r�r�rwrwrwryrzl
srzc@s�eZdZUdZdZdejfdejfgZde	d<de	d<de	d<dd
d�Z
ejddd��Z
ejdd��Zedd��Z	dd dd�ZdS)!�
TypeCoerceaRepresent a Python-side type-coercion wrapper.

    :class:`.TypeCoerce` supplies the :func:`_expression.type_coerce`
    function; see that function for usage details.

    .. seealso::

        :func:`_expression.type_coerce`

        :func:`.cast`

    �type_coercer�r�r[r�rirr r�rorpcCs(t�|�|_tjtj||j|d�|_dSrs)rr1r�rrrr0r�rtrwrwryr��
s�zTypeCoerce.__init__rsr�cCrurvrvr�rwrwryr��
rwzTypeCoerce._from_objectscCs(t|jt�r|j��}|j|_|S|jSrv)r�r�rr%r�)r��bprwrwry�typed_expression�
s

zTypeCoerce.typed_expressioncCr�rvrxr�rwrwryr{�
r#z$TypeCoerce.wrapped_column_expressionNrr�TypeCoerce[_T]cCs(|jj|d�}||jurt||j�S|Sr)r�rr|r�)r�rr9rwrwryr�
s
zTypeCoerce.self_groupryrDrv)rrrsr�)r�r�r�r�r�r6rqr�r�rHr�r<r`r�r+rarr^r{rrwrwrwryr||
s"

�



�r|c@s\eZdZUdZdZdejfdejfgZde	d<de	d<de	d<dd
d�Z
ejddd��Z
dS)�Extractz=Represent a SQL EXTRACT clause, ``extract(field FROM expr)``.�extract�expr�fieldr[r�rir�r�cCs"tj|_||_t�tj|�|_dSrv)	r�INTEGERTYPEr�r�rrrr0r�)r�r�r�rwrwryr��
szExtract.__init__rsr�cCrurv)r�r�r�rwrwryr��
rwzExtract._from_objectsN)r�r�r�r�rD)r�r�r�r�r�r6rqr�r�rHr�r<r`r�rwrwrwryr��
s
�
r�c@sLeZdZUdZdZdejfgZded<ded<ddd�Z	e
jddd��Zd
S)�_label_referencea�Wrap a column expression as it appears in a 'reference' context.

    This expression is any that includes an _order_by_label_element,
    which is a Label, or a DESC / ASC construct wrapping a Label.

    The production of _label_reference() should occur when an expression
    is added to this context; this includes the ORDER BY or GROUP BY of a
    SELECT statement, as well as a few other places, such as the ORDER BY
    within an OVER clause.

    �label_reference�elementr[r�r�cCr�rv�r��r�r�rwrwryr��
r�z_label_reference.__init__rsr�cCr�rvrwr�rwrwryr��
r�z_label_reference._from_objectsN)r�r�rD)
r�r�r�r�r�r6rqr�rHr�r<r`r�rwrwrwryr��
s
�
r�c@s@eZdZUdZdejfgZded<d
dd�Ze	j
dd
d��ZdS)�_textual_label_reference�textual_label_referencer�r[r�r�cCr�rvr�r�rwrwryr��
r�z!_textual_label_reference.__init__rsr�cCrrv)r�r�r�rwrwry�_text_clause�
r�z%_textual_label_reference._text_clauseN)r�r�)rsr�)r�r�r�r�r6r�r�rHr�r<rEr�rwrwrwryr��
s
�
r�c@s�eZdZUdZdZdejfdejfdejfgZde	d<de	d<							
d1d2dd�Z
ed3dd��Zed3dd��Z
ed4dd��Zed4dd��Zed5d!d"��Zed5d#d$��Zed6d&d'��Zejd7d)d*��Zd+d,�Z		d8d9d/d0�Zd	S):r7a�Define a 'unary' expression.

    A unary expression has a single column expression
    and an operator.  The operator can be placed on the left
    (where it is called the 'operator') or right (where it is called the
    'modifier') of the column expression.

    :class:`.UnaryExpression` is the basis for several unary operators
    including those used by :func:`.desc`, :func:`.asc`, :func:`.distinct`,
    :func:`.nulls_first` and :func:`.nulls_last`.

    �unaryr�r3�modifierr[r�r�NFrirror�rrrcCs@||_||_|j|_|j|jp|jd�|_t�|�|_||_dSr)	r3r�r�rr�rr1r�r)r�r�r3r�rorrwrwryr�s
�
zUnaryExpression.__init__�column�_ColumnExpressionArgument[_T]rs�UnaryExpression[_T]cC�tt�tj|�tjdd�S�NF)r�r)r7rrr�ByOfRoler�nulls_first_op�r�r�rwrwry�_create_nulls_first,�
�z#UnaryExpression._create_nulls_firstcCr�r�)r7rrrr�r�
nulls_last_opr�rwrwry�_create_nulls_last7r�z"UnaryExpression._create_nulls_last�'_ColumnExpressionOrStrLabelArgument[_T]cCr�r�)r7rrrr�r�desc_opr�rwrwry�_create_descBs
�zUnaryExpression._create_desccCr�r�)r7rrrr�r�asc_opr�rwrwry�_create_ascLr�zUnaryExpression._create_ascr�cC�"t�tj|�}t|tj|jdd�S�NF�r3ror)rrrr0r7r�distinct_opr��r�r��col_exprrwrwry�_create_distinctW���z UnaryExpression._create_distinctcCr�r�)rrrr0r7r�bitwise_not_opr�r�rwrwry�_create_bitwise_notfr�z#UnaryExpression._create_bitwise_notr�cCst�|j�r
|jjSdSrv)r�is_order_by_modifierr�r�r�r�rwrwryr�u�z'UnaryExpression._order_by_label_elementr�cCrurv�r�r�r�rwrwryr�|rwzUnaryExpression._from_objectscCs:|jjtjjurt|jtjd�tjtj|jd�St	�
|�S)Nr1r�)r�r�rr�r7rrr5rr�r/r�rwrwryr/�s�
zUnaryExpression._negaterrcCs |jrt�|j|�rt|�S|Srv)r3rrrrrwrwryr�rzUnaryExpression.self_group)NNNF)
r�rir3rr�rror�rrr)r�r�rsr�)r�r�rsr�)r�r�rsr�rCrDrvr+)r�r�r�r�r�r6rqrr�rHr�r�r�r�r�r�r�r�r^r�r<r`r�r/rrwrwrwryr7�
s@

��

	
�r7c@sDeZdZdZdZdZeddd��Zedd	d
��Zdd�Z	d
d�Z
dS)�CollectionAggregateaForms the basis for right-hand collection operator modifiers
    ANY and ALL.

    The ANY and ALL keywords are available in different ways on different
    backends.  On PostgreSQL, they only work for an ARRAY type.  On
    MySQL, they only work for subqueries.

    Tr�r�rs�CollectionAggregate[bool]cC�*t�tj|�}|��}t|tjtj	dd�Sr�)
rrrr0rr�rrrr�r�rwrwry�_create_any����zCollectionAggregate._create_anycCr�r�)
rrrr0rr�rrrr�r�rwrwry�_create_all�r�zCollectionAggregate._create_allcOs<t�|�s
t�d��d|d<|jjt�|�g|�Ri|��S)N�2Only comparison operators may be used with ANY/ALLT�reverse)rrqr:r�rrk�mirrorrjrwrwryrk�s
� zCollectionAggregate.operatecKst�|�rJ�t�d��)Nr�)rrqr:r�rjrwrwryrl�s�z#CollectionAggregate.reverse_operateN)r�r�rsr�)r�r�r�r�r�rer�r�r�rkrlrwrwrwryr��s	r�c@s8eZdZdZdd�Zedd��Zdddd�Zd
d�ZdS)r�TcCs2||_tj|_||_||_d|_d|_|j|_dS�NT)	r�rr�r�r3rr�rrt)r�r�r3rrwrwryr��szAsBoolean.__init__cCr�rvr�r�rwrwryr{�r#z#AsBoolean.wrapped_column_expressionNrrrsrAcCr�rvrwrrwrwryr�rgzAsBoolean.self_groupcCs,t|jttf�r
|j��St|j|j|j�Srv)r�r�r�r�r/r�rr3r�rwrwryr/�s
zAsBoolean._negatervrb)	r�r�r�r�r�r^r{rr/rwrwrwryr��s	
r�c@s�eZdZUdZdZdejfdejfdejfdejfdejfdej	fgZ
d	ed
<dejfdejfdejfdejfdej	fgZdZ
	ded<d
ed<d
ed<			d$d%dd�Zed&dd��Zdd�Zejrhd'dd�Zejd(d d!��Zd"d#�ZdS))r&a�Represent an expression that is ``LEFT <operator> RIGHT``.

    A :class:`.BinaryExpression` is generated automatically
    whenever two column expressions are used in a Python binary expression:

    .. sourcecode:: pycon+sql

        >>> from sqlalchemy.sql import column
        >>> column("a") + column("b")
        <sqlalchemy.sql.expression.BinaryExpression object at 0x101029dd0>
        >>> print(column("a") + column("b"))
        {printsql}a + b

    �binaryrr r3rrr�r[r�TrriNrOror�rcCs�t|t�r
t�|�}|��|��f|_|jp|j|_|j|d�|_|j|d�|_	||_
t�|�|_
||_t�|�|_|durCi|_dS||_dSr)r�r�r�	custom_opr��_origr�rrr r3rr1r�rr�rtr)r�rr r3rorrrwrwryr�$s



zBinaryExpression.__init__rsrcCs|j|jfSrv)rr r�rwrwryrCr�z,BinaryExpression._flattened_operator_clausescCs&|jtjtjfvr|j|j�Std��)aImplement Python-side "bool" for BinaryExpression as a
        simple "identity" check for the left and right attributes,
        if the operator is "eq" or "ne".  Otherwise the expression
        continues to not support "bool" like all other column expressions.

        The rationale here is so that ColumnElement objects can be hashable.
        What?  Well, suppose you do this::

            c1, c2 = column("x"), column("y")
            s1 = set([c1, c2])

        We do that **a lot**, columns inside of sets is an extremely basic
        thing all over the ORM for example.

        So what happens if we do this? ::

            c1 in s1

        Hashing means it will normally use ``__hash__()`` of the object,
        but in case of hash collision, it's going to also do ``c1 == c1``
        and/or ``c1 == c2`` inside.  Those operations need to return a
        True/False value.   But because we override ``==`` and ``!=``, they're
        going to get a BinaryExpression.  Hence we implement ``__bool__`` here
        so that these comparisons behave in this particular context mostly
        like regular object comparisons.  Thankfully Python is OK with
        that!  Otherwise we'd have to use special set classes for columns
        (which we used to do, decades ago).

        r:)r3r�eq�ner�r;r�rwrwryr<IszBinaryExpression.__bool__r��BinaryExpression[_T]cCrurvrwr�rwrwryr0qr�zBinaryExpression.__invert__r�cCs|jj|jjSrv)rr�r r�rwrwryr�u�zBinaryExpression._from_objectscCsB|jdurt|j|j�|j|j�|j|j|j|jd�S|���	�S)N)rror)
rr&rr r�r3r�rrr/r�rwrwryr/ys
�	zBinaryExpression._negate)NNN)rrir rir3rOror�rrrrr,)r�r�rsr�rD)r�r�r�r�r�r6rqrr�r�r�rHr�rtr�r^rr<r_rr0r<r`r�r/rwrwrwryr&�sJ
��
��
�&
r&c@sPeZdZUdZdZdejfdejfdejfgZded<dd	d
�Z	dddd�Z
dS)�Slicez�Represent SQL for a Python array-slice object.

    This is not a specific SQL construct at this level, but
    may be interpreted by specific dialects, e.g. PostgreSQL.

    �slice�start�stop�stepr[r�NcCsTtjtj||tjd�|_tjtj||tjd�|_tjtj||tjd�|_tj	|_
dS)N)r�ro)rrrr0rr�r�r�r�r	r�)r�r�r�r��_namerwrwryr��s&���zSlice.__init__rrrsrAcCs|tjusJ�|Srv)r3�getitemrrwrwryr�szSlice.self_grouprvrb)r�r�r�r�r�r6rqr�rHr�rrwrwrwryr��s
�
r�c@r�)�IndexExpressionzJRepresent the class of expressions that are like an "index"
    operation.TN)r�r�r�r�r�rwrwrwryr��sr�c@s2eZdZUdZdZded<ddd
d�Zdd
�ZdS)�GroupedElementz&Represent any parenthesized expression�groupingr�r�NrrrsrAcCr�rvrwrrwrwryr�rgzGroupedElement.self_groupcCs
|j��Srv)r�rr�rwrwryr�r�zGroupedElement._ungrouprvrb)r�r�r�r�r�rHrrrwrwrwryr��s
r�c@s�eZdZUdZdejfdejfgZded<dejfgZ	ded<d#dd�Z
d	d
�Zej
dd��Zejd$dd��Zejd%dd��Zejd&dd��Zdd�Zdd�Zdd�Zer^	d'd(d!d"�ZdSdS))rz/Represent a grouping within a column expressionr�r�r[r��0Union[TextClause, ClauseList, ColumnElement[_T]]cCs"||_t|dtj�|_|j|_dS)Nr�)r�r�rr	r�r�r�rwrwryr��szGrouping.__init__cCs|�|j�|��Srv)r�r�r�r�rwrwryr���z"Grouping._with_binary_element_typecCrurv�r�rtr�rwrwryrt�rwzGrouping._is_implicitly_booleanrsr�cCst|jdd�p	|jSrh)r�r�rDr�rwrwryr��s�zGrouping._tq_labelr�cCst|jt�r
|jgSgSrv)r�r�r6r�rwrwryr��r�zGrouping._proxiesr�cCrurvr�r�rwrwryr��rwzGrouping._from_objectscCst|j|�Srv)r�r�)r��attrrwrwryr�r�zGrouping.__getattr__cCs|j|jd�S)N�r�r�r�r�rwrwryr���zGrouping.__getstate__cCs|d|_|d|_dS)Nr�r�r�rrwrwryr�s
zGrouping.__setstate__NrrrAcCrurvrwrrwrwryrr�zGrouping.self_group)r�r�rBrmrDrvrb)r�r�r�r�r6rqr�r�rHr�r�r�r<rErtr�r�r�r`r�rr�rrrrwrwrwryr�s2
��
	
��rc@s(eZdZdZdZddd	�Zddd�ZdS)�_OverrideBindsaused by cache_key->_apply_params_to_element to allow compilation /
    execution of a SQL element that's been cached, using an alternate set of
    bound parameter values.

    This is used by the ORM to swap new parameter values into expressions
    that are embedded into loader options like with_expression(),
    selectinload().  Previously, this task was accomplished using the
    .params() method which would perform a deep-copy instead.  This deep
    copy proved to be too expensive for more complex expressions.

    See #11085

    �override_bindsr�r�r�r��replaces_paramscCs ||_dd�t||�D�|_dS)NcSsi|]	\}}|j|j�qSrw)r�rnr�rwrwryr�r�z+_OverrideBinds.__init__.<locals>.<dictcomp>)r�r\�	translate)r�r�r�r�rwrwryr�s�z_OverrideBinds.__init__r\�List[BindParameter[Any]]rs� Optional[typing_Tuple[Any, ...]]cs.g}�j�||�}|��fdd�|D��|S)ztgenerate a cache key for the given element, substituting its bind
        values for the translation values present.c3s8�|]}|j�jvr|j�j|jddd�n|VqdS)TF)r
r	N)r�r�r�)r�r~r�rwryr&+s����
�z0_OverrideBinds._gen_cache_key.<locals>.<genexpr>)r�r��extend)r�r\r��existing_bps�ckrwr�ryr�"s�z_OverrideBinds._gen_cache_keyN)r�r�r�r�r�r�)r\r\r�r�rsr�)r�r�r�r�r�r�r�rwrwrwryr�s

r�c@r�)�
_OverRangerrN)r�r�r��RANGE_UNBOUNDED�
RANGE_CURRENTrwrwrwryr�9�r�c@s�eZdZUdZdZdejfdejfdejfdejfdejfgZde	d	<d
Z
de	d<d
Zde	d<de	d<	d
e	d<d
e	d<	
	
	
	
dd dd�Zdd�Z
d!dd�ZesYejd"dd��Zejd#dd��Zd
S)$�OveraRepresent an OVER clause.

    This is a special operator against a so-called
    "window" function, as well as any aggregate function,
    which produces results relative to the result set
    itself.  Most modern SQL backends now support window functions.

    �overr��order_by�partition_by�range_�rowsr[r�N�Optional[ClauseList]r�z0Optional[typing_Tuple[_IntOrRange, _IntOrRange]]�Optional[_ByArgument]�4Optional[typing_Tuple[Optional[int], Optional[int]]]cCs�||_|durtt�|�dtji�|_|dur#tt�|�dtji�|_|r7|�|�|_	|r2t
�d��d|_dS|rD|�|�|_d|_	dSd|_|_	dS)Nr�z*'range_' and 'rows' are mutually exclusive)
r�r�r<�to_listrr�r�r��_interpret_ranger�r:r�r�)r�r�r�r�r�r�rwrwryr�bs0�����

z
Over.__init__cCs|j|j|j|j|j|jffSrv)r�r�r�r�r�r�r�rwrwry�
__reduce__�s�zOver.__reduce__�:typing_Tuple[Optional[_IntOrRange], Optional[_IntOrRange]]rs�&typing_Tuple[_IntOrRange, _IntOrRange]c
Cs�t|t�rt|�dkrt�d��|\}}|durt}n't|t�r#|}nzt|�}Wnty;}zt�d�|�d}~ww|dkrBt	}|durLt}||fSt|t�rW|}||fSzt|�}Wntyo}zt�d�|�d}~ww|dkrvt	}||fS)Nr9z2-tuple expected for range/rowsz(Integer or None expected for range valuer)
r�r"r	r:r�r�r�rp�
ValueErrorr�)r�r��r0�r1�lowerr
�upperrwrwryr��sL

����
������zOver._interpret_rangercCrurvr�r�rwrwryr��rwz	Over.typer�cCs$ttjdd�|j|j|jfD���S)NcS�g|]	}|dur|j�qSrvrr%rwrwryr+��
�z&Over._from_objects.<locals>.<listcomp>)r3r/r0r�r�r�r�rwrwryr��s���zOver._from_objects�NNNN)
r�r�r�r�r�r�r�r�r�r�)r�r�rsr�rnrD)r�r�r�r�r�r6rqr�r�rHr�r�r�r�r�rr<rEr�r`r�rwrwrwryr�Ds6
	��!
	,r�c@s�eZdZUdZdZdejfdejfgZded<dZ	ded<d)dd�Z
d
d�Zddddd�d*dd�Ze
d+dd��Ze
d,d d��Zd-d"d�ZesNejd.d$d%��Zejd/d'd(��ZdS)0�WithinGroupa%Represent a WITHIN GROUP (ORDER BY) clause.

    This is a special operator against so-called
    "ordered set aggregate" and "hypothetical
    set aggregate" functions, including ``percentile_cont()``,
    ``rank()``, ``dense_rank()``, etc.

    It's supported only by certain database backends, such as PostgreSQL,
    Oracle Database and MS SQL Server.

    The :class:`.WithinGroup` construct extracts its type from the
    method :meth:`.FunctionElement.within_group_type`.  If this returns
    ``None``, the function's ``.type`` is used.

    �withingroupr�r�r[r�Nr��.Union[FunctionElement[_T], FunctionFilter[_T]]r�cGs.||_|durtt�|�dtji�|_dSdS)Nr�)r�r�r<r�rr�r�)r�r�r�rwrwryr��s���zWithinGroup.__init__cCs*|j|jf|jdurt|j�fSdfSr�)r�r�r�r"r�rwrwryr��s

��zWithinGroup.__reduce__)r�r�r�r�r�r�r�r�r�rs�Over[_T]cCst|||||d�S)z�Produce an OVER clause against this :class:`.WithinGroup`
        construct.

        This function has the same signature as that of
        :meth:`.FunctionElement.over`.

        �r�r�r�r��r�)r�r�r�r�r�rwrwryr��s�zWithinGroup.overrAcCrurvrwr�rwrwry�filterrgzWithinGroup.filter�_WithinGroup__criterion0rP�	criterion�FunctionFilter[_T]cGrurvrw)r�r�r�rwrwryr�r{�Union[Self, FunctionFilter[_T]]cGs|s|St|g|�R�S)z.Produce a FILTER clause against this function.)�FunctionFilter)r�r�rwrwryr�srcCs |j�|�}|dur|S|jjSrv)r��within_group_typer�)r��wgtrwrwryr� szWithinGroup.typer�cC� ttjdd�|j|jfD���S)NcSr�rvrr%rwrwryr+,r�z-WithinGroup._from_objects.<locals>.<listcomp>)r3r/r0r�r�r�rwrwryr�(�
���zWithinGroup._from_objects)r�r�r�r�)
r�r�r�r�r�r�r�r�rsr�)rsrA)r�rPr�rPrsr�)r�rPrsr�rnrD)r�r�r�r�r�r6rqr�rHr�r�r�r�rr�rr<rEr�r`r�rwrwrwryr��s0
�
�
r�c@s�eZdZUdZdZdejfdejfgZded<dZ	ded<d-dd�Z
ed.dd��Z				d/d0dd�Z
d1dd�Zd2d d!�Z	d3d4d%d&�ZesNejd5d(d)��Zejd6d+d,��ZdS)7r�a�Represent a function FILTER clause.

    This is a special operator against aggregate and window functions,
    which controls which rows are passed to it.
    It's supported only by certain database backends.

    Invocation of :class:`.FunctionFilter` is via
    :meth:`.FunctionElement.filter`::

        func.count(1).filter(True)

    .. seealso::

        :meth:`.FunctionElement.filter`

    �
funcfilter�funcr�r[r�NrM�+Union[FunctionElement[_T], WithinGroup[_T]]rPcGs||_|jj|g|�R�dSrv)rr��non_generative)r�rr�rwrwryr�PszFunctionFilter.__init__rsrAcGs>t|�D]}t�tj|�}|jdur|j|@|_q||_q|S)a
Produce an additional FILTER against the function.

        This method adds additional criteria to the initial criteria
        set up by :meth:`.FunctionElement.filter`.

        Multiple criteria are joined together at SQL render time
        via ``AND``.


        N)r3rrrrr�)r�r��critrwrwryr�Xs

zFunctionFilter.filterr��YOptional[Union[Iterable[_ColumnExpressionArgument[Any]], _ColumnExpressionArgument[Any]]]r�r�r�r�r�cCst|||||d�S)a�Produce an OVER clause against this filtered function.

        Used against aggregate or so-called "window" functions,
        for database backends that support window functions.

        The expression::

            func.rank().filter(MyClass.y > 5).over(order_by="x")

        is shorthand for::

            from sqlalchemy import over, funcfilter

            over(funcfilter(func.rank(), MyClass.y > 5), order_by="x")

        See :func:`_expression.over` for a full description.

        r�r�)r�r�r�r�r�rwrwryr�os#�zFunctionFilter.overr��WithinGroup[_T]cGst|g|�R�S)zUProduce a WITHIN GROUP (ORDER BY expr) clause against
        this function.
        )r�)r�r�rwrwry�within_group�szFunctionFilter.within_groupr	rcCrurvrw)r�r	rwrwryr��rcz FunctionFilter.within_group_typerrrcCst�tj|�rt|�S|Srv)rr�	filter_oprrrwrwryr�szFunctionFilter.self_grouprcCrurv)rr�r�rwrwryr��rwzFunctionFilter.typer�cCr)NcSr�rvrr%rwrwryr+�r�z0FunctionFilter._from_objects.<locals>.<listcomp>)r3r/r0rr�r�rwrwryr��rzFunctionFilter._from_objects)rrr�rP)r�rPrsrAr�)
r�rr�rr�r�r�r�rsr�)r�r�rsr)r	rrsrrvr+rnrD)r�r�r�r�r�r6rqr�rHr�r�r'r�r�r	r�rrr<rEr�r`r�rwrwrwryr�5s0
�
�
+
�r�c@s�eZdZUdZdZded<ded<ded<dd	�Zejd4dd��Z	e
jd5dd��Ze
jd5dd��Z
e
jdd��Ze
jdd��Z	d6d7dd�Z		d8d9d#d$�Zdddddd%�d:d2d3�ZdS);�NamedColumnFN�Optional[FromClause]�tabler�r�r�cCs,t|d�r|j|jkpt|d�o|j|jkS)Nr�r�)r.r�r�r{rwrwryr7�s�z$NamedColumn._compare_name_for_resultrscCr�rv�r�r�rwrwryr��r#zNamedColumn.descriptionr�cCs$|j}|r||jkr|�|�S|jS)z�table qualified label based on column key.

        for table-bound columns this is <tablename>_<column key/proxy key>;

        all other expressions it resolves to key/proxy key.

        )r�r��
_gen_tq_labelr�)r�r8rwrwryr��s	
zNamedColumn._tq_key_labelcCr\)z�table qualified label based on column name.

        for table-bound columns this is <tablename>_<columnname>; all other
        expressions it resolves to .name.

        �rr�r�rwrwryr��szNamedColumn._tq_labelcCr�r�rwr�rwrwryrr�r�z+NamedColumn._render_label_in_columns_clausecCr�rvrr�rwrwryr��r#zNamedColumn._non_anon_labelT�
dedupe_on_keyrrcCs|Srvrw)r�r�rrwrwryr�rczNamedColumn._gen_tq_labelr3rOrrrorrrtc	Cst|j|||j|d|d�S)NT)rrrorr)rr�r�rrwrwryr�s�zNamedColumn._bind_param�r�r�r=r>�disallow_is_literalr?rUr�rIr�r@r=r>rArr�rBcKs�t|r
t�tj|p|j�n|p|j|j|dd�}
|j|
_|dur$|j|
_|r,t	|�|
_
n|g|
_
|jdur>|jj�
|
j�|
_|
j|
fS)NF�rorCr�)r�rrrrEr�r�r�r�r3r�r�rFr#)r�r?r�r�r�r�r=r>rr�r�rwrwryrHs"
��

zNamedColumn._make_proxyr�rB�T�r�r�rrrrsr�r)
r3rOrrrorrrrrsrt�r?rUr�rIr�r@r�r�r�r�r=rrr>rArrrr�rrsrB)r�r�r�r�r
rHr7r<rGr�r+rar�r�rrr�rrrHrwrwrwryr�s6
	

�	��r�_PSc@s.eZdZUdZdZdejfdejfdejfgZ	de
d<dejfdejfgZde
d<d	e
d<	
dMdNdd�Zdd�Z
ejdd��ZdOdd�Zejdd��Zejdd��Zedd��ZejdPd d!��ZdMdQd%d&�Zd'd(�ZdRd/d0�Zed1d2��Zed3d4��Zedd5�dSd<d=�Zej dTd?d@��Z!d
d
dA�dUdKdL�Z"d
S)VrMz�Represents a column label (AS).

    Represent a label, as typically applied to any column-level
    element using the ``AS`` sql keyword.

    rNr�r��_elementr[r�r�r�Nr�r�r�ror�cCs�|}tjtj||d�}t|t�r|j}t|t�s|r||_nt�	t
|�t|dd��|_t|t�r4|j|_
|j|_|_|_||_|durJt�|�n|jj|_|g|_dS)Nr�r�rV)rrrr0r�rMr�r�r:rXr?r�r��_resolve_labelr�r�r�rrr1r�r�)r�r�r�ro�orig_elementrwrwryr�Hs.�

��

��zLabel.__init__cCs|j|j|j|jffSrv)r�r�rr�r�rwrwryr�oszLabel.__reduce__cCr�r�rwr�rwrwryrrrr�z%Label._render_label_in_columns_clauseFc	Crrrrrwrwryrvs�zLabel._bind_paramcCrurvr�r�rwrwryrt�rwzLabel._is_implicitly_booleancCrurv)r�rsr�rwrwryrs�rwzLabel._allow_label_resolvecCr�rvrwr�rwrwryr��r�zLabel._order_by_label_elementrscCs|jjtjd�Sr)rrr�as_r�rwrwryr��r�z
Label.elementrrrLcCs|j|jj|d�Sr)�_apply_to_innerrrrrwrwryr�r�zLabel.self_groupcCs|�|jj�Srv)rrr/r�rwrwryr/�r�z
Label._negate�fn� Callable[_PS, ColumnElement[_T]]r9�_PS.argsr��
_PS.kwargscOs.||i|��}||jurt|j||jd�S|SrX)rrMr�r�)r�rr9r��sub_elementrwrwryr�s
zLabel._apply_to_innercCrurv)r�r�r�rwrwryr��rwzLabel.primary_keycCrurv)r�r�r�rwrwryr��rwzLabel.foreign_keys)�clone�anonymize_labelsr#rZr$rrrr|cKsX|��||jfi|��|_|r*t�t|�t|jdd��|_|j|_|_	|_
dSdS)Nr�rV)�_reset_memoizationsrr:rXr?r�r�r�r�r�r�)r�r#r$r�rwrwry�_copy_internals�s��zLabel._copy_internalsr�cCrurvr�r�rwrwryr��rwzLabel._from_objects)r�r>r?rUr�rIr�r@r>rArBc		Ks�|s|jn|}|jj||dt|t�|||d�\}}||jkr,t|jt�s,t�d|j��|j|_|j	�
|�|jdur?|j|_|j|fS)NT)r�rr=r>r�r�z�Label name %s is being renamed to an anonymous label due to disambiguation which is not supported right now.  Please use unique names for explicit labels.)
r�r�rHr��_truncated_labelr:r:�InvalidRequestErrorr�r�r�r�r�)	r�r?r�r�r�r>r�r��erwrwryrH�s*

���

zLabel._make_proxyrv)r�r�r�r�ror�rr�)rrrsrL)rrr9r r�r!rsrL)r#rZr$rrr�rrsr|rD)r?rUr�rIr�r@r�r�r>rAr�rrsrB)#r�r�r�r�r�r6r�r�rqr�rHr�r�r�r+rarrrr<rErtrsr^r�r�rr/rr�r�r%r&r`r�rHrwrwrwryrM0sR
���'







�	�rMcs*eZdZUdZded<ded<dZdejfdejfdej	fdej
fgZd	ed
<dZded
<dZ
ded<dZded<dZded<dZedd��Z			dCdDdd�Zdd�dd�Ze�fdd ��ZdE�fd!d"�	ZedFd%d&��Zejd'd(��Zed)d*��Zd+d,�Z	-dGdHd0d1�Zdddddd2�dIdAdB�Z�Z S)Jr�a�Represents a column expression from any textual string.

    The :class:`.ColumnClause`, a lightweight analogue to the
    :class:`_schema.Column` class, is typically invoked using the
    :func:`_expression.column` function, as in::

        from sqlalchemy import column

        id, name = column("id"), column("name")
        stmt = select(id, name).select_from("user")

    The above statement would produce SQL like:

    .. sourcecode:: sql

        SELECT id, name FROM user

    :class:`.ColumnClause` is the immediate superclass of the schema-specific
    :class:`_schema.Column` object.  While the :class:`_schema.Column`
    class has all the
    same capabilities as :class:`.ColumnClause`, the :class:`.ColumnClause`
    class is usable by itself in those cases where behavioral requirements
    are limited to simple SQL expression generation.  The object has none of
    the associations with schema-level metadata or with execution-time
    behavior that :class:`_schema.Column` does,
    so in that sense is a "lightweight"
    version of :class:`_schema.Column`.

    Full details on :class:`.ColumnClause` usage is at
    :func:`_expression.column`.

    .. seealso::

        :func:`_expression.column`

        :class:`_schema.Column`

    rr
rrr�r�r�r�r[r�NzOptional[DefaultGenerator]�onupdater�zOptional[FetchedValue]�server_default�server_onupdateFcCs|jo|jdkSr�)r�r�r�rwrwryr],r�zColumnClause._is_starr�r�ror�rCcCs(||_|_||_t�|�|_||_dSrv)r�r�r
rr1r�r�)r�r�ror�rCrwrwryr�0s
zColumnClause.__init__)�
column_tablescKr�rvrw)r�r-r�rwrwryr�@r�zColumnClause.get_childrencs|jdur	|jjSt�jSrv)r
r�r~r�r�rwryr�Fs
zColumnClause.entity_namespacecsT|r!|jdur!|jjr!|�d�}||jfi|��}|j�|�}|St�jdi|��S)Nr#rw)r
�_is_subqueryr�r��corresponding_columnr~r%)r�rr�r#r
�newr�rwryr%Ms�
�
zColumnClause._clonersr�cCs|j}|dur
|gSgSrv�r
)r��trwrwryr�ZszColumnClause._from_objectscCs
|jduSrvr1r�rwrwryrrbr�z,ColumnClause._render_label_in_columns_clausecCs|j|jdd�S)NF)rrr�rwrwry�
_ddl_labelfr�zColumnClause._ddl_labelcCs~|js"|jdus"|jjs"t|d�r"t|t�r8|js"|jdus"|jjr8t|d�r-|j|jkp7t|d�o7|j|jkS|j�	|j�S)Nr(r�r�)
r�r
rPr.r�r�r�r�r(r5r{rwrwryr7js&�
����
�

�z%ColumnClause._compare_name_for_resultTrr�cCs,|j}|jrdS|dur�t|�r�t|�r(|jr(|j�dd�d|jd|}ntr1t|t	�s1J�|jd|}t
|�rQ|jdurQt
|�rJ|j|_n t||j�}nt
|j�rj|jjdurjt|t�rcJ�t||jj�}|r�||j
vr�|}d}||j
vr�|dt|�}|d7}||j
vsz|}t�tj|�S|S)z�generate table-qualified label

        for a table-bound column this is <tablename>_<columnname>.

        used primarily for LABEL_STYLE_TABLENAME_PLUS_COL
        as well as the .columns collection on a Join object.

        N�.rSr)r
r�r r�schema�replacer�rr�rVr!r�r�r�r�rrrrE)r�r�rr2rNr��counterrwrwryr�s4"

	

�zColumnClause._gen_tq_labelrr?rUr�rIr�r@r�r=r>rArr�rrBcKs�|o|jo|dup||jk}
|j|rt�tj|p|j�n|p!|j|j||
d�}|j|_|dur4|j	|_	|r<t
|�|_n|g|_|jdurN|jj
�|j	�|_|j	|fS)Nr)r�r�r�rrrrEr�r�r�r3r�r�rFr#)r�r?r�r�r�r�r=r>rr�r�r�rwrwryrH�s.��
��


zColumnClause._make_proxy)NFN)r�r�ror�r�rrrCrr�rDrrr)!r�r�r�r�rHr�r6r�r�rqr�r�r*r�r+r,�_is_multiparam_columnr^r]r�r�r�r%r=r�r+rarrr3r7rrHr�rwrwr�ryr��sP
'�
�


�>�r�c@s^eZdZUdZdejfdejfdejfgZde	d<dd
d�Z
efddd�Ze
jddd��ZdS)�TableValuedColumn�table_valued_columnr�r��scalar_aliasr[r�rVrorcCs||_|j|_|_||_dSrv)r;r�r�r�)r�r;rorwrwryr��s
zTableValuedColumn.__init__r#rZr�rrsr|cKs(||jfi|��|_|jj|_|_dSrv)r;r�r�)r�r#r�rwrwryr&�sz!TableValuedColumn._copy_internalsr�cCs|jgSrv)r;r�rwrwryr�rwzTableValuedColumn._from_objectsN)r;rVror)r#rZr�rrsr|rD)r�r�r�r�r6r�r�rqr�rHr�r%r&r<r`r�rwrwrwryr9�s
�
�r9c@sFeZdZUdZdejfgZded<ee	�
d�dd
d���Zdd
�ZdS)r�r�r[r�rVr �_ColumnExpressionArgument[str]r�rs�BinaryExpression[str]cCsRtjj}t�tjt|�}|jj	|j
ur|j�|�}n|j}t|t
|�tj|d�SrX)r<r�r[rrrr0r�r�r��String�_with_collationr&r�rr�)r�r r�r]r��collate_typerwrwry�_create_collation_expressions�z,CollationClause._create_collation_expressioncCr�rv)r�r�rwrwryr�"r�zCollationClause.__init__N)r r<r�r�rsr=)
r�r�r�r�r6r�r�rHr�r<r�rAr�rwrwrwryr�s
�r�c@�eZdZdZdd�ZdS)�_IdentifiedClause�
identifiedcCr�rv)�ident)r�rErwrwryr�)r�z_IdentifiedClause.__init__N)r�r�r�r�r�rwrwrwryrC&srCc@r�)�SavepointClause�	savepointFN�r�r�r�r�r�rwrwrwryrF-r�rFc@r�)�RollbackToSavepointClause�rollback_to_savepointFNrHrwrwrwryrI2r�rIc@r�)�ReleaseSavepointClause�release_savepointFNrHrwrwrwryrK7r�rKcszeZdZUdZdZded<eeddd	���Zeeddd	���Zeddd	��Zd�fdd�Z	dd�Z
dd�Zdd�Z�Z
S)r�a�Represent a SQL identifier combined with quoting preferences.

    :class:`.quoted_name` is a Python unicode/str subclass which
    represents a particular identifier name along with a
    ``quote`` flag.  This ``quote`` flag, when set to
    ``True`` or ``False``, overrides automatic quoting behavior
    for this identifier in order to either unconditionally quote
    or to not quote the name.  If left at its default of ``None``,
    quoting behavior is applied to the identifier on a per-backend basis
    based on an examination of the token itself.

    A :class:`.quoted_name` object with ``quote=True`` is also
    prevented from being modified in the case of a so-called
    "name normalize" option.  Certain database backends, such as
    Oracle Database, Firebird, and DB2 "normalize" case-insensitive names
    as uppercase.  The SQLAlchemy dialects for these backends
    convert from SQLAlchemy's lower-case-means-insensitive convention
    to the upper-case-means-insensitive conventions of those backends.
    The ``quote=True`` flag here will prevent this conversion from occurring
    to support an identifier that's quoted as all lower case against
    such a backend.

    The :class:`.quoted_name` object is normally created automatically
    when specifying the name for key schema constructs such as
    :class:`_schema.Table`, :class:`_schema.Column`, and others.
    The class can also be
    passed explicitly as the name to any function that receives a name which
    can be quoted.  Such as to use the :meth:`_engine.Engine.has_table`
    method with
    an unconditionally quoted name::

        from sqlalchemy import create_engine
        from sqlalchemy import inspect
        from sqlalchemy.sql import quoted_name

        engine = create_engine("oracle+oracledb://some_dsn")
        print(inspect(engine).has_table(quoted_name("some_table", True)))

    The above logic will run the "has table" logic against the Oracle Database
    backend, passing the name exactly as ``"some_table"`` without converting to
    upper case.

    .. versionchanged:: 1.2 The :class:`.quoted_name` construct is now
       importable from ``sqlalchemy.sql``, in addition to the previous
       location of ``sqlalchemy.sql.elements``.

    )r�r�r�r�r�rnr�rscCrurvrw�r�rnr�rwrwryr�qr�zquoted_name.constructr|cCrurvrwrMrwrwryr�ur�r��Optional[quoted_name]cCs|durdSt||�Srv)r�rMrwrwryr�ys
csH|dusJd��t||�r|dus|j|kr|St��||�}||_|S)Nz0use quoted_name.construct() for None passthrough)r�r�r~r�)r�rnr�r�r�rwryr��s
�zquoted_name.__new__cCstt|�|jffSrv)r�r�r�r�rwrwryr��r�zquoted_name.__reduce__cC�|jr|St|���Srv)r�r�r�r�rwrwry�_memoized_method_lower��z"quoted_name._memoized_method_lowercCrOrv)r�r�r�r�rwrwry�_memoized_method_upper�rQz"quoted_name._memoized_method_upper)rnr�r�r�rsr�)rnr|r�r�rsr|)rnr�r�r�rsrN)r�r�r�r�r�rHrr�r�r�r�rPrRr�rwrwr�ryr�<s 
0r�r��Set[ColumnClause[Any]]cCst�}t|id|ji�|S)z2locate Column objects within the given expression.r�)�setr7r�)r�r�rwrwry�
_find_columns�srU�args�Sequence[ColumnElement[_T]]rcCs"|D]}|jjs
|jSqtjSrv)r�rYrr	)rV�arwrwry�_type_from_args�s

�rYcCs8|j||d�}|durt�d|t|dd�|jf��|S)N)�require_embeddedzbGiven column '%s', attached to table '%s', failed to locate a corresponding column from table '%s'r
)r/r:r(r�r�)�
fromclauser�rZr�rwrwry�_corresponding_column_or_error�s���r\c@rB)�#_memoized_property_but_not_nulltypez,memoized property, but dont memoize NullTypecCs,|dur|S|�|�}|js||j|j<|Srv)�fgetrYr�r�)r�rr��resultrwrwry�__get__�s
z+_memoized_property_but_not_nulltype.__get__N)r�r�r�r�r`rwrwrwryr]�sr]cs�eZdZUded<dd�Z�fdd�Zejdd��Ze	d	d
��Z
ejdd��Zejd
d��Zejddd��Z
ejddd��Z�ZS)�AnnotatedColumnElementri�_Annotated__elementcCsRt�|||�dD]	}|j�|d�q	dD]}|j�|d�dur&|j�|�qdS)N)rr�r�r�r�r�)r�r�r
F)r#r�r�r�r#)r�r�r�r�rwrwryr��s��zAnnotatedColumnElement.__init__cs(t��|�}dD]	}|j�|d�q|S)N)rr�r�r�r�)r~�_with_annotationsr�r�)r�r�r#r�r�rwryrc�sz(AnnotatedColumnElement._with_annotationscCru)z'pull 'name' from parent, if not present)rbr�r�rwrwryr���zAnnotatedColumnElement.namecCru)a�pull 'type' from parent and don't cache if null.

        type is routinely changed on existing columns within the
        mapped_column() initialization process, and "type" is also consulted
        during the creation of SQL expressions.  Therefore it can change after
        it was already retrieved.  At the same time we don't want annotated
        objects having overhead when expressions are produced, so continue
        to memoize, but only when we have a non-null type.

        )rbr�r�rwrwryr��szAnnotatedColumnElement.typecCru)z(pull 'table' from parent, if not present)rbr
r�rwrwryr
�rdzAnnotatedColumnElement.tablecCru)z&pull 'key' from parent, if not present)rbr�r�rwrwryr��rdzAnnotatedColumnElement.keyrsrFcCstr
t|jt�s
J�|jjSrv)rr�rbrP�infor�rwrwryreszAnnotatedColumnElement.infor�cCrurv)rbrDr�rwrwryrD	rwz'AnnotatedColumnElement._anon_name_label)rsrFr�)r�r�r�rHr�rcr<rEr�r]r�r
r�rerDr�rwrwr�ryra�s 




racs<eZdZdZdZdd�fd
d�
Zddd
�Zddd�Z�ZS)r'zVA unicode subclass used to identify symbolic "
    "names that may require truncation.rwNrnr�r�r�rsrcst|d|�}t��|||�S)Nr�)r�r~r�rMr�rwryr�sz_truncated_label.__new__cCs|jt|�|jffSrv)r�r�r�r�rwrwryr�r4z_truncated_label.__reduce__�map_r�cCr�rvrw�r�rfrwrwry�	apply_maprgz_truncated_label.apply_maprv)rnr�r�r�rsrr7)rfr�rsr�)	r�r�r�r�r�r�r�rhr�rwrwr�ryr's
r'c@r�)�convaMark a string indicating that a name has already been converted
    by a naming convention.

    This is a string subclass that indicates a name that should not be
    subject to any further naming conventions.

    E.g. when we create a :class:`.Constraint` using a naming convention
    as follows::

        m = MetaData(
            naming_convention={"ck": "ck_%(table_name)s_%(constraint_name)s"}
        )
        t = Table(
            "t", m, Column("x", Integer), CheckConstraint("x > 5", name="x5")
        )

    The name of the above constraint will be rendered as ``"ck_t_x5"``.
    That is, the existing name ``x5`` is used in the naming convention as the
    ``constraint_name`` token.

    In some situations, such as in migration scripts, we may be rendering
    the above :class:`.CheckConstraint` with a name that's already been
    converted.  In order to make sure the name isn't double-modified, the
    new name is applied using the :func:`_schema.conv` marker.  We can
    use this explicitly as follows::


        m = MetaData(
            naming_convention={"ck": "ck_%(table_name)s_%(constraint_name)s"}
        )
        t = Table(
            "t",
            m,
            Column("x", Integer),
            CheckConstraint("x > 5", name=conv("ck_t_x5")),
        )

    Where above, the :func:`_schema.conv` marker indicates that the constraint
    name here is final, and the name will render as ``"ck_t_x5"`` and not
    ``"ck_t_ck_t_x5"``

    .. seealso::

        :ref:`constraint_naming_conventions`

    rwNr�rwrwrwryri s/ric@s@eZdZdZdZe		dddd��Zdd�Zdd�Zdd�Z	dS)r:zDA unicode subclass used to identify anonymously
    generated names.rwNFrOrp�bodyr�rUr�r�rrrscCsHt�dd|�}|r|�d�}d||�dd�f}|r d||f}t|�S)Nz[%\(\) \$]+rSz
%%(%d %s)s�%�%%z%s%s)r�r��stripr6r:)r�rOrjrUr�rNrwrwryrX`s

z_anonymous_label.safe_constructcCsDd|vrt|t�st|��dd�}nt|�}ttt�||�|j��S�Nrkrl�r�r:r�r6r�r�r�r{rwrwryr�v�
��z_anonymous_label.__add__cCsDd|vrt|t�st|��dd�}nt|�}ttt�||�|j��Srnror{rwrwryr��rpz_anonymous_label.__radd__cCs"|jdur
t|||j�S||Srv)r�r�rgrwrwryrh�s
z_anonymous_label.apply_mapr)
rOrprjr�rUr�r�rrrsr:)
r�r�r�r�r�r�rXr�r�rhrwrwrwryr:Zs�

r:r�)rnrrorprqrrrsrtr)rnreror|rqrrrsrt)rnrror}rqrrrsr~rv)r�r�ror�rsr�)r�r�rsrS)rVrWrsr)�r��
__future__r�decimalr�enumrr/r3r�r_rrrrr	r
rrr
rrrrrrr�typing_TuplerrrrrTrrrrr�_typingrr r!r"�
annotationr#r$�baser%r&r'r(r)r*r+r,r-r.r r/r0r1r2r3�visitorsr4r5r6r7r8r:r;r<r=r>�util.typingr?r@rArBrCrDrErFrGrHrIrJrK�compilerrLrM�	functionsrNrOr5rPrQrRrSr?rTrUrVrWr]rXrYrZr[r\�enginer]r^�engine.interfacesr_r`rarbrc�
engine.resultrd�floatrkrprmrergrirjrlrzr�r��_self_inspectsr�rb�
DMLColumnRole�DDLConstraintColumnRole�ColumnsClauseRolerdrfr0r��_SQO�ColumnArgumentOrKeyRole�StatementOptionRoler�BinaryElementRole�OrderByRole�LimitOffsetRole�DDLExpressionRoler6rvrw�
InElementRolerr��FromClauseRole�SelectStatementRole�Inspectabler��
ConstExprRoler��_create_singletonrrr�r�r�rr$rzr�r�rcrKrzr|r�r�r�r7r�r�r&r�r�r�rr�r�r�r��_IntOrRanger�r�r�rrr�rM�DDLReferredColumnRole�StrAsPlainColumnRoler�r9r�r�rCrFrIrK�
MemoizedSlotsr�rUrYr\rEr]rar'ri�_generated_labelr:rwrwrwry�<module>s$���	�&�&]
�;
�
}�
�yB 
�
�$
�lX[QMa<@@*@3jk
<�!a

�F7