o

���g���@
sl
dZd
dl
mZ
d
dlZd
dlmZ
d
dlZd
dlmZ
d
dlm	Z

d
dlm	Z	
d
dlmZ
d
dlmZ
d
d	lm
Z

d
d
lmZ
d
dlmZ
d
dlmZ
d
d
lmZ
d
dlmZ
d
dlmZ
d
dlmZ
d
dlmZ
d
dlmZ
d
dlmZ
d
dlmZ
d
dlmZ
d
dlmZ
d
dlmZ
d
dlmZ
ddlmZ
ddlmZ
ddlm Z 
ddlm!Z!
ddlm"Z"
ddlm#Z#
dd lm$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%m-Z-
dd)l.m/Z/
dd*l.m0Z0
dd+l1m2Z2
dd,l1m3Z3
dd-l1m4Z4
dd.l1m5Z5
dd/l1m6Z6
dd0l1m7Z7
dd1l1m8Z8
dd2l1m9Z9
dd3l1m:Z:
dd4l1m;Z;
dd5l1m<Z<
dd6l1m=Z=
dd7l1m>Z>
dd8l1m?Z?
dd9l1m@Z@
dd:l1mAZA
dd;l1mBZB
dd<l1mCZC
dd=l1mDZD
dd>l1mEZE
dd?l1mFZF
dd@lmGZG
ddAlHmIZI
ddBlHmJZJ
ddClHmKZK
ddDlHmLZL
ddElHmMZM
ddFlHmNZN
ddGlHmOZO
ddHlHmPZP
ddIlHmQZQ
ddJlHmRZR
ddKlHmSZS
ddLlHmTZT
ddMl mUZU
ddNlVmWZW
ddOl$mXZX
ddPl$mYZY
ddQl$mZZZ
dRdSlm[Z[
dRdTlm\Z\
dRdUl\m]Z]
dRdVl^m_Z_
dRdWl^m`Z`
dRdXl^maZa
eKjbZbedYe	dZ�Zce�r�dd[l%mdZd
dd\l%meZe
dd]l%mfZf
dd^l%mgZg
dd_l%mhZh
dd`l%miZi
ddal%mjZj
ddbl%mkZk
ddcl%mlZl
dddl%mmZm
ddel%mnZn
ddfl%moZo
ddgl%mpZp
ddhl%mqZq
ddil%mrZr
ddjl%msZs
ddkl%mtZt
ddll%muZu
ddml%mvZw
ddnl%mxZx
ddol1myZy
ddpl1mzZz
ddql1m{Z{
ddrlm|Z|
ddsl}m~Z~
ddtlm�Z�
ddulm�Z�
ddvlHm�Z�
ddwlHm�Z�
ddxlHm�Z�
ddylHm�Z�
ddzlHm�Z�
dd{l�m�Z�
dd|l�m�Z�
dd}l�m�Z�
dd~lVm�Z�
ddl#m�Z�
dd�l$m�Z�
ed�eOe	d�fZ�eed�g
ee�fZ�Gd�d��d�e`�Z�ed�e�fZ�ed�e�fZ�eed�ed�fZ�ee�ee�ed�e
e�e	ffZ�eed�Z�Gd�d��d�eJe��Z�Gd�d��d�e!j�eP�Z�Gd�d��d�eBe��Z�Gd�d��d�e�ee(�Z�Gd�d��d�e��Z�Gd�d��d��Z�Gd�d��d��Z�Gd�d��d��Z�Gd�d��d�e!j�e��Z�Gd�d��d�e��Z�Gd�d��d�e�Z�e�e��
\Z�Z�Z�Z�e�Z�Gd�d��d�e!j�e��Z�Gd�d��d��Z�Gd�d��d�e��Z�Gd�d��d�e�e��Z�Gd�d��d�e��Z�Gd�d��d�e!j�e��Z�Gd�d��d�e�e��Z�Gd�d��d�e�e��Z�Gd�d��d�e��Z�Gd�d��d�e!j�e!j�eCe�e�e��Z�Gd�d��d�e�Z�Gd�d��d�e�Z�Gd�d��d�e��Z�Gd�d��d�e!j�e��Z�Gd�d��d�e��Z�Gd�d��d�eQe��Z�Gd�d��d�e�e��Z�Gd�d��d�e!j�eFe��Z�ed�de�e
e�e	ffZ�Gd�d„d�eL�Z�Gd�dńd�e!j�eCe��Z�Gd�dDŽd�e!j�eQeOe	�Z�Gd�dɄd�e!j�e!j�e!j�e!j�e�e0e��	Z�ed�e�dZ�Z�Gd�d̄d�eQe�ee��Z�Gd�d΄d�e�eC�Z�e@��d�dСGd�d҄d�e@��
Z�Gd�dԄd�e�Z�Gd�dքd�eDe�e��Z�e�D]
Z�e�e�e�j�e҃
�q�e@��d�dסGd�dلd�e\j�e@��
Z�Gd�dۄdۃZ�Gd�d݄d�ej�e"j�e$jڃZ�Gd�d߄d�e�e�e�eDe�e�e�e(�	Z�Gd�d�d�e!j�eCeQeOec�Z�Gd�d�d�eTe��Z�Gd�d�d�e�e�eC�Z�e�Z�	Gd�d�d�e/�Z�dS)�ztThe :class:`_expression.FromClause` class of SQL expression elements,
representing
SQL tables and derived rowsets.

�)
�annotationsN)
�Enum)
�AbstractSet)
�Any)
�Callable)
�cast)
�Dict)
�Generic)
�Iterable)
�Iterator)
�List)
�
NamedTuple)
�NoReturn)
�Optional)
�overload)
�Sequence)
�Set)
�Tuple)
�Type)
�
TYPE_CHECKING)
�TypeVar)
�Union�
)
�	cache_key)
�	coercions)
�	operators)
�roles)
�
traversals)
�type_api)
�visitors)
�_ColumnsClauseArgument)
�_no_kw)
�_TP�
�is_column_element)
�is_select_statement)
�is_subquery)
�is_table)
�is_text_clause)
�	Annotated)
�SupportsCloneAnnotations)
�_clone)
�_cloned_difference�
�_cloned_intersection�
�_entity_namespace_key)
�_EntityNamespace)
�_expand_cloned�
�
_from_objects)
�_generative�
�_never_select_column)
�_NoArg)
�_select_iterables)
�CacheableOptions)
�ColumnCollection)
�	ColumnSet)
�CompileState)
�DedupeColumnCollection)
�
Executable)
�
Generative)
�HasCompileState)
�HasMemoized)
�	Immutable)
�_document_text_coercion)
�_anonymous_label)
�
BindParameter)
�BooleanClauseList)
�
ClauseElement)
�
ClauseList)
�ColumnClause)
�
ColumnElement)
�DQLDMLClauseElement)
�GroupedElement)
�literal_column)
�TableValuedColumn)
�UnaryExpression)
�OperatorType)
�NULLTYPE)
�_TraverseInternalsType)
�InternalTraversal)
�prefix_anon_map�)
�exc)
�util)
�!HasMemoized_ro_memoized_attribute)
�Literal)
�Protocol)
�Self�_T)
�bound)
�_ColumnExpressionArgument)
�#_ColumnExpressionOrStrLabelArgument)
�_FromClauseArgument)
�_JoinTargetArgument)
�_LimitOffsetType)
�
_MAYBE_ENTITY)
�_NOT_ENTITY)
�_OnClauseArgument)
�#_SelectStatementForCompoundArgument)
�_T0)
�_T1)
�_T2)
�_T3)
�_T4)
�_T5)
�_T6)
�_T7)
�_TextCoercedExpressionArgument)
�_TypedColumnClauseArgument)
�_TypeEngineArgument)
�_AmbiguousTableNameMap)
�ExecutableOption)
�ReadOnlyColumnCollection)
�_CacheKeyTraversalType)
�SQLCompiler)
�Delete)
�Update)
�BinaryExpression)
�KeyedColumnElement)
�Label)
�NamedColumn)
�
TextClause)
�Function)
�
ForeignKey)
�ForeignKeyConstraint)
�TableValueType)
�
TypeEngine)
�_CloneCallableType�
FromClauser~)�ColumnElement[Any]r~c@
s,eZ
dZejd	dd��
Zejd
dd��
ZdS)�_JoinTargetProtocol�return�List[FromClause]c


C
�dS�
N��
�selfr�r��D/usr/local/lib/python3.10/dist-packages/sqlalchemy/sql/selectable.pyr4��
z!_JoinTargetProtocol._from_objectsr1c


C
r�r�r�r�r�r�r��entity_namespace�r�z$_JoinTargetProtocol.entity_namespaceN�r�r��r�r1)�__name__�
__module__�__qualname__rX�ro_non_memoized_propertyr4r�r�r�r�r�r��s



r��ColumnElement[bool])�_ColumnExpressionArgument[Any]rar�c@
seZ
dZd
Zeddd��
ZdS)�_OffsetLimitParamTr��
Optional[int]c


C
�|jSr�)
�effective_valuer�r�r�r��_limit_offset_value��z%_OffsetLimitParam._limit_offset_valueN�r�r�)r�r�r��
inherit_cache�propertyr�r�r�r�r�r��s

r�c@
sneZ
dZd
ZdZdZdZdZdZe	d!dd��
Z
ejd"dd	��
Z
d#d
d�Zd$dd�Zd%dd�Ze	d&dd��
Zd S)'�ReturnsRowsa�
The base-most class for Core constructs that have some concept of
    columns that can represent rows.

    While the SELECT statement and TABLE are the primary things we think
    of in this category,  DML like INSERT, UPDATE and DELETE can also specify
    RETURNING which means they can be used in CTEs and other forms, and
    PostgreSQL has functions that return rows also.

    .. versionadded:: 1.4

    TFr�c


C
�|Sr�r�r�r�r�r��
selectable��zReturnsRows.selectable�_SelectIterablec


C
�t��
)
aE
A sequence of column expression objects that represents the
        "selected" columns of this :class:`_expression.ReturnsRows`.

        This is typically equivalent to .exported_columns except it is
        delivered in the form of a straight sequence and not  keyed
        :class:`_expression.ColumnCollection`.

        �
�NotImplementedErrorr�r�r�r��_all_selected_columns�s
z!ReturnsRows._all_selected_columns�
fromclause�Optional[FromClause]�boolc
C
r�)
z�Return ``True`` if this :class:`.ReturnsRows` is
        'derived' from the given :class:`.FromClause`.

        An example would be an Alias of a Table is derived from that Table.

        r��r�r�r�r�r��is_derived_from��zReturnsRows.is_derived_fromr��columns�.ColumnCollection[str, KeyedColumnElement[Any]]�primary_keyr<�foreign_keys�Set[KeyedColumnElement[Any]]�Nonec
C
r�)
z=Populate columns into an :class:`.AliasedReturnsRows` object.r��r�r�r�r�r�r�r�r��#_generate_fromclause_column_proxies�s	z/ReturnsRows._generate_fromclause_column_proxies�columnr�c
C
r�)
z>reset internal collections for an incoming column being added.r��r�r�r�r�r��_refresh_for_new_column�r�z#ReturnsRows._refresh_for_new_column�"ReadOnlyColumnCollection[Any, Any]c


C
r�)
aA :class:`_expression.ColumnCollection`
        that represents the "exported"
        columns of this :class:`_expression.ReturnsRows`.

        The "exported" columns represent the collection of
        :class:`_expression.ColumnElement`
        expressions that are rendered by this SQL
        construct.   There are primary varieties which are the
        "FROM clause columns" of a FROM clause, such as a table, join,
        or subquery, the "SELECTed columns", which are the columns in
        the "columns clause" of a SELECT statement, and the RETURNING
        columns in a DML statement..

        .. versionadded:: 1.4

        .. seealso::

            :attr:`_expression.FromClause.exported_columns`

            :attr:`_expression.SelectBase.exported_columns`
        r�r�r�r�r��exported_columns

szReturnsRows.exported_columnsN�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��__doc__�_is_returns_rows�_is_from_clause�_is_select_base�_is_select_statement�_is_lateralr�r�rXr�r�r�r�r�r�r�r�r�r�r��s 







	

r�c
@
�eZ
dZd
ZdS)�ExecutableReturnsRows�0base for executable statements that return rows.N�r�r�r�r�r�r�r�r�r�
�
r�c
@
r�)�TypedReturnsRowsr�Nr�r�r�r�r�r� 
r�r�c@
s^eZ
dZd
ZdZdZd"dd	�Zd#d$dd�Zej	ddd�e�
d�
d%dd��
�
Z	d&d'd d!�Zd
S)(�
Selectablez!Mark a class as being selectable.r�Tr�r�r�r�c
C
r�r�r�r�r�r�r�r�+
�
z"Selectable._refresh_for_new_columnN�name�
Optional[str]�LateralFromClausecC
�tj
||
d
�S)�;
Return a LATERAL alias of this :class:`_expression.Selectable`.

        The return value is the :class:`_expression.Lateral` construct also
        provided by the top-level :func:`_expression.lateral` function.

        .. seealso::

            :ref:`tutorial_lateral_correlation` -  overview of usage.

        �
r�)�Lateral�
_construct�r�r�r�r�r��lateral.
szSelectable.lateral�1.4z�The :meth:`.Selectable.replace_selectable` method is deprecated, and will be removed in a future release.  Similar functionality is available via the sqlalchemy.sql.visitors module.)
�message�sqlalchemy.sql.util�oldr��alias�Aliasr\cC
stj
j�|�
�|�
S)
z�Replace all occurrences of :class:`_expression.FromClause`
        'old' with the given :class:`_expression.Alias`
        object, returning a copy of this :class:`_expression.FromClause`.

        )rX�	preloaded�sql_util�
ClauseAdapter�traverse)r�r�r�r�r�r��replace_selectable;
s
zSelectable.replace_selectableF�KeyedColumnElement[Any]�require_embeddedr��!Optional[KeyedColumnElement[Any]]cC
s|j�
|
|�S)
a�Given a :class:`_expression.ColumnElement`, return the exported
        :class:`_expression.ColumnElement` object from the
        :attr:`_expression.Selectable.exported_columns`
        collection of this :class:`_expression.Selectable`
        which corresponds to that
        original :class:`_expression.ColumnElement` via a common ancestor
        column.

        :param column: the target :class:`_expression.ColumnElement`
                      to be matched.

        :param require_embedded: only return corresponding columns for
         the given :class:`_expression.ColumnElement`, if the given
         :class:`_expression.ColumnElement`
         is actually present within a sub-element
         of this :class:`_expression.Selectable`.
         Normally the column will match if
         it merely shares a common ancestor with one of the exported
         columns of this :class:`_expression.Selectable`.

        .. seealso::

            :attr:`_expression.Selectable.exported_columns` - the
            :class:`_expression.ColumnCollection`
            that is used for the operation.

            :meth:`_expression.ColumnCollection.corresponding_column`
            - implementation
            method.

        )r��corresponding_column)r�r�r�r�r�r�r�J
s#
�zSelectable.corresponding_columnr�r��r�r�r�r�)r�r�r�r�r�r\�
F)r�r�r�r�r�r�)
r�r�r�r��__visit_name__�
is_selectabler�r�rX�
deprecated�preload_moduler�r�r�r�r�r�r�$
s




�
	�r�c@
�NeZ
dZUd
Zded<dejfg
Zded<ee	ddd�d	d
�
ddd��
�
Z
dS)�HasPrefixesr��+Tuple[Tuple[DQLDMLClauseElement, str], ...]�	_prefixesrS� _has_prefixes_traverse_internals�prefixesz+:meth:`_expression.HasPrefixes.prefix_with`z.:paramref:`.HasPrefixes.prefix_with.*prefixes`�
*�
�dialect�#_TextCoercedExpressionArgument[Any]r��strr�r\c


�"|jt
�f
d
d�|D�
�
|_|S)aqAdd one or more expressions following the statement keyword, i.e.
        SELECT, INSERT, UPDATE, or DELETE. Generative.

        This is used to support backend-specific prefix keywords such as those
        provided by MySQL.

        E.g.::

            stmt = table.insert().prefix_with("LOW_PRIORITY", dialect="mysql")

            # MySQL 5.7 optimizer hints
            stmt = select(table).prefix_with("/*+ BKA(t1) */", dialect="mysql")

        Multiple prefixes can be specified by multiple calls
        to :meth:`_expression.HasPrefixes.prefix_with`.

        :param \*prefixes: textual or :class:`_expression.ClauseElement`
         construct which
         will be rendered following the INSERT, UPDATE, or DELETE
         keyword.
        :param dialect: optional string dialect name which will
         limit rendering of this prefix to only that dialect.

        c

�g|]}
t�
tj|
��f�qSr��r�expectr�StatementOptionRole��.0�
pr�r�r��
<listcomp>�
���z+HasPrefixes.prefix_with.<locals>.<listcomp>)r��tuple)r�r�r�r�r�r��prefix_withy
s#

��zHasPrefixes.prefix_withN)r�r�r�r�r�r\)r�r�r�r��__annotations__rT�dp_prefix_sequencer�r5rDr
r�r�r�r�r�r
�

�



��r�c@
r�)�HasSuffixesr�r��	_suffixesrS� _has_suffixes_traverse_internals�suffixesz+:meth:`_expression.HasSuffixes.suffix_with`z.:paramref:`.HasSuffixes.suffix_with.*suffixes`r�r�r�r�r�r�r\c


r�)a%Add one or more expressions following the statement as a whole.

        This is used to support backend-specific suffix keywords on
        certain constructs.

        E.g.::

            stmt = (
                select(col1, col2)
                .cte()
                .suffix_with(
                    "cycle empno set y_cycle to 1 default 0", dialect="oracle"
                )
            )

        Multiple suffixes can be specified by multiple calls
        to :meth:`_expression.HasSuffixes.suffix_with`.

        :param \*suffixes: textual or :class:`_expression.ClauseElement`
         construct which
         will be rendered following the target clause.
        :param dialect: Optional string dialect name which will
         limit rendering of this suffix to only that dialect.

        c

r�r�r�r

r�r�r�r
�
r
z+HasSuffixes.suffix_with.<locals>.<listcomp>)r
r
)r�r�r
r�r�r��suffix_with�
s$

��zHasSuffixes.suffix_withN)r
r�r�r�r�r\)r�r�r�r
r
rTr	
r

r5rDr
r�r�r�r�r
�
r

r
c@
sreZ
dZUe��Zd
ed<dZded<dej	fdej
fgZded<edddd��
Z
e	dddd��
Zddd�ZdS)�HasHintsz/util.immutabledict[Tuple[FromClause, str], str]�_hintsr�zTuple[Tuple[str, str], ...]�_statement_hintsrS�_has_hints_traverse_internalsr��textr��dialect_namer�r\cC
s|�d
|
|�S)aAdd a statement hint to this :class:`_expression.Select` or
        other selectable object.

        .. tip::

            :meth:`_expression.Select.with_statement_hint` generally adds hints
            **at the trailing end** of a SELECT statement.  To place
            dialect-specific hints such as optimizer hints at the **front** of
            the SELECT statement after the SELECT keyword, use the
            :meth:`_expression.Select.prefix_with` method for an open-ended
            space, or for table-specific hints the
            :meth:`_expression.Select.with_hint` may be used, which places
            hints in a dialect-specific location.

        This method is similar to :meth:`_expression.Select.with_hint` except
        that it does not require an individual table, and instead applies to
        the statement as a whole.

        Hints here are specific to the backend database and may include
        directives such as isolation levels, file directives, fetch directives,
        etc.

        .. seealso::

            :meth:`_expression.Select.with_hint`

            :meth:`_expression.Select.prefix_with` - generic SELECT prefixing
            which also can suit some database-specific HINT syntaxes such as
            MySQL or Oracle Database optimizer hints

        N�
�
_with_hint)r�r
r
r�r�r��with_statement_hint�
s!zHasHints.with_statement_hintr�racC
s|�|
||�S)
a?Add an indexing or other executional context hint for the given
        selectable to this :class:`_expression.Select` or other selectable
        object.

        .. tip::

            The :meth:`_expression.Select.with_hint` method adds hints that are
            **specific to a single table** to a statement, in a location that
            is **dialect-specific**.  To add generic optimizer hints to the
            **beginning** of a statement ahead of the SELECT keyword such as
            for MySQL or Oracle Database, use the
            :meth:`_expression.Select.prefix_with` method.  To add optimizer
            hints to the **end** of a statement such as for PostgreSQL, use the
            :meth:`_expression.Select.with_statement_hint` method.

        The text of the hint is rendered in the appropriate
        location for the database backend in use, relative
        to the given :class:`_schema.Table` or :class:`_expression.Alias`
        passed as the
        ``selectable`` argument. The dialect implementation
        typically uses Python string substitution syntax
        with the token ``%(name)s`` to render the name of
        the table or alias. E.g. when using Oracle Database, the
        following::

            select(mytable).with_hint(mytable, "index(%(name)s ix_mytable)")

        Would render SQL as:

        .. sourcecode:: sql

            select /*+ index(mytable ix_mytable) */ ... from mytable

        The ``dialect_name`` option will limit the rendering of a particular
        hint to a particular backend. Such as, to add hints for both Oracle
        Database and MSSql simultaneously::

            select(mytable).with_hint(
                mytable, "index(%(name)s ix_mytable)", "oracle"
            ).with_hint(mytable, "WITH INDEX ix_mytable", "mssql")

        .. seealso::

            :meth:`_expression.Select.with_statement_hint`

            :meth:`_expression.Select.prefix_with` - generic SELECT prefixing
            which also can suit some database-specific HINT syntaxes such as
            MySQL or Oracle Database optimizer hints

        r
�r�r�r
r
r�r�r��	with_hints:zHasHints.with_hint�Optional[_FromClauseArgument]cC
sD|
dur|j||ff
7_|S|j
�t�tj|
�|f|i
�
|_
|Sr�)r
r
�unionrr�r�FromClauseRoler
r�r�r�r
Cs

�
���zHasHints._with_hintN)
r�)r
r�r
r�r�r\)r�rar
r�r
r�r�r\)r�r
r
r�r
r�r�r\)r�r�r�rX�
immutabledictr
r
r
rT�dp_statement_hint_list�dp_table_hint_listr
r5r
r
r
r�r�r�r�r
�
s

�
�
"�;r
c@
s�
eZ
dZUd
ZdZdZejdcdd��
Zde	d	<d
e	d<dZ
d
e	d<	dZdZdZ
dZdddd�Z			dedfdd�Z		dgdhdd�Z	dgdid"d#�Z		djdkd)d*�Zdld+d,�Zdmd.d/�Zejdnd1d2��
Zdod:d;�Zejdpd=d>��
Zejdpd?d@��
ZejdpdAdB��
ZdqdCdD�ZejdrdFdG��
ZejdsdIdJ��
ZejdtdLdM��
ZdqdNdO�Z ejdudQdR��
Z!e"dvdSdT��
Z#dwdUdV�Z$dxdYdZ�Z%ddd[�dyd\d]�Z&e'r�	dzd{dadb�Z(dSdS)|r�aERepresent an element that can be used within the ``FROM``
    clause of a ``SELECT`` statement.

    The most common forms of :class:`_expression.FromClause` are the
    :class:`_schema.Table` and the :func:`_expression.select` constructs.  Key
    features common to all :class:`_expression.FromClause` objects include:

    * a :attr:`.c` collection, which provides per-name access to a collection
      of :class:`_expression.ColumnElement` objects.
    * a :attr:`.primary_key` attribute, which is a collection of all those
      :class:`_expression.ColumnElement`
      objects that indicate the ``primary_key`` flag.
    * Methods to generate various derivations of a "from" clause, including
      :meth:`_expression.FromClause.alias`,
      :meth:`_expression.FromClause.join`,
      :meth:`_expression.FromClause.select`.


    r�Fr��Iterable[FromClause]c


C
�d
S�Nr�r�r�r�r�r��_hide_fromsor�zFromClause._hide_fromsr��_is_clone_ofzColumnCollection[Any, Any]�_columnsNr��schemaT�Select[Any]c

C
�t|�
S)
a#
Return a SELECT of this :class:`_expression.FromClause`.


        e.g.::

            stmt = some_table.select().where(some_table.c.id == 5)

        .. seealso::

            :func:`_expression.select` - general purpose
            method which allows for arbitrary column lists.

        �
�Selectr�r�r�r��select��zFromClause.select�rightra�onclause�)Optional[_ColumnExpressionArgument[bool]]�isouterr��full�JoincC
st||
|||�S)
aReturn a :class:`_expression.Join` from this
        :class:`_expression.FromClause`
        to another :class:`FromClause`.

        E.g.::

            from sqlalchemy import join

            j = user_table.join(
                address_table, user_table.c.id == address_table.c.user_id
            )
            stmt = select(user_table).select_from(j)

        would emit SQL along the lines of:

        .. sourcecode:: sql

            SELECT user.id, user.name FROM user
            JOIN address ON user.id = address.user_id

        :param right: the right side of the join; this is any
         :class:`_expression.FromClause` object such as a
         :class:`_schema.Table` object, and
         may also be a selectable-compatible object such as an ORM-mapped
         class.

        :param onclause: a SQL expression representing the ON clause of the
         join.  If left at ``None``, :meth:`_expression.FromClause.join`
         will attempt to
         join the two tables based on a foreign key relationship.

        :param isouter: if True, render a LEFT OUTER JOIN, instead of JOIN.

        :param full: if True, render a FULL OUTER JOIN, instead of LEFT OUTER
         JOIN.  Implies :paramref:`.FromClause.join.isouter`.

        .. seealso::

            :func:`_expression.join` - standalone function

            :class:`_expression.Join` - the type of object produced

        �
r3
)r�r.
r/
r1
r2
r�r�r��join�s3zFromClause.joincC
st||
|d
|�S)a�Return a :class:`_expression.Join` from this
        :class:`_expression.FromClause`
        to another :class:`FromClause`, with the "isouter" flag set to
        True.

        E.g.::

            from sqlalchemy import outerjoin

            j = user_table.outerjoin(
                address_table, user_table.c.id == address_table.c.user_id
            )

        The above is equivalent to::

            j = user_table.join(
                address_table, user_table.c.id == address_table.c.user_id, isouter=True
            )

        :param right: the right side of the join; this is any
         :class:`_expression.FromClause` object such as a
         :class:`_schema.Table` object, and
         may also be a selectable-compatible object such as an ORM-mapped
         class.

        :param onclause: a SQL expression representing the ON clause of the
         join.  If left at ``None``, :meth:`_expression.FromClause.join`
         will attempt to
         join the two tables based on a foreign key relationship.

        :param full: if True, render a FULL OUTER JOIN, instead of
         LEFT OUTER JOIN.

        .. seealso::

            :meth:`_expression.FromClause.join`

            :class:`_expression.Join`

        Tr4
)r�r.
r/
r2
r�r�r��	outerjoin�s/zFromClause.outerjoinr��flat�NamedFromClausecC
r�)at
Return an alias of this :class:`_expression.FromClause`.

        E.g.::

            a2 = some_table.alias("a2")

        The above code creates an :class:`_expression.Alias`
        object which can be used
        as a FROM clause in any SELECT statement.

        .. seealso::

            :ref:`tutorial_using_aliases`

            :func:`_expression.alias`

        r�)r�r��r�r�r7
r�r�r�r��szFromClause.alias�sampling�Union[float, Function[Any]]�seed�*Optional[roles.ExpressionElementRole[Any]]�TableSamplecC
�tj
||
||d
�S)aW
Return a TABLESAMPLE alias of this :class:`_expression.FromClause`.

        The return value is the :class:`_expression.TableSample`
        construct also
        provided by the top-level :func:`_expression.tablesample` function.

        .. seealso::

            :func:`_expression.tablesample` - usage guidelines and parameters

        )r:
r�r<
)r>
r�)r�r:
r�r<
r�r�r��tablesamples
�zFromClause.tablesamplecC
s
|
|jvS)
z�Return ``True`` if this :class:`_expression.FromClause` is
        'derived' from the given ``FromClause``.

        An example would be an Alias of a Table is derived from that Table.

        )
�_cloned_setr�r�r�r�r�(s

zFromClause.is_derived_from�othercC
st|j
�|
j
�
�
S)
z�Return ``True`` if this :class:`_expression.FromClause` and
        the other represent the same lexical identity.

        This tests if either one is a copy of the other, or
        if they are the same via annotation identity.

        )r�rA
�intersection�r�rB
r�r�r��_is_lexical_equivalent4sz!FromClause._is_lexical_equivalentr�c

C
st|d
|j
jd�S)z|A brief description of this :class:`_expression.FromClause`.

        Used primarily for error message formatting.

        r�z object)�getattr�	__class__r�r�r�r�r��description>szFromClause.descriptionr�r�r�r<r�r�r�c
s"|���
�fd
d�|j
D�
�

dS)Nc
3
� �|]}
|
j�
��d�V
qd
S��r�r�N�
�_make_proxy�r
�col�r�r�r�r�r��	<genexpr>Ns��
�
�zAFromClause._generate_fromclause_column_proxies.<locals>.<genexpr>)�_populate_separate_keys�
cr�r�rP
r�r�Gs�z.FromClause._generate_fromclause_column_proxies�6ReadOnlyColumnCollection[str, KeyedColumnElement[Any]]c


C
r�)
a�
A :class:`_expression.ColumnCollection`
        that represents the "exported"
        columns of this :class:`_expression.Selectable`.

        The "exported" columns for a :class:`_expression.FromClause`
        object are synonymous
        with the :attr:`_expression.FromClause.columns` collection.

        .. versionadded:: 1.4

        .. seealso::

            :attr:`_expression.Selectable.exported_columns`

            :attr:`_expression.SelectBase.exported_columns`


        �
rS
r�r�r�r�r�UszFromClause.exported_columnsc


C
r�)
a�
A named-based collection of :class:`_expression.ColumnElement`
        objects maintained by this :class:`_expression.FromClause`.

        The :attr:`.columns`, or :attr:`.c` collection, is the gateway
        to the construction of SQL expressions using table-bound or
        other selectable-bound columns::

            select(mytable).where(mytable.c.somecolumn == 5)

        :return: a :class:`.ColumnCollection` object.

        rU
r�r�r�r�r�mszFromClause.columnsc

C
sd
|jv
r	|�
�
|j��S)zk
        A synonym for :attr:`.FromClause.columns`

        :return: a :class:`.ColumnCollection`

        r&
)�__dict__�_setup_collectionsr&
�as_readonlyr�r�r�r�rS
s



zFromClause.cc
C
sbd
|jv
sJ�
d|jv
sJ�
d|jv
sJ�
t
�}
t�}t�}|j|
||d�
|
|_||_||_dS)Nr&
r�r�)r�r�r�)rV
r;r<�set�_populate_column_collectionr&
r�r�)r�r&
r�r�r�r�r�rW
�s







�


zFromClause._setup_collectionsr1c


C
r�)
a�
Return a namespace used for name-based access in SQL expressions.

        This is the namespace that is used to resolve "filter_by()" type
        expressions, such as::

            stmt.filter_by(address="some address")

        It defaults to the ``.c`` collection, however internally it can
        be overridden using the "entity_namespace" annotation to deliver
        alternative results.

        rU
r�r�r�r�r��szFromClause.entity_namespace�Iterable[NamedColumn[Any]]c

C
�|��
|j
S)
ap
Return the iterable collection of :class:`_schema.Column` objects
        which comprise the primary key of this :class:`_selectable.FromClause`.

        For a :class:`_schema.Table` object, this collection is represented
        by the :class:`_schema.PrimaryKeyConstraint` which itself is an
        iterable collection of :class:`_schema.Column` objects.

        )rW
r�r�r�r�r�r��s

zFromClause.primary_key�Iterable[ForeignKey]c

C
r\
)
aV
Return the collection of :class:`_schema.ForeignKey` marker objects
        which this FromClause references.

        Each :class:`_schema.ForeignKey` is a member of a
        :class:`_schema.Table`-wide
        :class:`_schema.ForeignKeyConstraint`.

        .. seealso::

            :attr:`_schema.Table.foreign_key_constraints`

        )rW
r�r�r�r�r�r��s
zFromClause.foreign_keysc
C
sd
D]	}
|j�
|
d�
qdS)aReset the attributes linked to the ``FromClause.c`` attribute.

        This collection is separate from all the other memoized things
        as it has shown to be sensitive to being cleared out in situations
        where enclosing code, typically in a replacement traversal scenario,
        has already established strong relationships
        with the exported columns.

        The collection is cleared for the case where a table is having a
        column added to it as well as within a Join during copy internals.

        )r&
r�rS
r�r�N)rV
�pop)r��keyr�r�r��_reset_column_collection�s
�z#FromClause._reset_column_collectionr�c

C
�d
d�|jD�
S)Nc
s
s�|]	}
t|
�
s|
V
qdSr�r6�r
rS
r�r�r�rQ
�s�z.FromClause._select_iterable.<locals>.<genexpr>rU
r�r�r�r��_select_iterable��zFromClause._select_iterablec

C
s
d
|jvS)Nr&
)
rV
r�r�r�r��_cols_populated�s
zFromClause._cols_populatedc
C
r"
)z�Called on subclasses to establish the .c collection.

        Each implementation has a different way of establishing
        this collection.

        Nr��r�r�r�r�r�r�r�rZ
��z&FromClause._populate_column_collectionr�r�cC
s|��
d
S)aNGiven a column added to the .c collection of an underlying
        selectable, produce the local version of that column, assuming this
        selectable ultimately should proxy this column.

        this is used to "ping" a derived selectable to add a new column
        to its .c. collection when a Column has been added to one of the
        Table objects it ultimately derives from.

        If the given selectable hasn't populated its .c. collection yet,
        it should at least pass on the message to the contained selectables,
        but it will return None.

        This method is currently used by Declarative to allow Table
        columns to be added to a partially constructed inheritance
        mapping that may have already produced joins.  The method
        isn't public right now, as the full span of implications
        and/or caveats aren't yet clear.

        It's also possible that this functionality could be invoked by
        default via an event, which would require that
        selectables maintain a weak referencing collection of all
        derivations.

        N)
r`
r�r�r�r�r��sz"FromClause._refresh_for_new_column�r�r7
c
C
�|j|
d
�
S�Nr�)
r�r9
r�r�r��_anonymous_fromclausesz FromClause._anonymous_fromclause�against�Optional[OperatorType]�Union[FromGrouping, Self]c
C
r�r�r��r�rl
r�r�r��
self_groupr�zFromClause.self_group�r�r!
�r�r(
�NFF)
r.
rar/
r0
r1
r�r2
r�r�r3
�NF)r.
rar/
r0
r2
r�r�r3
)r�r�r7
r�r�r8
�NN)r:
r;
r�r�r<
r=
r�r>
r�)rB
r�r�r��r�r�r��r�rT
)r�r�r��r�r[
�r�r]
r��r�r��r�r�r�r<r�r�r�r�r�)r�r�r7
r�r�r�r�)rl
rm
r�rn
))r�r�r�r�r��named_with_columnrXr�r$
r
r'
r�r��_is_join�_use_schema_mapr,
r5
r6
r�r@
r�rE
rH
r�r�r��ro_memoized_propertyrS
rW
r�r�r�r`
rc
r�re
rZ
r�rk
rrp
r�r�r�r�r�Wst









�8
�2�
�

















���c@
s2eZ
dZUd
ZdZded<e�d�
ddd	��
Zd
S)r8
z�A :class:`.FromClause` that has a name.

    Examples include tables, subqueries, CTEs, aliased tables.

    .. versionadded:: 2.0

    Tr�r�zsqlalchemy.sql.sqltypesr��TableValuedColumn[Any]c

C
st|t
j�S)
ayReturn a :class:`_sql.TableValuedColumn` object for this
        :class:`_expression.FromClause`.

        A :class:`_sql.TableValuedColumn` is a :class:`_sql.ColumnElement` that
        represents a complete row in a table. Support for this construct is
        backend dependent, and is supported in various forms by backends
        such as PostgreSQL, Oracle Database and SQL Server.

        E.g.:

        .. sourcecode:: pycon+sql

            >>> from sqlalchemy import select, column, func, table
            >>> a = table("a", column("id"), column("x"), column("y"))
            >>> stmt = select(func.row_to_json(a.table_valued()))
            >>> print(stmt)
            {printsql}SELECT row_to_json(a) AS row_to_json_1
            FROM a

        .. versionadded:: 1.4.0b2

        .. seealso::

            :ref:`tutorial_functions` - in the :ref:`unified_tutorial`

        )rOr�
TABLEVALUEr�r�r�r��table_valued(szNamedFromClause.table_valuedN�r�r�
)	r�r�r�r�r|
r
rXr�r�
r�r�r�r�r8
s


r8
c
@
s,eZ
dZd
ZdZ	dZ	dZ	eZ	dZdS)�SelectLabelStylezTLabel style constants that may be passed to
    :meth:`_sql.Select.set_label_style`.r
rrV�N)	r�r�r�r��LABEL_STYLE_NONE�LABEL_STYLE_TABLENAME_PLUS_COL�LABEL_STYLE_DISAMBIGUATE_ONLY�LABEL_STYLE_DEFAULT�LABEL_STYLE_LEGACY_ORMr�r�r�r�r�
Gs


'
#
r�
c
s�
eZ
dZUd
ZdZdejfdejfdejfdejfdejfgZde	d	<d
Z
de	d<de	d<de	d<d
e	d<d
e	d<			dZd[dd�Zej
d\dd��
Zd]dd�Z	d^d_dd �Ze�d!�
d`d)d*��
Zef
da�f
d/d0�
Zdb�f
d3d4�Zdcd6d7�Zeddd8�ddd>d?��
Zedd@�
dedAdB��
Zee�d!�
dfdDdE��
�
ZedgdIdJ��
ZdhdLdM�Ze�d!�
	didjdRdS��
Zej
dkdUdV��
Zej
dldXdY��
Z�Z S)mr3
a�
Represent a ``JOIN`` construct between two
    :class:`_expression.FromClause`
    elements.

    The public constructor function for :class:`_expression.Join`
    is the module-level
    :func:`_expression.join()` function, as well as the
    :meth:`_expression.FromClause.join` method
    of any :class:`_expression.FromClause` (e.g. such as
    :class:`_schema.Table`).

    .. seealso::

        :func:`_expression.join`

        :meth:`_expression.FromClause.join`

    r5
�leftr.
r/
r1
r2
rS�_traverse_internalsTr�zOptional[ColumnElement[bool]]r�NFra�Optional[_OnClauseArgument]cC
sjt�
tj|
�|_t�
tj|���|_|d
ur |�|j|j�|_n
t�
tj	|�jt
jd�
|_||_||_
d
S)z�Construct a new :class:`_expression.Join`.

        The usual entrypoint here is the :func:`_expression.join`
        function or the :meth:`_expression.FromClause.join` method of any
        :class:`_expression.FromClause` object.

        N�
rl
)rr�rr
r�
rp
r.
�_match_primariesr/
�OnClauseRoler�_asboolr1
r2
)r�r�
r.
r/
r1
r2
r�r�r��__init__�s&

�

��

��

z
Join.__init__r�r�c

C
s$d
|jj
t|j�
|jj
t|j�
fS)Nz Join object on %s(%d) and %s(%d))r�
rH
�idr.
r�r�r�r�rH
s



�zJoin.descriptionr�r�cC
s(t|
�
t|�
kp|j
�|
�
p|j�|
�
Sr�)�hashr�
r�r.
r�r�r�r�r�$s


�
�zJoin.is_derived_fromrl
rm
�FromGroupingcC
r)
r�)
r�
ro
r�r�r�rp
-�zJoin.self_groupr�r�r�r�r<r�r�r�cC
s|tj
j}d
d�|jjD�
d
d�|jjD�
}|�|�dd�|D�
|j��

|
�	dd�|D�
�

|�
tjdd�|D�
��

dS)Nc
S
�g|]}
|
�qSr�r�rb
r�r�r�r
:�z4Join._populate_column_collection.<locals>.<listcomp>c
s
s�|]}
|
jr|
V
qdSr�)
r�rb
r�r�r�rQ
@s�z3Join._populate_column_collection.<locals>.<genexpr>c
s
��|]}
|
j|
fV
qdSr�)
�
_tq_key_labelrN
r�r�r�rQ
C��


�c
S
�g|]}
|
j�qSr�)
r�rN
r�r�r�r
G�)
rXr�r�r�
rS
r.
�extend�reduce_columnsr/
rR
�update�	itertools�chain)r�r�r�r��sqlutilr&
r�r�r�rZ
2s

�

��

�
�z Join._populate_column_collection�cloner��kwrc
shtt
�t|j�
t|j�
��
}��
fd
d�|D�
�d
�f
d	d
�}|�
d<t�jdd�i
�
�
�

|��
dS)Nc

�i|]}
|
�|
f
i�
�
�
�qSr�r��r
�
f�r�
r�
r�r��
<dictcomp>Z�z(Join._copy_internals.<locals>.<dictcomp>�obj�/Union[BinaryExpression[Any], ColumnClause[Any]]r�
rr�r�c

�,t|t
�r|j�vr�|j�|�
}|SdSr���
isinstancerJ�tabler��r�
r�
�newelem�
�	new_fromsr�r��replace_�


z%Join._copy_internals.<locals>.replacer�
r�
�r�
r�
r�
rr�r�r�)	rY
r�
r�
r4r�
r.
�super�_copy_internals�_reset_memoizations)r�r�
r�
�
all_the_fromsr�
�
rG
�r�
r�
r�
r�r�
Js


��		zJoin._copy_internalsr�r�c
s(t��
|
�

|j�
|
�

|j�
|
�

dSr�)r�
r�r�
r.
r�r�
r�r�r�qs


zJoin._refresh_for_new_columnr�cC
s&t|
t
�r	|
j}nd}|j|
||d
�S)N)
�a_subset)r�
r3
r.
�_join_condition)r�r�
r.
�
left_rightr�r�r�r�
vs


zJoin._match_primaries)r�
�consider_as_foreign_keys�
a�
br�
r�
�(Optional[AbstractSet[ColumnClause[Any]]]cC
s�|�|
|||�}t
|�
d
kr|�|
|||�
t
|�
dkr2t|t�r$d}nd}t�d|
j|j|f�
�
dd�t|�	��
dD�
}t
|�
d
krI|dSt
|�S)z�Create a join condition between two tables or selectables.

        See sqlalchemy.sql.util.join_condition() for full docs.

        rr
zI Perhaps you meant to convert the right side to a subquery using alias()?�zACan't find any foreign key relationships between '%s' and '%s'.%sc
S
sg|]\}
}|
|k�qSr�r�)r
�
x�
yr�r�r�r
��z(Join._join_condition.<locals>.<listcomp>)�_joincond_scan_left_right�len�_joincond_trim_constraintsr�
r�
rW�NoForeignKeysErrorrH
�list�values�and_)�clsr�
r�
r�
r�
�constraints�hint�critr�r�r�r�
�s*
�

�

�

��

zJoin._join_condition)
r�
c
C
s0t|
t
�r	|
j}nd}|j|
|||d
�}t|�
S)N)r�
r�
r�
r�
)r�
r3
r.
r�
r�)r�
r�
r.
r�
r�
r�
r�r�r��	_can_join�s






�zJoin._can_join�jcollections.defaultdict[Optional[ForeignKeyConstraint], List[Tuple[ColumnClause[Any], ColumnClause[Any]]]]cC
s�
tj
j}t�tj|
�}
t�tj|�}t�t	�
}||
fD]�}|dur"qt
|jd
d�d�D]F}|du
r7|j|v
r7q+z|�
|�
}	Wn#tjya
}

zdd�|�|�
D�
}|
j|vrW�WYd}
~
q+d}
~
w
w|	du
rq||j�|	|jf�

q+||u
r�t
|jdd�d�D]F}|du
r�|j|v
r�qz|�
|�
}	Wn#tjy�
}

zdd�|�|�
D�
}|
j|vr��WYd}
~
qd}
~
w
w|	du
r�||j�|	|jf�

q|r�
|Sq|S)Nc


S
�|jj
Sr���parent�_creation_order�
�fkr�r�r��<lambda>��z0Join._joincond_scan_left_right.<locals>.<lambda>�
r_
c
S
�h|]}
|
j�qSr�r��r
�
tr�r�r��	<setcomp>�r�
z1Join._joincond_scan_left_right.<locals>.<setcomp>c


S
r�
r�r�
r�
r�r�r�r�
�r�
c
S
r�
r�r�r�
r�r�r�r�
r�
)rXr�r�rr�rr
�collections�defaultdictr�
�sortedr�r�
�get_referentrW�NoReferenceError�find_tables�
table_name�
constraint�append)r�
r�
r�
r�
r�
r�r�
r�
r�
rO
�nrte�table_namesr�r�r�r�
�sh
�





�








��
�




�








��
�


�zJoin._joincond_scan_left_rightr�
�Dict[Any, Any]�
Optional[Any]cC
s�|rt|�
D]}d
d�|j
D�
t|�
kr||=qt|�
dkr9dd�|��D�
}t|�
dkr9t|�
d}|||i
}t|�
dkrJt�d|
j|jf�
�
dS)Nc
S
r�
r�)
r�
r�
r�r�r�r�
r�
z2Join._joincond_trim_constraints.<locals>.<setcomp>rc
S
sh|]}
t|
�
�qSr�)
r
)r
r�
r�r�r�r�
!�r
z�Can't determine join between '%s' and '%s'; tables have more than one foreign key constraint relationship between them. Please specify the 'onclause' of this join explicitly.)r�
�elementsrY
r�
r�
rW�AmbiguousForeignKeysErrorrH
)r�
r�
r�
r�
r�
�const�deduper_
r�r�r�r�
s&


��






���zJoin._joincond_trim_constraintsr(
c

C
st|j
|j��|�
S)
a�
Create a :class:`_expression.Select` from this
        :class:`_expression.Join`.

        E.g.::

            stmt = table_a.join(table_b, table_a.c.id == table_b.c.a_id)

            stmt = stmt.select()

        The above will produce a SQL string resembling:

        .. sourcecode:: sql

            SELECT table_a.id, table_a.col, table_b.id, table_b.a_id
            FROM table_a JOIN table_b ON table_a.id = table_b.a_id

        )r+
r�
r.
�select_fromr�r�r�r�r,
/szJoin.selectr�r�r7
�TODO_Anyc	C
s�tj
j}|rot|jttf�r|
}n|
r#t|jt�r#|
�d
|jj��}n|
}t|j	ttf�r0|
}n|
rBt|j	t�rB|
�d
|j	j��}n|
}|jj
||d�|j	j
||d�}}|�|�
�|�|�
�
}|j
||�|j�
|j|jd�S|���t�
�d�
�|
�
S)N�
_rh
�r1
r2
)rXr�r�r�
r�
r�
r3
r8
r�r.
rk
r�r�
r5
r�r/
r1
r2
r,
�set_label_styler�
�	correlater�)	r�r�r7
r�
�	left_name�
right_name�left_a�right_a�adapterr�r�r�rk
Cs:







�

�




�


�zJoin._anonymous_fromclauser!
c

C
stj
d
d�|jD�
�S)Nc
S
sg|]	}
t|
j
|
j��qSr�)r4r�
r.
)r
r�
r�r�r�r
p�z$Join._hide_froms.<locals>.<listcomp>)r�
r�
rA
r�r�r�r�r$
ms
�zJoin._hide_fromsr�c
C
s|g
}
|
|jj
|jj
Sr�)r�
r4r.
)r��	self_listr�r�r�r4ss
zJoin._from_objectsrs
)
r�
rar.
rar/
r�
r1
r�r2
r�rv
r�r�)rl
rm
r�r�
r{
�r�
r�r�
rr�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�rr
rt
)r�r�r7
r�r�r�
rq
r�)!r�r�r�r�r�rT�dp_clauseelement�
dp_booleanr�
r
r}
r�
rXr�rH
r�rp
r�rZ
r+r�
r�r�
�classmethodr�
r�
r�
r�
r,
rk
r$
r4�
__classcell__r�r�r�
r�r3
�sd





�





�.


�
�'
�,�

D

"�)

r3
c@
seZ
dZddd�ZdS)�NoInit�argrr�
c
O
s&td
|j
j|j
j��|j
j��f�
�
)Nz�The %s class is not intended to be constructed directly.  Please use the %s() standalone function or the %s() method available from appropriate selectable objects.)r�rG
r��lower�r�r	r�
r�r�r�r�
zs





���zNoInit.__init__N)r	rr�
r)r�r�r�r�
r�r�r�r�rys
rc
@
r�)r�z>mark a FROM clause as being able to render directly as LATERALNr�r�r�r�r�r��r�r�c
s�eZ
dZUd
ZdZdZded<dejfdej	fgZ
ded<ed	d
�
d5dd��
Zd	d
�
d6dd�Z
d7�f
dd�Zd8d d!�Zejd9d#d$��
Zejd:d&d'��
Zed;d(d)��
Zd<d,d-�Zef
d=�f
d0d1�
Zed>d3d4��
Z�ZS)?�AliasedReturnsRowszLBase class of aliases against tables, subqueries, and other
    selectables.TFr��elementr�rSr�
Nr�r�rr�r�
r�r\c
K
s$|�|�
}|j
|
f
d
|i
|�
�

|S)Nr�)�__new__�_init)r�
r�r�r�
r�
r�r�r�r��s


zAliasedReturnsRows._constructr�c
C
sptj
tj|
|d
�|_|
|_||_|dur3t|
t�r)|
jr)t	|
dd�}t|t
�r)d}t
�t|�
|p1d�}||_
dS)N�
�apply_propagate_attrsr��anon)rr�r�ReturnsRowsRoler
�
_orig_namer�
r�r|
rF
rE�safe_constructr�
r�)r�r�r�r�r�r�r�s

�

��





zAliasedReturnsRows._initr�r�c
st��
|
�

|j�
|
�

dSr�)r�
r�r
r�r�
r�r�r��s

z*AliasedReturnsRows._refresh_for_new_columnr�r�r�r<r�r�cC
s|jj
||
||d
�
dS�NrK
�r
r�rf
r�r�r�rZ
�s

�z.AliasedReturnsRows._populate_column_collectionr�c
C
s|j}
t
|
t�r
d
}
|
S)N�anon_1)r�r�
rEr�r�r�r�rH
�s


zAliasedReturnsRows.descriptionr�c


C
r�
r�)r
�implicit_returningr�r�r�r�r��z%AliasedReturnsRows.implicit_returningc


C
r�)
z9Legacy for dialects that are referring to Alias.original.�
r
r�r�r�r��original�szAliasedReturnsRows.originalr�r�cC
s|
|jvrd
S|j
�|
�
S�NT)rA
r
r�r�r�r�r�r��s



z"AliasedReturnsRows.is_derived_fromr�
r�c
s6|j}t
�jdd
|
i
|�
�

||ju
r|��
dSdS)Nr�
r�)r
r�
r�
r`
)r�r�
r�
�existing_elementr�
r�r�r�
�s


�z"AliasedReturnsRows._copy_internalsr�c


C
�|g
Sr�r�r�r�r�r�r4�r�z AliasedReturnsRows._from_objects)r�rr�r�r�
rr�r\)r�rr�r�r�r�r�r{
rv
rz
r�r�rr�)r�r�r�r��_is_from_container�_supports_derived_columnsr
rTr�dp_anon_namer�
rr�rr�rZ
rXr�rH
rr�rr�r+r�
r4rr�r�r�
r�r�s2


��





�
rc@
�eZ
dZUd
ed<dS)�FromClauseAliasr�r
N�r�r�r�r
r�r�r�r�r$��

r$c@
s6eZ
dZUd
ZdZdZded<e		dddd��
ZdS)r�aRepresents an table or selectable alias (AS).

    Represents an alias, as typically applied to any table or
    sub-select within a SQL statement using the ``AS`` keyword (or
    without the keyword on certain databases such as Oracle Database).

    This object is constructed from the :func:`_expression.alias` module
    level function as well as the :meth:`_expression.FromClause.alias`
    method available
    on all :class:`_expression.FromClause` subclasses.

    .. seealso::

        :meth:`_expression.FromClause.alias`

    r�Tr�r
NFr�r�r�r7
r�r�r8
cC
stj
tj|
d
d�j||d�S)NT)
�allow_selectrh
)rr�rr
r�)r�
r�r�r7
r�r�r��_factorys

��zAlias._factoryrt
)r�r�r�r�r7
r�r�r8
)	r�r�r�r�r�r�r
rr(r�r�r�r�r��s


�r�c
s�eZ
dZUd
ZdZdZdZdZdZde	j
fde	jfde	jfde	j
fd	e	j
fgZd
ed<dddd
�d%�f
dd�Zejd&dd��
Z	d'd(dd�Zd)d*d d!�Z		d'd+d#d$�Z�ZS),�TableValuedAliasaAn alias against a "table valued" SQL function.

    This construct provides for a SQL function that returns columns
    to be used in the FROM clause of a SELECT statement.   The
    object is generated using the :meth:`_functions.FunctionElement.table_valued`
    method, e.g.:

    .. sourcecode:: pycon+sql

        >>> from sqlalchemy import select, func
        >>> fn = func.json_array_elements_text('["one", "two", "three"]').table_valued(
        ...     "value"
        ... )
        >>> print(select(fn.c.value))
        {printsql}SELECT anon_1.value
        FROM json_array_elements_text(:json_array_elements_text_1) AS anon_1

    .. versionadded:: 1.4.0b2

    .. seealso::

        :ref:`tutorial_functions_table_valued` - in the :ref:`unified_tutorial`

    �table_valued_aliasTFr
r��_tableval_type�_render_derived�_render_derived_w_typesrSr�
N�r��table_value_type�joins_implicitlyr�rr�r/�Optional[TableValueType]r0r�r�r�c
s4t�j
|
|d
�
||_|durtj|_dS||_dSrj
)r�
rr0rr�
r+)r�r�r�r/r0r�
r�r�rJs���zTableValuedAlias._initr�
c

C
st||j
�S)
aReturn a column expression representing this
        :class:`_sql.TableValuedAlias`.

        This accessor is used to implement the
        :meth:`_functions.FunctionElement.column_valued` method. See that
        method for further details.

        E.g.:

        .. sourcecode:: pycon+sql

            >>> print(select(func.some_func().table_valued("value").column))
            {printsql}SELECT anon_1 FROM some_func() AS anon_1

        .. seealso::

            :meth:`_functions.FunctionElement.column_valued`

        )rOr+r�r�r�r�r�[�zTableValuedAlias.columnr7
cC
s.tj
||
|j|jd
�}|jrd|_|j|_|S)z�Return a new alias of this :class:`_sql.TableValuedAlias`.

        This creates a distinct FROM object that will be distinguished
        from the original one when used in a SQL statement.

        r.T)r)r�r+r0r,r-)r�r�r7
�tvar�r�r�r�ss




�

zTableValuedAlias.aliasr�cC
s|j|
d
�
}d|_
|S)z�Return a new :class:`_sql.TableValuedAlias` with the lateral flag
        set, so that it renders as LATERAL.

        .. seealso::

            :func:`_expression.lateral`

        r�T)r�r�)r�r�r3r�r�r�r��s	

zTableValuedAlias.lateral�
with_typescC
s(tj
|j|
|j|jd
�}d|_||_|S)a�Apply "render derived" to this :class:`_sql.TableValuedAlias`.

        This has the effect of the individual column names listed out
        after the alias name in the "AS" sequence, e.g.:

        .. sourcecode:: pycon+sql

            >>> print(
            ...     select(
            ...         func.unnest(array(["one", "two", "three"]))
            ...         .table_valued("x", with_ordinality="o")
            ...         .render_derived()
            ...     )
            ... )
            {printsql}SELECT anon_1.x, anon_1.o
            FROM unnest(ARRAY[%(param_1)s, %(param_2)s, %(param_3)s]) WITH ORDINALITY AS anon_1(x, o)

        The ``with_types`` keyword will render column types inline within
        the alias expression (this syntax currently applies to the
        PostgreSQL database):

        .. sourcecode:: pycon+sql

            >>> print(
            ...     select(
            ...         func.json_to_recordset('[{"a":1,"b":"foo"},{"a":"2","c":"bar"}]')
            ...         .table_valued(column("a", Integer), column("b", String))
            ...         .render_derived(with_types=True)
            ...     )
            ... )
            {printsql}SELECT anon_1.a, anon_1.b FROM json_to_recordset(:json_to_recordset_1)
            AS anon_1(a INTEGER, b VARCHAR)

        :param name: optional string name that will be applied to the alias
         generated.  If left as None, a unique anonymizing name will be used.

        :param with_types: if True, the derived columns will include the
         datatype specification with each column. This is a special syntax
         currently known to be required by PostgreSQL for some SQL functions.

        r.T)r)r�r
r+r0r,r-)r�r�r4�	new_aliasr�r�r��render_derived�s7



�

zTableValuedAlias.render_derived)
r�rr�r�r/r1r0r�r�r�r�
rt
)r�r�r7
r�r�r)r�r�)r�r�r4r�r�r))r�r�r�r�r�r!r,r-r0rTrr"�dp_typerr�
r
rrB�memoized_attributer�r�r�r6rr�r�r�
r�r)!s2








�

�
�
�r)c@
s.eZ
dZd
ZdZdZdZe	d
ddd��
ZdS)r�a�
Represent a LATERAL subquery.

    This object is constructed from the :func:`_expression.lateral` module
    level function as well as the :meth:`_expression.FromClause.lateral`
    method available
    on all :class:`_expression.FromClause` subclasses.

    While LATERAL is part of the SQL standard, currently only more recent
    PostgreSQL versions provide support for this keyword.

    .. seealso::

        :ref:`tutorial_lateral_correlation` -  overview of usage.

    r�TNr��&Union[SelectBase, _FromClauseArgument]r�r�r�r�cC
stj
tj|
d
d�j|d�
S)NT)
�explicit_subqueryr�)rr�rr
r��r�
r�r�r�r�r�r(�s

��zLateral._factoryr�)r�r9r�r�r�r�)	r�r�r�r�r�r�r�rr(r�r�r�r�r��s

�r�c
szeZ
dZUd
ZdZejdejfdejfgZde	d<e
		dddd��
Ze�
d�
ddd�d�f
dd��
Zddd�Z�ZS)r>
aI
Represent a TABLESAMPLE clause.

    This object is constructed from the :func:`_expression.tablesample` module
    level function as well as the :meth:`_expression.FromClause.tablesample`
    method
    available on all :class:`_expression.FromClause` subclasses.

    .. seealso::

        :func:`_expression.tablesample`

    r@
r:
r<
rSr�
Nr�rar;
r�r�r=
r�cC
st�
tj|
�j|||d
�S)N�r�r<
)rr�rr
r@
)r�
r�r:
r�r<
r�r�r�r(s
�zTableSample._factoryzsqlalchemy.sql.functionsr<rr�c
sL|du
sJ�
tj
j}t||j�s|j�|�
}||_||_t	�j
|
|d
�
dSrj
)rXr��
sql_functionsr�
r�func�systemr:
r<
r�
r)r�r�r�r:
r<
�	functionsr�
r�r�rs	




zTableSample._init�
Function[Any]c


C
r�r�)
r:
r�r�r�r��_get_method0r�zTableSample._get_methodru
)
r�rar:
r;
r�r�r<
r=
r�r>
)
r�rr�r�r:
r;
r<
r=
r�r�)r�rA)r�r�r�r�r�rr�
rTrr
rr(rXr�rrBrr�r�r�
r�r>
�s$



��
�
��r>
c
s�eZ
dZUd
ZdZejdejfdejfdej	fdej	fge
jej
Zded<d	ed
<e		d0d1dd��
Zdddddddd�d2�f
dd�Zd3d#d$�Zd0d4d&d'�Zd5d*d+�Zd5d,d-�Zd6d.d/�Z�ZS)7�CTEaURepresent a Common Table Expression.

    The :class:`_expression.CTE` object is obtained using the
    :meth:`_sql.SelectBase.cte` method from any SELECT statement. A less often
    available syntax also allows use of the :meth:`_sql.HasCTE.cte` method
    present on :term:`DML` constructs such as :class:`_sql.Insert`,
    :class:`_sql.Update` and
    :class:`_sql.Delete`.   See the :meth:`_sql.HasCTE.cte` method for
    usage details on CTEs.

    .. seealso::

        :ref:`tutorial_subqueries_ctes` - in the 2.0 tutorial

        :meth:`_sql.HasCTE.cte` - examples of calling styles

    �cte�
_cte_alias�	_restates�	recursive�nestingrSr�
�HasCTEr
NFr�r�r�r�r�cC
st�
tj|
�j||d
�S)z�Return a new :class:`_expression.CTE`,
        or Common Table Expression instance.

        Please see :meth:`_expression.HasCTE.cte` for detail on CTE usage.

        )r�rG)rr�r�
HasCTERolerD)r�
r�r�rGr�r�r�r(^s

�zCTE._factory)r�rGrHrErFr�r
r(
�
Optional[CTE]r��Optional[Tuple[()]]r
r�c	
s@||_||_
||_||_|r||_|r||_t�j|
|d
�
dSrj
)rGrHrErFr�r
r�
r)	r�r�r�rGrHrErFr�r
r�
r�r�ros






z	CTE._initr�r�r�r<r�r�cC
s:|jdu
r|jj
||
||d
�
dS|jj
||
||d
�
dSr)rEr�r
rf
r�r�r�rZ
�s






�




�zCTE._populate_column_collectionr7
c	C
s"tj
|j|
|j|j||j|jd
�S)a2
Return an :class:`_expression.Alias` of this
        :class:`_expression.CTE`.

        This method is a CTE-specific specialization of the
        :meth:`_expression.FromClause.alias` method.

        .. seealso::

            :ref:`tutorial_using_aliases`

            :func:`_expression.alias`

        )r�rGrHrEr�r
)rCr�r
rGrHr�r
r9
r�r�r�r��s






�z	CTE.aliasrB
rgc
	G
�Ft|j
�
sJd
|j
�d��
�
tj|j
j|
�|j|j|j||j|j	d�S)a�
Return a new :class:`_expression.CTE` with a SQL ``UNION``
        of the original CTE against the given selectables provided
        as positional arguments.

        :param \*other: one or more elements with which to create a
         UNION.

         .. versionchanged:: 1.4.28 multiple elements are now accepted.

        .. seealso::

            :meth:`_sql.HasCTE.cte` - examples of calling styles

        �
CTE element fz does not support union()�r�rGrHrFr�r
)
r%r
rCr�r
r�rGrHr�r
rD
r�r�r�r
�s
��







�z	CTE.unionc
	G
rM)a�
Return a new :class:`_expression.CTE` with a SQL ``UNION ALL``
        of the original CTE against the given selectables provided
        as positional arguments.

        :param \*other: one or more elements with which to create a
         UNION.

         .. versionchanged:: 1.4.28 multiple elements are now accepted.

        .. seealso::

            :meth:`_sql.HasCTE.cte` - examples of calling styles

        rNz does not support union_all()rO)
r%r
rCr��	union_allr�rGrHr�r
rD
r�r�r�rP�s
��







�z
CTE.union_allc

C
s|jd
u
r|jS|S)z�
        A recursive CTE is updated to attach the recursive part.
        Updated CTEs should still refer to the original CTE.
        This function returns this reference identifier.
        N)
rFr�r�r�r��_get_reference_cte�szCTE._get_reference_ctert
)r�rIr�r�rGr�r�rC)r�r(
r�r�rGr�rHr�rErKrFrKr�rLr
rLr�r�r{
)r�r�r7
r�r�rC)rB
rgr�rC)r�rC)r�r�r�r�r�rr�
rTrrr�r�r
r

r
rr(rrZ
r�r
rPrQrr�r�r�
r�rC4sB



����
�
�





�


rCc@
r#)�_CTEOptsr�rHNr%r�r�r�r�rR�r&rRc@
s>eZ
dZUd
ed<	d
ed<	d
ed<	ded<	ded<d	S)
�_ColumnsPlusNamesr��required_label_name�	proxy_key�fallback_label_name�%Union[ColumnElement[Any], TextClause]r�r��repeatedNr%r�r�r�r�rS�s






rSc@
s,eZ
dZUd
ZeZded<	d
ddd�ZdS)�SelectsRowszvSub-base of ReturnsRows for elements that deliver rows
    directly, namely SELECT and INSERT/UPDATE/DELETE..RETURNINGr�
�_label_styleN�anon_for_dupe_keyr��cols�Optional[_SelectIterable]r��List[_ColumnsPlusNames]cC
sR|d
ur|j}t
�|j�
}i}g}|j}|jtu}|jtu}d}	|D�
]}
d}|
js1d
}}
}ni|rFtr;t	|
�
s;J�
d
}}
|
j
pD|
j}nTtrNt	|
�
sNJ�
|rX|
j}
}}n|
j
}}d
}
|d
ur�|
j
}|d
ur�|
j|v}|
||
j<d
}}
|r�|r�|
�|	�
}|	d7}	n|
�|	�
}|	d7}	n
|
j}n|}
}}|d
u
�
rtr�t	|
�
s�J�
||v�
rt||�
t|
�
kr�|r�|
j}
}n|
j}
}|
r�|
|vr�t||
�
t|
�
ks�J�
|r�|
�|	�
}
}|	d7}	n|
�|	�
}
}|	d7}	d}n)|
||
<n$|
�
r|�
r|
�|	�
}
}|	d7}	n|
�|	�
}
}|	d7}	d}n|
||<|t|
||
�
||
|��

q"|S)ac
Generate column names as rendered in a SELECT statement by
        the compiler.

        This is distinct from the _column_naming_convention generator that's
        intended for population of .c collections and similar, which has
        different rules.   the collection returned here calls upon the
        _column_naming_convention as well.

        NrFT)r��SelectState�_column_naming_conventionrZr�
r�
r�
�_render_label_in_columns_clauserr$�_non_anon_label�_anon_name_label�	_tq_label�_expression_label�_dedupe_anon_tq_label_idx�_dedupe_anon_label_idxr�
�_anon_tq_labelrS)r�r[r\�key_naming_convention�names�result�
result_append�table_qualified�label_style_none�dedupe_hashrS
rX�effective_namerTrV�
expr_labelr�r�r��_generate_columns_plus_names"	s�

�





�



�








�

�
�




���
�


�
�
�





��
z(SelectsRows._generate_columns_plus_namesr�)r[r�r\r]r�r^)r�r�r�r�r�
rZr
rrr�r�r�r�rY	s


�rYc@
sleZ
dZUd
ZdejfdejfgZded<dZ	ded<dZ
ded<ed	d
�
ddd��
Z					dddd�Z
dS)rIz3Mixin that declares a class to include CTE support.�_independent_ctes�_independent_ctes_optsrS�_has_ctes_traverse_internalsr�zTuple[CTE, ...]zTuple[_CTEOpts, ...]F�
�	nest_here�ctesrCrwr�r�r\c

G
sDt|
�
}|D]}t
�tj|�}|j|f
7_|j|f
7_q|S)
a�Add one or more :class:`_sql.CTE` constructs to this statement.

        This method will associate the given :class:`_sql.CTE` constructs with
        the parent statement such that they will each be unconditionally
        rendered in the WITH clause of the final statement, even if not
        referenced elsewhere within the statement or any sub-selects.

        The optional :paramref:`.HasCTE.add_cte.nest_here` parameter when set
        to True will have the effect that each given :class:`_sql.CTE` will
        render in a WITH clause rendered directly along with this statement,
        rather than being moved to the top of the ultimate rendered statement,
        even if this statement is rendered as a subquery within a larger
        statement.

        This method has two general uses. One is to embed CTE statements that
        serve some purpose without being referenced explicitly, such as the use
        case of embedding a DML statement such as an INSERT or UPDATE as a CTE
        inline with a primary statement that may draw from its results
        indirectly.  The other is to provide control over the exact placement
        of a particular series of CTE constructs that should remain rendered
        directly in terms of a particular statement that may be nested in a
        larger statement.

        E.g.::

            from sqlalchemy import table, column, select

            t = table("t", column("c1"), column("c2"))

            ins = t.insert().values({"c1": "x", "c2": "y"}).cte()

            stmt = select(t).add_cte(ins)

        Would render:

        .. sourcecode:: sql

            WITH anon_1 AS (
                INSERT INTO t (c1, c2) VALUES (:param_1, :param_2)
            )
            SELECT t.c1, t.c2
            FROM t

        Above, the "anon_1" CTE is not referenced in the SELECT
        statement, however still accomplishes the task of running an INSERT
        statement.

        Similarly in a DML-related context, using the PostgreSQL
        :class:`_postgresql.Insert` construct to generate an "upsert"::

            from sqlalchemy import table, column
            from sqlalchemy.dialects.postgresql import insert

            t = table("t", column("c1"), column("c2"))

            delete_statement_cte = t.delete().where(t.c.c1 < 1).cte("deletions")

            insert_stmt = insert(t).values({"c1": 1, "c2": 2})
            update_statement = insert_stmt.on_conflict_do_update(
                index_elements=[t.c.c1],
                set_={
                    "c1": insert_stmt.excluded.c1,
                    "c2": insert_stmt.excluded.c2,
                },
            ).add_cte(delete_statement_cte)

            print(update_statement)

        The above statement renders as:

        .. sourcecode:: sql

            WITH deletions AS (
                DELETE FROM t WHERE t.c1 < %(c1_1)s
            )
            INSERT INTO t (c1, c2) VALUES (%(c1)s, %(c2)s)
            ON CONFLICT (c1) DO UPDATE SET c1 = excluded.c1, c2 = excluded.c2

        .. versionadded:: 1.4.21

        :param \*ctes: zero or more :class:`.CTE` constructs.

         .. versionchanged:: 2.0  Multiple CTE instances are accepted

        :param nest_here: if True, the given CTE or CTEs will be rendered
         as though they specified the :paramref:`.HasCTE.cte.nesting` flag
         to ``True`` when they were added to this :class:`.HasCTE`.
         Assuming the given CTEs are not referenced in an outer-enclosing
         statement as well, the CTEs given should render at the level of
         this statement when this flag is given.

         .. versionadded:: 2.0

         .. seealso::

            :paramref:`.HasCTE.cte.nesting`


        )rRrr�r�	IsCTERolersrt)r�rwrx�optrDr�r�r��add_cte�	se




zHasCTE.add_cteNr�r�rGrHcC
r?
)a�&Return a new :class:`_expression.CTE`,
        or Common Table Expression instance.

        Common table expressions are a SQL standard whereby SELECT
        statements can draw upon secondary statements specified along
        with the primary statement, using a clause called "WITH".
        Special semantics regarding UNION can also be employed to
        allow "recursive" queries, where a SELECT statement can draw
        upon the set of rows that have previously been selected.

        CTEs can also be applied to DML constructs UPDATE, INSERT
        and DELETE on some databases, both as a source of CTE rows
        when combined with RETURNING, as well as a consumer of
        CTE rows.

        SQLAlchemy detects :class:`_expression.CTE` objects, which are treated
        similarly to :class:`_expression.Alias` objects, as special elements
        to be delivered to the FROM clause of the statement as well
        as to a WITH clause at the top of the statement.

        For special prefixes such as PostgreSQL "MATERIALIZED" and
        "NOT MATERIALIZED", the :meth:`_expression.CTE.prefix_with`
        method may be
        used to establish these.

        .. versionchanged:: 1.3.13 Added support for prefixes.
           In particular - MATERIALIZED and NOT MATERIALIZED.

        :param name: name given to the common table expression.  Like
         :meth:`_expression.FromClause.alias`, the name can be left as
         ``None`` in which case an anonymous symbol will be used at query
         compile time.
        :param recursive: if ``True``, will render ``WITH RECURSIVE``.
         A recursive common table expression is intended to be used in
         conjunction with UNION ALL in order to derive rows
         from those already selected.
        :param nesting: if ``True``, will render the CTE locally to the
         statement in which it is referenced.   For more complex scenarios,
         the :meth:`.HasCTE.add_cte` method using the
         :paramref:`.HasCTE.add_cte.nest_here`
         parameter may also be used to more carefully
         control the exact placement of a particular CTE.

         .. versionadded:: 1.4.24

         .. seealso::

            :meth:`.HasCTE.add_cte`

        The following examples include two from PostgreSQL's documentation at
        https://www.postgresql.org/docs/current/static/queries-with.html,
        as well as additional examples.

        Example 1, non recursive::

            from sqlalchemy import (
                Table,
                Column,
                String,
                Integer,
                MetaData,
                select,
                func,
            )

            metadata = MetaData()

            orders = Table(
                "orders",
                metadata,
                Column("region", String),
                Column("amount", Integer),
                Column("product", String),
                Column("quantity", Integer),
            )

            regional_sales = (
                select(orders.c.region, func.sum(orders.c.amount).label("total_sales"))
                .group_by(orders.c.region)
                .cte("regional_sales")
            )


            top_regions = (
                select(regional_sales.c.region)
                .where(
                    regional_sales.c.total_sales
                    > select(func.sum(regional_sales.c.total_sales) / 10)
                )
                .cte("top_regions")
            )

            statement = (
                select(
                    orders.c.region,
                    orders.c.product,
                    func.sum(orders.c.quantity).label("product_units"),
                    func.sum(orders.c.amount).label("product_sales"),
                )
                .where(orders.c.region.in_(select(top_regions.c.region)))
                .group_by(orders.c.region, orders.c.product)
            )

            result = conn.execute(statement).fetchall()

        Example 2, WITH RECURSIVE::

            from sqlalchemy import (
                Table,
                Column,
                String,
                Integer,
                MetaData,
                select,
                func,
            )

            metadata = MetaData()

            parts = Table(
                "parts",
                metadata,
                Column("part", String),
                Column("sub_part", String),
                Column("quantity", Integer),
            )

            included_parts = (
                select(parts.c.sub_part, parts.c.part, parts.c.quantity)
                .where(parts.c.part == "our part")
                .cte(recursive=True)
            )


            incl_alias = included_parts.alias()
            parts_alias = parts.alias()
            included_parts = included_parts.union_all(
                select(
                    parts_alias.c.sub_part, parts_alias.c.part, parts_alias.c.quantity
                ).where(parts_alias.c.part == incl_alias.c.sub_part)
            )

            statement = select(
                included_parts.c.sub_part,
                func.sum(included_parts.c.quantity).label("total_quantity"),
            ).group_by(included_parts.c.sub_part)

            result = conn.execute(statement).fetchall()

        Example 3, an upsert using UPDATE and INSERT with CTEs::

            from datetime import date
            from sqlalchemy import (
                MetaData,
                Table,
                Column,
                Integer,
                Date,
                select,
                literal,
                and_,
                exists,
            )

            metadata = MetaData()

            visitors = Table(
                "visitors",
                metadata,
                Column("product_id", Integer, primary_key=True),
                Column("date", Date, primary_key=True),
                Column("count", Integer),
            )

            # add 5 visitors for the product_id == 1
            product_id = 1
            day = date.today()
            count = 5

            update_cte = (
                visitors.update()
                .where(
                    and_(visitors.c.product_id == product_id, visitors.c.date == day)
                )
                .values(count=visitors.c.count + count)
                .returning(literal(1))
                .cte("update_cte")
            )

            upsert = visitors.insert().from_select(
                [visitors.c.product_id, visitors.c.date, visitors.c.count],
                select(literal(product_id), literal(day), literal(count)).where(
                    ~exists(update_cte.select())
                ),
            )

            connection.execute(upsert)

        Example 4, Nesting CTE (SQLAlchemy 1.4.24 and above)::

            value_a = select(literal("root").label("n")).cte("value_a")

            # A nested CTE with the same name as the root one
            value_a_nested = select(literal("nesting").label("n")).cte(
                "value_a", nesting=True
            )

            # Nesting CTEs takes ascendency locally
            # over the CTEs at a higher level
            value_b = select(value_a_nested.c.n).cte("value_b")

            value_ab = select(value_a.c.n.label("a"), value_b.c.n.label("b"))

        The above query will render the second CTE nested inside the first,
        shown with inline parameters below as:

        .. sourcecode:: sql

            WITH
                value_a AS
                    (SELECT 'root' AS n),
                value_b AS
                    (WITH value_a AS
                        (SELECT 'nesting' AS n)
                    SELECT value_a.n AS n FROM value_a)
            SELECT value_a.n AS a, value_b.n AS b
            FROM value_a, value_b

        The same CTE can be set up using the :meth:`.HasCTE.add_cte` method
        as follows (SQLAlchemy 2.0 and above)::

            value_a = select(literal("root").label("n")).cte("value_a")

            # A nested CTE with the same name as the root one
            value_a_nested = select(literal("nesting").label("n")).cte("value_a")

            # Nesting CTEs takes ascendency locally
            # over the CTEs at a higher level
            value_b = (
                select(value_a_nested.c.n)
                .add_cte(value_a_nested, nest_here=True)
                .cte("value_b")
            )

            value_ab = select(value_a.c.n.label("a"), value_b.c.n.label("b"))

        Example 5, Non-Linear CTE (SQLAlchemy 1.4.28 and above)::

            edge = Table(
                "edge",
                metadata,
                Column("id", Integer, primary_key=True),
                Column("left", Integer),
                Column("right", Integer),
            )

            root_node = select(literal(1).label("node")).cte("nodes", recursive=True)

            left_edge = select(edge.c.left).join(
                root_node, edge.c.right == root_node.c.node
            )
            right_edge = select(edge.c.right).join(
                root_node, edge.c.left == root_node.c.node
            )

            subgraph_cte = root_node.union(left_edge, right_edge)

            subgraph = select(subgraph_cte)

        The above query will render 2 UNIONs inside the recursive CTE:

        .. sourcecode:: sql

            WITH RECURSIVE nodes(node) AS (
                    SELECT 1 AS node
                UNION
                    SELECT edge."left" AS "left"
                    FROM edge JOIN nodes ON edge."right" = nodes.node
                UNION
                    SELECT edge."right" AS "right"
                    FROM edge JOIN nodes ON edge."left" = nodes.node
            )
            SELECT nodes.node FROM nodes

        .. seealso::

            :meth:`_orm.Query.cte` - ORM version of
            :meth:`_expression.HasCTE.cte`.

        )r�rGrH)rCr�)r�r�rGrHr�r�r�rDA
s
*
�z
HasCTE.cte�rxrCrwr�r�r\rs
)r�r�rGr�rHr�r�rC)r�r�r�r�rT�dp_clauseelement_list�dp_plain_objrur
rsrtr5r{rDr�r�r�r�rI�	s


�

m

�rIc@
sNeZ
dZUd
ZdZdZdZded<e	dddd��
Z	e
�d
d�ddd��
ZdS)�Subquerya�Represent a subquery of a SELECT.

    A :class:`.Subquery` is created by invoking the
    :meth:`_expression.SelectBase.subquery` method, or for convenience the
    :meth:`_expression.SelectBase.alias` method, on any
    :class:`_expression.SelectBase` subclass
    which includes :class:`_expression.Select`,
    :class:`_expression.CompoundSelect`, and
    :class:`_expression.TextualSelect`.  As rendered in a FROM clause,
    it represents the
    body of the SELECT statement inside of parenthesis, followed by the usual
    "AS <somename>" that defines all "alias" objects.

    The :class:`.Subquery` object is very similar to the
    :class:`_expression.Alias`
    object and can be used in an equivalent way.    The difference between
    :class:`_expression.Alias` and :class:`.Subquery` is that
    :class:`_expression.Alias` always
    contains a :class:`_expression.FromClause` object whereas
    :class:`.Subquery`
    always contains a :class:`_expression.SelectBase` object.

    .. versionadded:: 1.4 The :class:`.Subquery` class was added which now
       serves the purpose of providing an aliased version of a SELECT
       statement.

    �subqueryT�
SelectBaser
Nr�r�r�r�cC
st�
tj|
�j|d
�
S)z#Return a :class:`.Subquery` object.r�)rr�r�SelectStatementRoler�r;r�r�r�r(�s

��zSubquery._factoryr�ax
The :meth:`.Subquery.as_scalar` method, which was previously ``Alias.as_scalar()`` prior to version 1.4, is deprecated and will be removed in a future release; Please use the :meth:`_expression.Select.scalar_subquery` method of the :func:`_expression.select` construct before constructing a subquery object, or with the ORM use the :meth:`_query.Query.scalar_subquery` method.�ScalarSelect[Any]c

C
s|j�
t�
��Sr�)r
r�
r�
�scalar_subqueryr�r�r�r��	as_scalar�szSubquery.as_scalarr�)r�r�r�r�r�r�r�r�)
r�r�r�r�r��_is_subqueryr�r
rr(rXr�r�r�r�r�r�rns

�	

�
rc@
s�eZ
dZUd
Zdejfg
Zded<ded<d7dd�Ze	j
d8d
d��
Ze	j
d8dd
��
Ze
d9dd��
Ze
d:dd��
Zd;dd�Z	d<d=dd �Zd>d#d$�Ze	j
d?d&d'��
Ze	j
d@d)d*��
ZdAd,d-�ZdBd0d1�Zern	dCdDd5d6�ZdSdS)Er�
z%Represent a grouping of a FROM clauser
rSr�
r�cC
st�
tj|
�|_dSr�)rr�rr
r
�r�r
r�r�r�r�
�s
zFromGrouping.__init__r�rT
c


C
r�
r��r
r�r�r�r�r�r��szFromGrouping.columnsc


C
r�
r�r�r�r�r�r�rS
�rzFromGrouping.cr[
c


C
r�
r�)r
r�r�r�r�r�r��rzFromGrouping.primary_keyr]
c


C
r�
r�)r
r�r�r�r�r�r��rzFromGrouping.foreign_keysr�r�r�cC
s|j�
|
�
Sr�)r
r�r�r�r�r�r���
zFromGrouping.is_derived_fromNFr�r�r7
�NamedFromGroupingcC
st|j
j|
|d
��
S)Nrh
)r�r
r�r9
r�r�r�r��szFromGrouping.aliasr�
rc
K
st|j
jd
i|
�
�
�
Sr#
)r�
r
rk
�r�r�
r�r�r�rk
�s
z"FromGrouping._anonymous_fromclauser!
c


C
r�
r�)r
r$
r�r�r�r�r$
�rzFromGrouping._hide_fromsr�c


C
r�
r��r
r4r�r�r�r�r4�rzFromGrouping._from_objects�Dict[str, FromClause]c

C
s
d
|ji
S�Nr
rr�r�r�r��__getstate__��

zFromGrouping.__getstate__�stater�cC
s|
d
|_dSr�r�r�r�r�r�r��__setstate__��
zFromGrouping.__setstate__rl
rm
r\c
C
r�r�r�ro
r�r�r�rp
�r�zFromGrouping.self_group)r
r�rw
rx
ry
r�rt
)r�r�r7
r�r�r�)r�
rr�r�
rq
r�)r�r�)r�r�r�r�r��rl
rm
r�r\)r�r�r�r�rTrr�
r
r�
rXr�r�rS
r�r�r�r�r�rk
r$
r4r�r�rrp
r�r�r�r�r�
�s8

�





�




��r�
c@
s*eZ
dZd
ZdZer	d
ddd	�ZdSdS)r�zLrepresent a grouping of a named FROM clause

    .. versionadded:: 2.0

    TNrl
rm
r�r\c
C
r�r�r�ro
r�r�r�rp
�r�zNamedFromGrouping.self_groupr�r�)r�r�r�r�r�rrp
r�r�r�r�r��s
��r�c
s
eZ
dZUd
ZdZdejfdejfdejfgZde	d<dZ
d	e	d
<dZ	ej
d3dd��
Zd4�f
dd�ZerEejd5dd��
Zejd5dd��
Zd6dd�Zd7dd �Zej
d6d!d"��
Zd8d$d%�Ze�d&�
d9d(d)��
Ze�d&�
d:d+d,��
Ze�d&�
d;d.d/��
Zejd<d1d2��
Z�ZS)=�TableClausea.Represents a minimal "table" construct.

    This is a lightweight table object that has only a name, a
    collection of columns, which are typically produced
    by the :func:`_expression.column` function, and a schema::

        from sqlalchemy import table, column

        user = table(
            "user",
            column("id"),
            column("name"),
            column("description"),
        )

    The :class:`_expression.TableClause` construct serves as the base for
    the more commonly used :class:`_schema.Table` object, providing
    the usual set of :class:`_expression.FromClause` services including
    the ``.c.`` collection and statement generation methods.

    It does **not** provide all the additional schema-level services
    of :class:`_schema.Table`, including constraints, references to other
    tables, or support for :class:`_schema.MetaData`-level services.
    It's useful
    on its own as an ad-hoc construct used to generate quick SQL
    statements when a more fully fledged :class:`_schema.Table`
    is not on hand.

    r�
r�r�r'
rSr�
Tr��fullnameFr��Optional[ColumnClause[Any]]c


C
r"
)z4No PK or default support so no autoincrement column.Nr�r�r�r�r��_autoincrement_column,�z!TableClause._autoincrement_column�ColumnClause[Any]r�
rc
s�t��
�
|
|_t�|_t�|_t�|_|D]}|�	|�

q|�
d
d�}|du
r+||_|jdu
r:d|j|jf|_n|j|_|rIt
�dt|�
�
�
dS)Nr'
z%s.%szUnsupported argument(s): %s)r�
r�
r�r>r&
r<r�rY
r��
append_columnr^
r'
r�rW�
ArgumentErrorr�
)r�r�r�r�
rS
r'
r�
r�r�r�
1s 














�zTableClause.__init__�0ReadOnlyColumnCollection[str, ColumnClause[Any]]c


C
r�r�r�r�r�r�r�r�Fr�zTableClause.columnsc


C
r�r�r�r�r�r�r�rS
Kr�z
TableClause.cc

C
s |jdu
r
|jd
|j
S|j
S)N�
.)r'
r�r�r�r�r��__str__Ns


zTableClause.__str__r�r�r�c
C
r�r�r�r�r�r�r�r�Tr�z#TableClause._refresh_for_new_columnc


C
r�r�r�r�r�r�r�rH
Wr�zTableClause.descriptionrS
cC
s@|
j}|du
r||u
rt
�d
|
j|f�
�
|j�|
�

||
_dS)Nz1column object '%s' already assigned to table '%s')r�
rWr�r_
r&
�add)r�rS
�existingr�r�r�r�[s




��

zTableClause.append_columnzsqlalchemy.sql.dml�util.preloaded.sql_dml.Insertc

C
�tj
j�|�
S)
z�Generate an :class:`_sql.Insert` construct against this
        :class:`_expression.TableClause`.

        E.g.::

            table.insert().values(name="foo")

        See :func:`_expression.insert` for argument and usage information.

        )rXr��sql_dml�Insertr�r�r�r��insertfs
zTableClause.insertryc

C
r�)
a
Generate an :func:`_expression.update` construct against this
        :class:`_expression.TableClause`.

        E.g.::

            table.update().where(table.c.id == 7).values(name="foo")

        See :func:`_expression.update` for argument and usage information.

        )rXr�r�ryr�r�r�r�r�
us
�zTableClause.updaterxc

C
r�)
z�Generate a :func:`_expression.delete` construct against this
        :class:`_expression.TableClause`.

        E.g.::

            table.delete().where(table.c.id == 7)

        See :func:`_expression.delete` for argument and usage information.

        )rXr�r�rxr�r�r�r��delete�szTableClause.deleter�c


C
rr�r�r�r�r�r�r4�r�zTableClause._from_objects)r�r�)r�r�r�r�r�
r)r�r�rv
r�)rS
r�r�r�)r�r�)r�ry)r�rxr�)r�r�r�r�r�rT�)dp_fromclause_canonical_column_collection�	dp_stringr�
r
�	_is_tablerrXr
r�r�
rr�r�rS
r�r�rH
r�r�r�r�
r�r4rr�r�r�
r�r��sD


�
�	












r��ForUpdateArgc@
s�eZ
dZUd
ejfdejfdejfdejfdejfgZded<ded
<d	ed<d	ed<d	ed<eddd��
Z	d dd�Z
d dd�Zd!dd�Zdddddd�d"dd�Z
dS)#r��of�nowait�read�skip_locked�	key_sharerSr�
z!Optional[Sequence[ClauseElement]]r��with_for_update�ForUpdateParameterr��Optional[ForUpdateArg]cC
s<t|
t
�r|
S|
d
vr
dS|
durt
�St
ditd|
��
�
S)Nrt
T�Dict[str, Any]r�)r�
r�r)r�
r�r�r�r��_from_argument�s





zForUpdateArg._from_argumentrB
rcC
sFt|
t
�o"|
j|jko"|
j|jko"|
j|jko"|
j|jko"|
j|juSr�)r�
r�r�r�r�r�r�rD
r�r�r��__eq__�s


�
�
�
�
�zForUpdateArg.__eq__cC
s|�|
�
Sr�)
r�rD
r�r�r��__ne__�r�zForUpdateArg.__ne__�intc

C
r)
r�)
r�
r�r�r�r��__hash__�s
zForUpdateArg.__hash__FN�r�r�r�r�r��Optional[_ForUpdateOfArgument]c
C
sD|
|_||_
||_||_|d
u
rdd�t�|�
D�
|_d
Sd
|_d
S)zZRepresents arguments specified to
        :meth:`_expression.Select.for_update`.

        Nc
S
�g|]	}
t�
tj|
��qSr��rr�r�ColumnsClauseRole�r
�elemr�r�r�r
����z)ForUpdateArg.__init__.<locals>.<listcomp>)r�r�r�r�rX�to_listr��r�r�r�r�r�r�r�r�r�r�
�s




�
zForUpdateArg.__init__)r�r�r�r�)rB
rr�r�)r�r�)
r�r�r�r�r�r�r�r�r�r�)r�r�r�rTr}rr�
r
rr�r�r�r�r�
r�r�r�r�r��s,




�











�c
s�eZ
dZUd
ZdZdZded<ded<dejfdej	fd	ej
fd
ejfgZded<d
dd�d1�f
dd�Z
ed2dd��
Zed3d4dd��
Zed5d6dd��
Zed7d!d"��
Zd8d$d%�Zd9d,d-�Zejd:d/d0��
Z�ZS);�Valuesz�Represent a ``VALUES`` construct that can be used as a FROM element
    in a statement.

    The :class:`_expression.Values` object is created from the
    :func:`_expression.values` function.

    .. versionadded:: 1.4

    r�
r��%Tuple[Sequence[Tuple[Any, ...]], ...]�_datar��_unnamed�_column_argsr��
literal_bindsrSr�
NF)r�r�r�r�r�c

sRt��
�
||_|
durd
|_t�t|�
d�|_nd|_|
|_||_|j|_	dS)NTrF)
r�
r�
r�r�rErr�
r�r�r|
)r�r�r�r�r�
r�r�r�
�s






zValues.__init__r��List[TypeEngine[Any]]c

C
ra
)Nc
S
r�
r��
�typerN
r�r�r�r

r�
z(Values._column_types.<locals>.<listcomp>�
r�r�r�r�r��
_column_types

rd
zValues._column_typesr7
r\cC
s4|
d
ur
t�
t|�
d�}n|
}||_d|_d|_|S)aY
Return a new :class:`_expression.Values`
        construct that is a copy of this
        one with the given name.

        This method is a VALUES-specific specialization of the
        :meth:`_expression.FromClause.alias` method.

        .. seealso::

            :ref:`tutorial_using_aliases`

            :func:`_expression.alias`

        NrTF)rErr�
r�r|
r�)r�r�r7
�
non_none_namer�r�r�r�
s



zValues.aliasr�cC
s*|
d
ur|j}n|
}d|_
||_d|_|S)z�Return a new :class:`_expression.Values` with the lateral flag set,
        so that
        it renders as LATERAL.

        .. seealso::

            :func:`_expression.lateral`

        NTF)r�r�r�)r�r�r�r�r�r�r�*
s




zValues.lateral�Sequence[Tuple[Any, ...]]cC
s|j|
f
7_|S)
aj
Return a new :class:`_expression.Values` construct,
        adding the given data to the data list.

        E.g.::

            my_values = my_values.data([(1, "value 1"), (2, "value2")])

        :param values: a sequence (i.e. list) of tuples that map to the
         column expressions given in the :class:`_expression.Values`
         constructor.

        )
r�)r�r�
r�r�r��dataA
s
zValues.data�ScalarValuesc

C
st|j
|j|j�S)
z�Returns a scalar ``VALUES`` construct that can be used as a
        COLUMN element in a statement.

        .. versionadded:: 2.0.0b4

        )r�r�r�r�r�r�r�r��
scalar_valuesS
szValues.scalar_valuesr�r�r<r�r�r�cC
sR|jD]#}|j
du
r|j
|u
r|j|||d
�\}}n|��
|
�|�

||_
qdSr)r�r�
rM
r�
r�)r�r�r�r�rS
r�
r�r�r�rZ
\
s



�


�z"Values._populate_column_collectionr�c


C
rr�r�r�r�r�r�r4o
r�zValues._from_objects)r�r�r�r�r�r��r�r�rt
)r�r�r7
r�r�r\r�r�)r�
r�r�r\�r�r�r{
r�)r�r�r�r�r�r�r
rTr}�dp_dml_multi_valuesr�rr�
r�
r�r�r5r�r�r�r�rZ
rXr�r4rr�r�r�
r�r��s2





�

�





	
r�c
s~eZ
dZUd
ZdZdejfdejfdejfgZ	de
d<d�f
d
d�Zeddd��
Z
ddd�Zer;	dddd�Z�ZS�ZS) r�a{
Represent a scalar ``VALUES`` construct that can be used as a
    COLUMN element in a statement.

    The :class:`_expression.ScalarValues` object is created from the
    :meth:`_expression.Values.scalar_values` method. It's also
    automatically generated when a :class:`_expression.Values` is used in
    an ``IN`` or ``NOT IN`` condition.

    .. versionadded:: 2.0.0b4

    r�r�r�r�rSr�
r��Sequence[ColumnClause[Any]]r�r�r�c
s t��
�
|
|_||_||_dSr�)r�
r�
r�r�r�)r�r�r�r�r�
r�r�r�
�
s




zScalarValues.__init__r�r�c

C
ra
)Nc
S
r�
r�r�rN
r�r�r�r
�
r�
z.ScalarValues._column_types.<locals>.<listcomp>r�r�r�r�r�r��
rd
zScalarValues._column_typesc


C
r�r�r�r�r�r�r��__clause_element__�
r�zScalarValues.__clause_element__Nrl
rm
r\c
C
r�r�r�ro
r�r�r�rp
�
r�zScalarValues.self_group)r�r�r�r�r�r�r�r�r�r�)r�r�r�r�r�rTr}r�rr�
r
r�
r�r�r�rrp
rr�r�r�
r�r�t
s



�

��r�c@
s>
eZ
dZUd
ZdZdZeZded<dVd	d
�Z	e
jdWdd
��
Zdd�
dXdd�Z
e
jdYdd��
ZedZd d!��
Zee
�d"d#�d[d%d&��
�
Zed[d'd(��
Zd\d)d*�Zd]d-d.�Ze
�d"d/�d^d4d5��
Zejd_d7d8��
Zd`d:d;�Ze
�d"d<�dad>d?��
ZdbdAdB�ZdadCdD�ZdcdHdI�ZdddedKdL�ZdddfdMdN�Z dgdOdP�Z!	QdhdidTdU�Z"dS)jr�z�Base class for SELECT statements.


    This includes :class:`_expression.Select`,
    :class:`_expression.CompoundSelect` and
    :class:`_expression.TextualSelect`.


    Tr�
rZr�r�r�r�cC
�|��
dSr�)
r�
r�r�r�r�r��
r�z"SelectBase._refresh_for_new_column�)ColumnCollection[str, ColumnElement[Any]]c


C
r�)
a$A :class:`_expression.ColumnCollection`
        representing the columns that
        this SELECT statement or similar construct returns in its result set.

        This collection differs from the :attr:`_expression.FromClause.columns`
        collection of a :class:`_expression.FromClause` in that the columns
        within this collection cannot be directly nested inside another SELECT
        statement; a subquery must be applied first which provides for the
        necessary parenthesization required by SQL.

        .. note::

            The :attr:`_sql.SelectBase.selected_columns` collection does not
            include expressions established in the columns clause using the
            :func:`_sql.text` construct; these are silently omitted from the
            collection. To use plain textual column expressions inside of a
            :class:`_sql.Select` construct, use the :func:`_sql.literal_column`
            construct.

        .. seealso::

            :attr:`_sql.Select.selected_columns`

        .. versionadded:: 1.4

        r�r�r�r�r��selected_columns�
szSelectBase.selected_columnsN�
�proxy_compound_columnsr�r�r�r�r�r<r�r�r��0Optional[Iterable[Sequence[ColumnElement[Any]]]]c

C
r�r�r��r�r�r�r�r�r�r�r�r�r��
sz.SelectBase._generate_fromclause_column_proxiesr�c


C
r�)
a
A sequence of expressions that correspond to what is rendered
        in the columns clause, including :class:`_sql.TextClause`
        constructs.

        .. versionadded:: 1.4.12

        .. seealso::

            :attr:`_sql.SelectBase.exported_columns`

        r�r�r�r�r�r��
s
z SelectBase._all_selected_columns�1ReadOnlyColumnCollection[str, ColumnElement[Any]]c

C
�
|j�
�S)
afA :class:`_expression.ColumnCollection`
        that represents the "exported"
        columns of this :class:`_expression.Selectable`, not including
        :class:`_sql.TextClause` constructs.

        The "exported" columns for a :class:`_expression.SelectBase`
        object are synonymous
        with the :attr:`_expression.SelectBase.selected_columns` collection.

        .. versionadded:: 1.4

        .. seealso::

            :attr:`_expression.Select.exported_columns`

            :attr:`_expression.Selectable.exported_columns`

            :attr:`_expression.FromClause.exported_columns`


        )r�rX
r�r�r�r�r��
s
zSelectBase.exported_columnsr�a�
The :attr:`_expression.SelectBase.c` and :attr:`_expression.SelectBase.columns` attributes are deprecated and will be removed in a future release; these attributes implicitly create a subquery that should be explicit.  Please call :meth:`_expression.SelectBase.subquery` first in order to create a subquery, which then contains this attribute.  To access the columns that this SELECT object SELECTs from, use the :attr:`_expression.SelectBase.selected_columns` attribute.rT
c


C
r�
r�)�_implicit_subqueryr�r�r�r�r�rS
�zSelectBase.cc


C
r�r�rU
r�r�r�r�r�%szSelectBase.columnsc


C
r�)
zX
        Retrieve the current label style.

        Implemented by subclasses.

        r�r�r�r�r��get_label_style+r�zSelectBase.get_label_style�styler\c
C
r�)
zeReturn a new selectable with the specified label style.

        Implemented by subclasses.

        r��r�r�r�r�r�r�
4r�zSelectBase.set_label_stylea 
The :meth:`_expression.SelectBase.select` method is deprecated and will be removed in a future release; this method implicitly creates a subquery that should be explicit.  Please call :meth:`_expression.SelectBase.subquery` first in order to create a subquery, which then can be selected.r	rr�
r(
c
O
s|jj
|
i|�
�
Sr�)r�r,
rr�r�r�r,
=s
zSelectBase.selectrc

C
�|��Sr��
r�r�r�r�r�r�IrzSelectBase._implicit_subquery�TypeEngine[Any]c


C
r�r�r�r�r�r�r��_scalar_typeMr�zSelectBase._scalar_typez�The :meth:`_expression.SelectBase.as_scalar` method is deprecated and will be removed in a future release.  Please refer to :meth:`_expression.SelectBase.scalar_subquery`.r�c

C
r�r�)
r�r�r�r�r�r�PszSelectBase.as_scalar�Existsc

C
r)
)
aa
Return an :class:`_sql.Exists` representation of this selectable,
        which can be used as a column expression.

        The returned object is an instance of :class:`_sql.Exists`.

        .. seealso::

            :func:`_sql.exists`

            :ref:`tutorial_exists` - in the :term:`2.0 style` tutorial.

        .. versionadded:: 1.4

        )
r�r�r�r�r��existsZr�zSelectBase.existsc

C
s|jt
u
r
|�t
�
}t|�
S)
aXReturn a 'scalar' representation of this selectable, which can be
        used as a column expression.

        The returned object is an instance of :class:`_sql.ScalarSelect`.

        Typically, a select statement which has only one column in its columns
        clause is eligible to be used as a scalar expression.  The scalar
        subquery can then be used in the WHERE clause or columns clause of
        an enclosing SELECT.

        Note that the scalar subquery differentiates from the FROM-level
        subquery that can be produced using the
        :meth:`_expression.SelectBase.subquery`
        method.

        .. versionchanged: 1.4 - the ``.as_scalar()`` method was renamed to
           :meth:`_expression.SelectBase.scalar_subquery`.

        .. seealso::

            :ref:`tutorial_scalar_subquery` - in the 2.0 tutorial

        )rZr�
r�
�ScalarSelectr�r�r�r�r�ks


zSelectBase.scalar_subqueryr�r��
Label[Any]cC
s|���
|
�
S)
z�Return a 'scalar' representation of this selectable, embedded as a
        subquery with a label.

        .. seealso::

            :meth:`_expression.SelectBase.scalar_subquery`.

        )r��labelr�r�r�r�r��s	zSelectBase.labelr�cC
st�
||
�S)
r�)r�r(r�r�r�r�r��szSelectBase.lateralcC
stj
|��|
d
�S)aReturn a subquery of this :class:`_expression.SelectBase`.

        A subquery is from a SQL perspective a parenthesized, named
        construct that can be placed in the FROM clause of another
        SELECT statement.

        Given a SELECT statement such as::

            stmt = select(table.c.id, table.c.name)

        The above statement might look like:

        .. sourcecode:: sql

            SELECT table.id, table.name FROM table

        The subquery form by itself renders the same way, however when
        embedded into the FROM clause of another SELECT statement, it becomes
        a named sub-element::

            subq = stmt.subquery()
            new_stmt = select(subq)

        The above renders as:

        .. sourcecode:: sql

            SELECT anon_1.id, anon_1.name
            FROM (SELECT table.id, table.name FROM table) AS anon_1

        Historically, :meth:`_expression.SelectBase.subquery`
        is equivalent to calling
        the :meth:`_expression.FromClause.alias`
        method on a FROM object; however,
        as a :class:`_expression.SelectBase`
        object is not directly  FROM object,
        the :meth:`_expression.SelectBase.subquery`
        method provides clearer semantics.

        .. versionadded:: 1.4

        r�)rr��_ensure_disambiguated_namesr�r�r�r�r��s,
�zSelectBase.subqueryc


C
r�)
ztEnsure that the names generated by this selectbase will be
        disambiguated in some way, if possible.

        r�r�r�r�r�r��sz&SelectBase._ensure_disambiguated_namesFr7
r�cC
ri
)a.Return a named subquery against this
        :class:`_expression.SelectBase`.

        For a :class:`_expression.SelectBase` (as opposed to a
        :class:`_expression.FromClause`),
        this returns a :class:`.Subquery` object which behaves mostly the
        same as the :class:`_expression.Alias` object that is used with a
        :class:`_expression.FromClause`.

        .. versionchanged:: 1.4 The :meth:`_expression.SelectBase.alias`
           method is now
           a synonym for the :meth:`_expression.SelectBase.subquery` method.

        r�r�r9
r�r�r�r��szSelectBase.aliasr��r�r��r�r�r�r�r�r<r�r�r�r�r�r�r�)r�r�rw
�r�r�
�r�r�
r�r\)r	rr�
rr�r(
)r�r�r�r�r�)r�r�)r�r�r�r�r�r�)r�r�r�r)r�r\rt
)r�r�r7
r�r�r)#r�r�r�r�r��	is_selectr�
rZr
r�rXr�r�r�r�r�r�r�rS
r�r�r�
r,
rBr8r�r�r�r�r�r�r�r�r�r�r�r�r�r�r��
sZ
	



(�





�



		

�	



�



0	�r��_SBc@
s�eZ
dZUd
ZdZdejfg
ejZ	de
d<dZde
d<d=d
d�Zd>d
d�Z
d?dd�Zd@dd�ZedAdd��
ZdBdCdd�ZerDdAdd�Zdd�
dDd*d+�ZejdEd-d.��
ZejdFd0d1��
ZejdGd3d4��
Zd5d6�
dHd;d<�ZdS)I�SelectStatementGroupingz�Represent a grouping of a :class:`_expression.SelectBase`.

    This differs from :class:`.Subquery` in that we are still
    an "inner" SELECT statement, this is strictly for grouping inside of
    compound selects.

    �select_statement_groupingr
rSr�
Tr�r�r�cC
stt
t�tj|
��|_dSr�)rr�rr�rr�r
r�r�r�r�r�

s


�z SelectStatementGrouping.__init__�SelectStatementGrouping[_SB]c
C
s |j�
�}
|
|ju
rt|
�
S|Sr�)r
r�r�)r��new_elementr�r�r�r�s




z3SelectStatementGrouping._ensure_disambiguated_namesr�
c

C
r�r�)r
r�r�r�r�r�r�
r�z'SelectStatementGrouping.get_label_style�label_stylecC
st|j
�|
�
�
Sr�)r�r
r�
)r�r�r�r�r�r�
s

�z'SelectStatementGrouping.set_label_stylec


C
r�r�rr�r�r�r��select_statementr�z(SelectStatementGrouping.select_statementNrl
rm
r\c
C
r�r�r�ro
r�r�r�rp
r�z"SelectStatementGrouping.self_groupc


C
r�r�r�r�r�r�r��_ungroup rg
z SelectStatementGrouping._ungroupr�r�r�r�r�r�r<r�r�r�r�c
C
s|jj
|
||||d
�
dS)N�r�r�r�rr�r�r�r�r�'s





�z;SelectStatementGrouping._generate_fromclause_column_proxiesr�c


C
r�
r�)r
r�r�r�r�r�r�:rz-SelectStatementGrouping._all_selected_columnsr�c


C
r�
)
a:
A :class:`_expression.ColumnCollection`
        representing the columns that
        the embedded SELECT statement returns in its result set, not including
        :class:`_sql.TextClause` constructs.

        .. versionadded:: 1.4

        .. seealso::

            :attr:`_sql.Select.selected_columns`

        )r
r�r�r�r�r�r�>r-
z(SelectStatementGrouping.selected_columnsr�c


C
r�
r�r�r�r�r�r�r4Nrz%SelectStatementGrouping._from_objectsFrvrxrCrwr�c


G
st�
r�r�)r�rwrxr�r�r�r{Rr�zSelectStatementGrouping.add_cte)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�rTrr*�%_clone_annotations_traverse_internalsr�
r
�_is_select_containerr�
r�r�r�
r�r�rp
rrr�rXr�r�r�r4r{r�r�r�r�r��s6

��





�


r�c@
s�
eZ
dZUd
ZdZded<dZded<dZded<dZded	<dZ	ded
<dZ
ded<dZd
ed<ef
d`dd�Z
edddddd�dadd��
Zdbd d!�Zdcd#d$�Zeddd&d'��
Zeddd(d)��
Z		dedfd1d2�Zedgd7d8��
Zedhd;d8��
Zdid=d8�Zedjd>d?��
ZdkdAdB�ZedjdCdD��
ZedldEdF��
ZedmdHdI��
Ze		dndodMdN��
ZedpdPdQ��
Zee� dR�
dqdVdW��
�
Z!ee"j#f
drd\d]��
Z$ee"j#f
drd^d_��
Z%dS)s�GenerativeSelecta&Base class for SELECT statements where additional elements can be
    added.

    This serves as the base for :class:`_expression.Select` and
    :class:`_expression.CompoundSelect`
    where elements such as ORDER BY, GROUP BY can be added and column
    rendering can be controlled.  Compare to
    :class:`_expression.TextualSelect`, which,
    while it subclasses :class:`_expression.SelectBase`
    and is also a SELECT construct,
    represents a fixed textual string which cannot be altered at this level,
    only wrapped as a subquery.

    r��Tuple[ColumnElement[Any], ...]�_order_by_clauses�_group_by_clausesN�Optional[ColumnElement[Any]]�
_limit_clause�_offset_clause�
_fetch_clausezOptional[Dict[str, bool]]�_fetch_clause_optionsr��_for_update_argrZr�
cC
s
|
|_dSr��
rZ)r�rZr�r�r�r�
or�zGenerativeSelect.__init__Fr�r�r�r�r�r�r�r�r�r\c
C
st|
||||d
�|_
|S)a~Specify a ``FOR UPDATE`` clause for this
        :class:`_expression.GenerativeSelect`.

        E.g.::

            stmt = select(table).with_for_update(nowait=True)

        On a database like PostgreSQL or Oracle Database, the above would
        render a statement like:

        .. sourcecode:: sql

            SELECT table.a, table.b FROM table FOR UPDATE NOWAIT

        on other backends, the ``nowait`` option is ignored and instead
        would produce:

        .. sourcecode:: sql

            SELECT table.a, table.b FROM table FOR UPDATE

        When called with no arguments, the statement will render with
        the suffix ``FOR UPDATE``.   Additional arguments can then be
        provided which allow for common database-specific
        variants.

        :param nowait: boolean; will render ``FOR UPDATE NOWAIT`` on Oracle
         Database and PostgreSQL dialects.

        :param read: boolean; will render ``LOCK IN SHARE MODE`` on MySQL,
         ``FOR SHARE`` on PostgreSQL.  On PostgreSQL, when combined with
         ``nowait``, will render ``FOR SHARE NOWAIT``.

        :param of: SQL expression or list of SQL expression elements,
         (typically :class:`_schema.Column` objects or a compatible expression,
         for some backends may also be a table expression) which will render
         into a ``FOR UPDATE OF`` clause; supported by PostgreSQL, Oracle
         Database, some MySQL versions and possibly others. May render as a
         table or as a column depending on backend.

        :param skip_locked: boolean, will render ``FOR UPDATE SKIP LOCKED`` on
         Oracle Database and PostgreSQL dialects or ``FOR SHARE SKIP LOCKED``
         if ``read=True`` is also specified.

        :param key_share: boolean, will render ``FOR NO KEY UPDATE``,
         or if combined with ``read=True`` will render ``FOR KEY SHARE``,
         on the PostgreSQL dialect.

        r�)r�r
r�r�r�r�r�rs;




�z GenerativeSelect.with_for_updatec


C
r�)
zS
        Retrieve the current label style.

        .. versionadded:: 1.4

        rr�r�r�r�r��r�z GenerativeSelect.get_label_styler�cC
s|j|
u
r|�
�}|
|_|S)
a{Return a new selectable with the specified label style.

        There are three "label styles" available,
        :attr:`_sql.SelectLabelStyle.LABEL_STYLE_DISAMBIGUATE_ONLY`,
        :attr:`_sql.SelectLabelStyle.LABEL_STYLE_TABLENAME_PLUS_COL`, and
        :attr:`_sql.SelectLabelStyle.LABEL_STYLE_NONE`.   The default style is
        :attr:`_sql.SelectLabelStyle.LABEL_STYLE_DISAMBIGUATE_ONLY`.

        In modern SQLAlchemy, there is not generally a need to change the
        labeling style, as per-expression labels are more effectively used by
        making use of the :meth:`_sql.ColumnElement.label` method. In past
        versions, :data:`_sql.LABEL_STYLE_TABLENAME_PLUS_COL` was used to
        disambiguate same-named columns from different tables, aliases, or
        subqueries; the newer :data:`_sql.LABEL_STYLE_DISAMBIGUATE_ONLY` now
        applies labels only to names that conflict with an existing name so
        that the impact of this labeling is minimal.

        The rationale for disambiguation is mostly so that all column
        expressions are available from a given :attr:`_sql.FromClause.c`
        collection when a subquery is created.

        .. versionadded:: 1.4 - the
            :meth:`_sql.GenerativeSelect.set_label_style` method replaces the
            previous combination of ``.apply_labels()``, ``.with_labels()`` and
            ``use_labels=True`` methods and/or parameters.

        .. seealso::

            :data:`_sql.LABEL_STYLE_DISAMBIGUATE_ONLY`

            :data:`_sql.LABEL_STYLE_TABLENAME_PLUS_COL`

            :data:`_sql.LABEL_STYLE_NONE`

            :data:`_sql.LABEL_STYLE_DEFAULT`

        )rZ�	_generater�r�r�r�r�
�s
&


z GenerativeSelect.set_label_stylerIc

C
�t�
tj|j�S)
z9ClauseList access to group_by_clauses for legacy dialects)rI�_construct_rawr�comma_oprr�r�r�r��_group_by_clause��
�z!GenerativeSelect._group_by_clausec

C
r)
z9ClauseList access to order_by_clauses for legacy dialects)rIrrrrr�r�r�r��_order_by_clause�rz!GenerativeSelect._order_by_clauser
rcr�r��type_�"Optional[_TypeEngineArgument[int]]r�cC
stj
tj|
||d
�S)z�Convert the given value to an "offset or limit" clause.

        This handles incoming integers and converts to an expression; if
        an expression is already given, it is passed through.

        )r�r)rr�r�LimitOffsetRole)r�r
r�rr�r�r��_offset_or_limit_clause�s

�z(GenerativeSelect._offset_or_limit_clause�clause�attrnamer�rc
C
r�r�r��r�rrr�r�r��_offset_or_limit_clause_asintr�z.GenerativeSelect._offset_or_limit_clause_asint�Optional[_OffsetLimitParam]r�c
C
r�r�r�rr�r�r�r
r��Union[NoReturn, Optional[int]]c
C
sJ|
d
urd
Sz|
j}Wnt
y
}
zt�d|�
|�d
}~w
wt�|�
S)z�Convert the "offset or limit" clause of a select construct to an
        integer.

        This is only possible if the value is stored as a simple bound
        parameter. Otherwise, a compilation error is raised.

        Nz@This SELECT structure does not use a simple integer value for %s)r��AttributeErrorrW�CompileErrorrX�asint)r�rr�value�errr�r�r�rs








�����
c

C
�|�|j
d
�S)z�Get an integer value for the limit.  This should only be used
        by code that cannot support a limit as a BindParameter or
        other custom clause as it will throw an exception if the limit
        isn't currently set to an integer.

        �limit)rr	r�r�r�r��_limit(szGenerativeSelect._limitrHcC
s
t|
t
�S)
zkTrue if the clause is a simple integer, False
        if it is not present or is a SQL expression.
        )r�
r�)r�rr�r�r��_simple_int_clause2s
z#GenerativeSelect._simple_int_clausec

C
r%)z�Get an integer value for the offset.  This should only be used
        by code that cannot support an offset as a BindParameter or
        other custom clause as it will throw an exception if the
        offset isn't currently set to an integer.

        �offset)rr
r�r�r�r��_offset8s
�zGenerativeSelect._offsetc

C
s|jdu
p|j
du
p|jdu
Sr�)r	r
rr�r�r�r��_has_row_limiting_clauseDs


��z)GenerativeSelect._has_row_limiting_clauser&cC
sd
|_|_
|�|
�
|_|S)a�Return a new selectable with the given LIMIT criterion
        applied.

        This is a numerical value which usually renders as a ``LIMIT``
        expression in the resulting select.  Backends that don't
        support ``LIMIT`` will attempt to provide similar
        functionality.

        .. note::

           The :meth:`_sql.GenerativeSelect.limit` method will replace
           any clause applied with :meth:`_sql.GenerativeSelect.fetch`.

        :param limit: an integer LIMIT parameter, or a SQL expression
         that provides an integer result. Pass ``None`` to reset it.

        .. seealso::

           :meth:`_sql.GenerativeSelect.fetch`

           :meth:`_sql.GenerativeSelect.offset`

        N)rrrr	)r�r&r�r�r�r&Ls

zGenerativeSelect.limit�count�	with_ties�percentcC
s:d
|_|
d
urd
|_
|_|S|�|
�
|_
||d�|_|S)a�Return a new selectable with the given FETCH FIRST criterion
        applied.

        This is a numeric value which usually renders as ``FETCH {FIRST | NEXT}
        [ count ] {ROW | ROWS} {ONLY | WITH TIES}`` expression in the resulting
        select. This functionality is is currently implemented for Oracle
        Database, PostgreSQL, MSSQL.

        Use :meth:`_sql.GenerativeSelect.offset` to specify the offset.

        .. note::

           The :meth:`_sql.GenerativeSelect.fetch` method will replace
           any clause applied with :meth:`_sql.GenerativeSelect.limit`.

        .. versionadded:: 1.4

        :param count: an integer COUNT parameter, or a SQL expression
         that provides an integer result. When ``percent=True`` this will
         represent the percentage of rows to return, not the absolute value.
         Pass ``None`` to reset it.

        :param with_ties: When ``True``, the WITH TIES option is used
         to return any additional rows that tie for the last place in the
         result set according to the ``ORDER BY`` clause. The
         ``ORDER BY`` may be mandatory in this case. Defaults to ``False``

        :param percent: When ``True``, ``count`` represents the percentage
         of the total number of selected rows to return. Defaults to ``False``

        .. seealso::

           :meth:`_sql.GenerativeSelect.limit`

           :meth:`_sql.GenerativeSelect.offset`

        N)r-r.)r	rrr)r�r,r-r.r�r�r��fetchjs-

�
�zGenerativeSelect.fetchr)cC
s|�|
�
|_
|S)
a2Return a new selectable with the given OFFSET criterion
        applied.


        This is a numeric value which usually renders as an ``OFFSET``
        expression in the resulting select.  Backends that don't
        support ``OFFSET`` will attempt to provide similar
        functionality.

        :param offset: an integer OFFSET parameter, or a SQL expression
         that provides an integer result. Pass ``None`` to reset it.

        .. seealso::

           :meth:`_sql.GenerativeSelect.limit`

           :meth:`_sql.GenerativeSelect.fetch`

        )rr
)r�r)r�r�r�r)�s
zGenerativeSelect.offsetr��startr��stopcC
s4tj
j}d
|_|_|�|j|j|
|�\|_|_|S)aApply LIMIT / OFFSET to this statement based on a slice.

        The start and stop indices behave like the argument to Python's
        built-in :func:`range` function. This method provides an
        alternative to using ``LIMIT``/``OFFSET`` to get a slice of the
        query.

        For example, ::

            stmt = select(User).order_by(User.id).slice(1, 3)

        renders as

        .. sourcecode:: sql

           SELECT users.id AS users_id,
                  users.name AS users_name
           FROM users ORDER BY users.id
           LIMIT ? OFFSET ?
           (2, 1)

        .. note::

           The :meth:`_sql.GenerativeSelect.slice` method will replace
           any clause applied with :meth:`_sql.GenerativeSelect.fetch`.

        .. versionadded:: 1.4  Added the :meth:`_sql.GenerativeSelect.slice`
           method generalized from the ORM.

        .. seealso::

           :meth:`_sql.GenerativeSelect.limit`

           :meth:`_sql.GenerativeSelect.offset`

           :meth:`_sql.GenerativeSelect.fetch`

        N)rXr�r�rr�_make_slicer	r
)r�r0r1r�r�r�r��slice�s-


�zGenerativeSelect.slice�_GenerativeSelect__first�MUnion[Literal[None, _NoArg.NO_ARG], _ColumnExpressionOrStrLabelArgument[Any]]�clauses�(_ColumnExpressionOrStrLabelArgument[Any]c
�J|s|
d
urd�_�S|
t
ju
r#�jt�f
dd�|
f
|D�
�
7_�S)a�Return a new selectable with the given list of ORDER BY
        criteria applied.

        e.g.::

            stmt = select(table).order_by(table.c.id, table.c.name)

        Calling this method multiple times is equivalent to calling it once
        with all the clauses concatenated. All existing ORDER BY criteria may
        be cancelled by passing ``None`` by itself.  New ORDER BY criteria may
        then be added by invoking :meth:`_orm.Query.order_by` again, e.g.::

            # will erase all ORDER BY and ORDER BY new_col alone
            stmt = stmt.order_by(None).order_by(new_col)

        :param \*clauses: a series of :class:`_expression.ColumnElement`
         constructs
         which will be used to generate an ORDER BY clause.

        .. seealso::

            :ref:`tutorial_order_by` - in the :ref:`unified_tutorial`

            :ref:`tutorial_order_by_label` - in the :ref:`unified_tutorial`

        Nr�c
3
�"�|]}
tj
tj|
�d�V
qd
S�rN)rr�r�OrderByRole�r
rr�r�r�rQ
���
�
�z,GenerativeSelect.order_by.<locals>.<genexpr>)rr8�NO_ARGr
�r�r4r6r�r�r��order_by�s$

�
�zGenerativeSelect.order_byc
r8)apReturn a new selectable with the given list of GROUP BY
        criterion applied.

        All existing GROUP BY settings can be suppressed by passing ``None``.

        e.g.::

            stmt = select(table.c.name, func.max(table.c.stat)).group_by(table.c.name)

        :param \*clauses: a series of :class:`_expression.ColumnElement`
         constructs
         which will be used to generate an GROUP BY clause.

        .. seealso::

            :ref:`tutorial_group_by_w_aggregates` - in the
            :ref:`unified_tutorial`

            :ref:`tutorial_order_by_label` - in the :ref:`unified_tutorial`

        Nr�c
3
r9r:)rr�r�GroupByRoler<r�r�r�rQ
@r=z,GenerativeSelect.group_by.<locals>.<genexpr>)rr8r>r
r?r�r�r��group_bys

�
�zGenerativeSelect.group_by)rZr�
)r�r�r�r�r�r�r�r�r�r�r�r\r�r�)r�rIru
)r
rcr�r�rrr�r�)rr�rr�r�r)rrrr�r�r�)rrrr�r�rr�)rrHr�r�rz
)r&rcr�r\)FF)r,rcr-r�r.r�r�r\)r)rcr�r\)r0r�r1r�r�r\)r4r5r6r7r�r\)&r�r�r�r�rr
rr	r
rrr
r�
r�
r5r�r�r�
r�rrrrrr'r(r*r+r&r/r)rXr�r3r8r>r@rBr�r�r�r�rWsn











�
C
	+

	
�




	



�7


2�.�r�default�compound_selectc@
seZ
dZejddd��
ZdS)�CompoundSelectStater��bTuple[Dict[str, ColumnElement[Any]], Dict[str, ColumnElement[Any]], Dict[str, ColumnElement[Any]]]c
C
s*|j�
�}
d
|
_dd�|
jD�
}|||fS)NFc
S
si|]}
|
j|
�qSr�r�
rb
r�r�r�r�
Vr�
z;CompoundSelectState._label_resolve_dict.<locals>.<dictcomp>)�	statementr�r|
rS
)r��hacky_subquery�
dr�r�r��_label_resolve_dictKs
	



z'CompoundSelectState._label_resolve_dictN�r�rF)r�r�r�rX�memoized_propertyrJr�r�r�r�rEIs
rEc
@
s$eZ
dZd
ZdZdZdZdZdZdS)�_CompoundSelectKeyword�UNIONz	UNION ALL�EXCEPTz
EXCEPT ALL�	INTERSECTz
INTERSECT ALLN)	r�r�r�rN�	UNION_ALLrO�
EXCEPT_ALLrP�
INTERSECT_ALLr�r�r�r�rMZs





rMc

s\
eZ
dZUd
ZdZdejfdejfdejfdejfdejfdejfd	ejfd
ejfdej	fg	e
jej
Zded
<ded<dZdZdNdd�ZedOdd��
ZedOdd��
ZedOdd��
ZedOdd��
ZedOdd��
ZedOd d!��
ZdPd#d$�Z	%dQdRd)d*�ZdSd.d/�ZdTd2d3�ZdUd4d5�Zd%d6�
dVdBdC�ZdW�f
dFdG�Z e!j"dXdIdJ��
Z#e!j"dYdLdM��
Z$�Z%S)Z�CompoundSelectaX
Forms the basis of ``UNION``, ``UNION ALL``, and other
    SELECT-based set operations.


    .. seealso::

        :func:`_expression.union`

        :func:`_expression.union_all`

        :func:`_expression.intersect`

        :func:`_expression.intersect_all`

        :func:`_expression.except`

        :func:`_expression.except_all`

    rD�selectsr	r
rrrrr
�keywordrSr�
zList[SelectBase]TFrMrgc
s(|
�_�f
d
d�|D�
�_
t���

dS)Nc

s&g|]}
tj
tj|
�d�j�d
�
�qS)rr�
)rr�r�CompoundElementRolerp
)r
�
sr�r�r�r
�s�
���z+CompoundSelect.__init__.<locals>.<listcomp>)rVrUrr�
)r�rVrUr�r�r�r�
�s


�zCompoundSelect.__init__r�c
G
�tt
jg
|
�
R�Sr�)rTrMrN�r�
rUr�r�r��
_create_union��zCompoundSelect._create_unionc
G
rYr�)rTrMrQrZr�r�r��_create_union_all�r\z CompoundSelect._create_union_allc
G
rYr�)rTrMrOrZr�r�r��_create_except�r\zCompoundSelect._create_exceptc
G
rYr�)rTrMrRrZr�r�r��_create_except_all�r\z!CompoundSelect._create_except_allc
G
rYr�)rTrMrPrZr�r�r��_create_intersect�r\z CompoundSelect._create_intersectc
G
rYr�)rTrMrSrZr�r�r��_create_intersect_all�r\z$CompoundSelect._create_intersect_allr�c

C
s|jd
�
�S�Nr
)rUr�r�r�r�r�r��r�zCompoundSelect._scalar_typeNrl
rm
rMcC
r)
r�)
r�ro
r�r�r�rp
�r�
zCompoundSelect.self_groupr�r�r�cC
s |jD]
}|�
|
�
r

d
SqdS�NTF)rUr�)r�r�rXr�r�r�r��s





�zCompoundSelect.is_derived_fromr�r�
cC
s<|j|
u
r|�
�}|jd
�|
�
}|g
|jdd�|_|S�Nr
r)rZrrUr�
)r�r��select_0r�r�r�r�
�s





zCompoundSelect.set_label_stylec
C
s>|jd
�
�}
|
|jd
u
r|��}|
g
|jdd�|_|Srd)rUr�r)r��
new_selectr�r�r�r��s




z*CompoundSelect._ensure_disambiguated_namesr�r�r�r�r�r�r<r�r�r�r�r�c
C
sZ|jd
}|j
tu
r|�|j
�
}tdd�dd�t|j�
D�
D�
�}|j|
||||d�
dS)Nr
c

s$g|]\�}
�f
dd
�|
jD�
�qS)c

sg|]}
t|
�
r|
�
��
�qSr�)r$�	_annotaterb
�
�ddr�r�r
�s
�
�zQCompoundSelect._generate_fromclause_column_proxies.<locals>.<listcomp>.<listcomp>)
r�)r
�stmtr�rhr�r
�s
���zFCompoundSelect._generate_fromclause_column_proxies.<locals>.<listcomp>c
S
s g|]\}
}d|
d
i
|f�qS)�weightrr�)r
�
irjr�r�r�r

s��r
)rUrZr�
r�
�zip�	enumerater�)r�r�r�r�r�r�re�extra_col_iteratorr�r�r�r��s"



���





�z2CompoundSelect._generate_fromclause_column_proxiesr�r�c
s&t��
|
�

|jD]}|�
|
�

q	dSr�)r�
r�rU)r�r�r,
r�
r�r�r�s



�z&CompoundSelect._refresh_for_new_columnr�c

C
�|jd
j
Srb)rUr�r�r�r�r�r�sz$CompoundSelect._all_selected_columnsr�c

C
rp)a\A :class:`_expression.ColumnCollection`
        representing the columns that
        this SELECT statement or similar construct returns in its result set,
        not including :class:`_sql.TextClause` constructs.

        For a :class:`_expression.CompoundSelect`, the
        :attr:`_expression.CompoundSelect.selected_columns`
        attribute returns the selected
        columns of the first SELECT statement contained within the series of
        statements within the set operation.

        .. seealso::

            :attr:`_sql.Select.selected_columns`

        .. versionadded:: 1.4

        r
)rUr�r�r�r�r�r�r2zCompoundSelect.selected_columns)rVrMrUrg)rUrgr�rTr�r�)rl
rm
r�rMr�)r�r�
r�rT)r�rTr�r�r�r�)&r�r�r�r�r�rTr}r�
dp_plain_dictr�r*rrIrur�
r
r �_auto_correlater�
rr[r]r^r_r`rar�rp
r�r�
r�r�r�rXr�r�r�rr�r�r�
r�rTcs^









���
�








�


�5

rTr,
c@
s
eZ
dZUd
Zerded<nGdd�de�ZeredTd	d
��
Z	dUdd�Z
edVdd��
ZedWdd��
ZedXdd��
Z
edYdd��
ZedZd#d$��
ZdYd%d&�Ze	'	'd[d\d.d/��
Z	'	'd[d]d3d4�Zd^d6d7�Zed_d:d;��
Zed`d=d>��
ZdadDdE�Ze�dF�
dbdNdO��
Ze�dF�
dcdRdS��
Zd'S)dr_)�from_clauses�froms�columns_plus_namesrJr:�default_select_compile_optionsc
@
seZ
dZgZd
S)z*SelectState.default_select_compile_optionsN)r�r�r��_cache_key_traversalr�r�r�r�rvIr�rGr?r��Type[SelectState]c
C
r�r�r��r�
rGr�r�r��get_plugin_classNr�zSelectState.get_plugin_classr(
�compiler�Optional[SQLCompiler]r�
rcK
s\|
|_|
j
|_|
jD]
}|�|j|j�
q
|
jr |�|
j|
j�
|�|
�
|_|
�d
�
|_	dSr)
rG�	_from_objrs�_memoized_select_entities�_setup_joins�_raw_columns�
_get_fromsrtrrru)r�rGr{r�
�memoized_entitiesr�r�r�r�
Ss



�
zSelectState.__init__rc

C
std
�
�
)NzLThe default SELECT construct without plugins does not implement this method.r�)
r�
r�r�r��_plugin_not_implementedhs
�z#SelectState._plugin_not_implemented�List[Dict[str, Any]]cC
sd
d�|
�d�
D�
S)Nc
S
s$g|]\}
}}
}}
||j|d��qS)
)r�r��exprr�)r
r�
r�r
r�r�r�r
ss�

��z7SelectState.get_column_descriptions.<locals>.<listcomp>F)
rrryr�r�r��get_column_descriptionsos�z#SelectState.get_column_descriptions�from_statement�roles.ReturnsRowsRoler�cC
r�r�)
r�)r�
rGr�r�r�r�r�~szSelectState.from_statementr�cC
s|�t
j�d
d�|
jD�
�
�
S)Nc
s
s�|]}
|
jV
qdSr�r3�r
r
r�r�r�rQ
�s�

�z7SelectState.get_columns_clause_froms.<locals>.<genexpr>)�_normalize_fromsr�
r�
�
from_iterabler�ryr�r�r��get_columns_clause_froms�s


��z$SelectState.get_columns_clause_fromsr�r�
�_LabelConventionCallablec
s8|
tu�|
t
u
�t��t��
	dd	��
��fdd�
}|S)
NrS
rW�col_namer�r�c
s�t|�
rdSt
rt|�
sJ�
�s|j}|durd
}|S�r |jn|j}|dur;d
}|�
vr4|�|�
�S�
�|�

|S|�
vrK�rF|j�S|j�S�
�|�

|S)N�	_no_label)	r(rr$�
_proxy_keyr�
�_anon_labelr��_anon_tq_key_label�_anon_key_label)rS
r�r��r�
rj�parmr�r��go�s0












���

z1SelectState._column_naming_convention.<locals>.gor�)rS
rWr�r�r�r�)r�
r�
rUrY
)r�
r�r�r�r�r�r`�s
�#z%SelectState._column_naming_conventionc	C
sNi|_}|j
t�|jtj�d
d�|
jD�
�
tj�dd�|
jD�
�
�|
|d�S)Nc
S
r�
r�r3r�r�r�r�r
����z*SelectState._get_froms.<locals>.<listcomp>c
S
r�
r�r3r�r�r�r�r
�r�)�check_statement�ambiguous_table_name_map)�_ambiguous_table_name_mapr�r�
r�
rsr�r��_where_criteria)r�rGr�r�r�r�r��s$




��
���
�zSelectState._get_fromsN�iterable_of_fromsr!
r��Optional[Select[Any]]r�� Optional[_AmbiguousTableNameMap]c
s�t�}g}|
D]!}t
|�
r|j|urt�d
�
�
|�|j�
s(|�|�

|�|j�

q|rStt	j
�dd�|D�
�
�
�
�
rC�
f
dd�|D�
}�du
rS���f
dd�|D�
�

|S)a0
given an iterable of things to select FROM, reduce them to what
        would actually render in the FROM clause of a SELECT.

        This does the job of checking for JOINs, tables, etc. that are in fact
        overlapping due to cloning, adaption, present in overlapping joins,
        etc.

        z-select() construct refers to itself as a FROMc
S
sg|]}
t|
j
�
�qSr�)r2r$
r�
r�r�r�r
��z0SelectState._normalize_froms.<locals>.<listcomp>c

sg|]}
|
�v
r|
�qSr�r�r�
)
�toremover�r�r
�r�
Nc
3
sN�|]"}
|
jD]}t
|�
r#|jr#|j�v
r|jt�t|j�
|j�fV
qqdSr�)r4r'r'
r�rErr�
)r
�item�fr)
r�r�r�rQ
�s$�
�
�
�
�

��
�z/SelectState._normalize_froms.<locals>.<genexpr>)rY
r&r
rW�InvalidRequestErrorrC
rA
r�
r�
r�
r�
r�)r�
r�r�r��seenrtr�r�)r�r�r�r��s0



�


�


��
�zSelectState._normalize_froms�explicit_correlate_froms�Optional[Sequence[FromClause]]�implicit_correlate_fromsc
s��j�
�j
jr�j
j��r��
�fd
d��
D�
�
�j
jdu
r)��
�fdd��
D�
�
�j
jrK�rKt�
�
dkrK�
�fdd��
D�
�
t�
�
sKt�d�j
�
�
�
S)a
Return the full list of 'from' clauses to be displayed.

        Takes into account a set of existing froms which may be
        rendered in the FROM clause of enclosing selects; this Select
        may want to leave those absent if it is automatically
        correlating.

        c

s(g|]}
|
tt�
�pd���v
r|
�qS�
r�r-r�
)r�rt�to_correlater�r�r
!s



����z2SelectState._get_display_froms.<locals>.<listcomp>Nc

s,g|]}
|
tt
�
�pd��jj�v
r|
�qSr�)r,r.rG�_correlate_exceptr�
)r�rtr�r�r�r
.s



����rc

sg|]}
|
t��
�v
r|
�qSr�r-r�
)rtr�r�r�r
?s

��z�Select statement '%r' returned no FROM clauses due to auto-correlation; specify correlate(<tables>) to control correlation manually.)rtrG�
_correlater�rrr�
rWr�)r�r�r�r�)r�rtr�r�r�r��_get_display_fromss4


�
�
���

��	zSelectState._get_display_fromsrFc
C
sVd
d�|jj
D�
}
dd�t|j�
D�
}|
��}|��D]
\}}|
�||�
q|
||fS)Nc
S
s i|]}
|
jr|
j
p|
j|
�qSr�)�_allow_label_resolverdr_
rb
r�r�r�r�
Ys
�
�zBSelectState._memoized_attr__label_resolve_dict.<locals>.<dictcomp>c
S
si|]	}
|
jr|
j
|
�qSr�)r�r_
rb
r�r�r�r�
^s
�
�)rGr�r9rt�copy�items�
setdefault)r��	with_cols�
only_froms�	only_colsr_
r#r�r�r��"_memoized_attr__label_resolve_dictRs��


z.SelectState._memoized_attr__label_resolve_dictrj�Optional[_JoinTargetElement]cC
s|
jr
|
jd
dSdS)N���r
)
r)r�
rjr�r�r��determine_last_joined_entityis
z(SelectState.determine_last_joined_entityr�cC
sd
d�t|
j
�
D�
S)Nc
S
r�
r�r�rb
r�r�r�r
tr�
z4SelectState.all_selected_columns.<locals>.<listcomp>)r9r�ryr�r�r��all_selected_columnsrsz SelectState.all_selected_columns�args�Tuple[_SetupJoinsElement, ...]�raw_columns�List[_ColumnsClauseElement]r�c	C
s
|
D]|\}}}}tr|du
rt
|t�sJ�
|d
}|d}|dur,|�||||�\}}	n|�|�
}	trEt
|t�s:J�
|du
rEt
|t�sEJ�
|	du
rj|j|	}
|jd|	�t|
||||d�f
|j|	dd�|_q|du
spJ�
|jt|||||d�f
|_qdS)Nr1
r2
r�
r)rr�
rK�"_join_determine_implicit_left_side�_join_place_explicit_left_sider�rsr3
)r�r�r�r.
r/
r�
�flagsr1
r2
�replace_from_obj_index�left_clauser�r�r�rvsP




��


�	








���
��


��zSelectState._setup_joinsr�r�
r�r.
�_JoinTargetElementr/
r�*Tuple[Optional[FromClause], Optional[int]]c
C
s�tj
j}d
}|j}|r!|�|||�}t|�
dkr |d}||}n>i}	|j}
t�tj�	dd�|
D�
�
tj�	dd�|
j
D�
�
�D]}d|	|<q?t|	���
}|�|||�}t|�
dkr_||d}t|�
dkrjt
�d�
�
|stt
�d	|f
�
�
||fS)
z�When join conditions don't express the left side explicitly,
        determine if an existing FROM or entity in this query
        can serve as the left hand side.

        Nrr
c
S
r�
r�r3r�r�r�r�r
�r�
zBSelectState._join_determine_implicit_left_side.<locals>.<listcomp>c
S
r�
r�r3r�r�r�r�r
�r�r�a
Can't determine which FROM clause to join from, there are multiple FROMS which can join to this entity. Please use the .select_from() method to establish an explicit left side, as well as providing an explicit ON clause if not present already to help resolve the ambiguity.z�Don't know how to join to %r. Please use the .select_from() method to establish an explicit left side, as well as providing an explicit ON clause if not present already to help resolve the ambiguity.)rXr�r�rs�find_left_clause_to_join_fromr�
rGr�
r�
r�r�r�
�keysrWr�)
r�r�r�
r.
r/
r�r�rs�indexes�	potentialrG�from_clause�all_clausesr�r�r�r��sR

�

�


�
���


�


�

��z.SelectState._join_determine_implicit_left_sider�r�cC
sXd}tj
j}t|j���
}|r|�|j|
�}ng}t|�
d
kr$t	�
d�
�
|r*|d}|S)NrzrCan't identify which entity in which to assign the left side of this join.   Please use a more specific ON clause.r
)rXr�r�r�
rG�_iterate_from_elements�#find_left_clause_that_matches_givenrsr�
rWr�)r�r�
r�r�rsr�r�r�r�r��s

�

�
z*SelectState._join_place_explicit_left_side)rGr?r�rx)rGr(
r{r|r�
r�r�r)rGr(
r�r�)rGr(
r�r�r�r�)rGr(
r�r�)r�r�
r�r�ru
)r�r!
r�r�r�r�r�r�)r�r�r�r�r�r�rK)rjr(
r�r�)rGr(
r�r�)r�r�r�r�r�r�)
r�r�r�
r�r.
r�r/
rr�r�)r�
r�r�r�)r�r�r��	__slots__rr
r:rvrrzr�
r�r�r�r�r`r�r�r�r�r�r�rrXr�r�r�r�r�r�r�r_<sJ








	

/
�9
�
D


;
G
r_c@
s4eZ
dZUd
Zded<ded<ded<d
d
d�ZdS)�_SelectFromElementsr�r�r�rr��Tuple[FromClause, ...]r}r��Iterator[FromClause]c
c
s��t�}
|j
D]}|jD]}||
vrq|
�|�

|V
qq|jD]}|jD]}||
vr,q%|
�|�

|V
q%q |jD]}||
vr@q9|
�|�

|V
q9dSr�)rY
r�r4r�r�r})r�r�r
r�r�r�r�r�#s,�








�







�





�z*_SelectFromElements._iterate_from_elementsN)r�r�)r�r�r�r�r
r�r�r�r�r�r�s



r�c@
sxeZ
dZUd
ZdZdejfdejfdejfgZ	de
d<de
d	<d
e
d<de
d<de
d<ejZ
ddd�Zeddd��
ZdS)�_MemoizedSelectEntitiesarepresents partial state from a Select object, for the case
    where Select.columns() has redefined the set of columns/entities the
    statement will be SELECTing from.  This object represents
    the entities from the SELECT before that transformation was applied,
    so that transformations that were made in terms of the SELECT at that
    time, such as join() as well as options(), can access the correct context.

    In previous SQLAlchemy versions, this wasn't needed because these
    constructs calculated everything up front, like when you called join()
    or options(), it did everything to figure out how that would translate
    into specific SQL constructs that would be ready to send directly to the
    SQL compiler when needed.  But as of
    1.4, all of that stuff is done in the compilation phase, during the
    "compile state" portion of the process, so that the work can all be
    cached.  So it needs to be able to resolve joins/options2 based on what
    the list of entities was when those methods were called.


    �memoized_select_entitiesr�r�
_with_optionsrSr�
zOptional[ClauseElement]r%
r�r�zTuple[ExecutableOption, ...]r�
rr�r\c
K
s8|j�
|j�
}d
d�|j��D�
|_|j�d|�|_|S)Nc
S
si|]\}
}|
|�qSr�r�)r
�
k�
vr�r�r�r�
cr�z2_MemoizedSelectEntities._clone.<locals>.<dictcomp>r%
)rG
rrV
r��getr%
)r�r�
rS
r�r�r�r+as


z_MemoizedSelectEntities._clone�select_stmtr(
r�cC
sT|
js|
j
r(t�}|
j|_|
j|_|
j
|_
|
j|f
7_g|
_d
|
_|
_
dSdSr#
)rr�r�r�r~)r�
r�r�r�r�r��_generate_for_statemenths





�z/_MemoizedSelectEntities._generate_for_statementN)r�
rr�r\)r�r(
r�r�)r�r�r�r�r�rTr}�dp_setup_join_tuple�dp_executable_optionsr�
r
rX�
EMPTY_DICT�_annotationsr+rr�r�r�r�r�r�;s


�




r�c
s*eZ
dZUd
ZdZdZded<dZded<ded	<d
Zded<dZ	d
ed<dZ
ded<dZded<dZd
ed<dZ
d
ed<dZded<dZdZejZded<d	ejfdejfdejfdejfdejfdejfdejfdejfdejfdejfdejfdejfdejfdejfd ejfdejfdejfd!ejfgejej e!j"e#j$e%j&e'j(Z)d"ed#<e)dej*fg
Z+d$ed%<d&ed'<e,d�d,d-��
Z-d�d0d1�Z.d�d3d4�Z/d�d8d9�Z0d�d;d<�Z1e2r�e3d�d@dA��
Z4e3d�dDdA��
Z4e3d�dEdA��
Z4d�dFdA�Z4d�dHdI�Z5e6d�dJdK��
Z7d�dOdP�Z8e9	d�d
d
dQ�d�dXdY��
Z:	d�d
dZ�
d�d]d^�Z;e9	d�d
d
dQ�d�d_d`��
Z<	d�d
dZ�
�
ddadb�Z=�
d
ddde�Z>e6e?�@dfdg��
d
dhdi��
�
ZAe6�
ddkdl��
ZBe6�
ddndo��
ZC�
ddrds�ZDeEf
�
d�f
dwdx�
ZF�
d�f
dzd{�ZGe9�
dd|d}��
ZH�
ddd��ZIe?�@d�d���
d	d�d���
ZJe?�Kd��
�
d
�
dd�d���
ZLe3d�d��
�
dd�d���
ZMe3d�d��
�
d
d�d���
ZMe3d�d��
�
dd�d���
ZMe3d�d��
�
dd�d���
ZMe3d�d��
�
dd�d���
ZMe3d�d��
�
dd�d���
ZMe3d�d��
�
dd�d���
ZMe3d�d��
�
dd�d���
ZMe3d
d��
�
dd�d���
ZMe9d
d��
�
dd�d���
ZMe6�
dd�d���
ZNeNZOe9�
dd�d���
ZPe9�
dd�d���
ZQe9�
dd�d���
ZRe9�
dd�d���
ZSe9�
dd�dĄ�
ZTe9�
dd�dƄ�
ZUeV�
dd�dɄ�
ZWeV�
dd�d˄�
ZX�
dd�d̈́ZYddΜ
�
dd�dڄZZ�
dd�d܄Z[	d��
dd�d�Z\�
d d�d�Z]�
d d�d�Z^�
d d�d�Z_�
d d�d�Z`�
d d�d�Za�
d d�d�Zb�ZcS(!
r+
a
Represents a ``SELECT`` statement.

    The :class:`_sql.Select` object is normally constructed using the
    :func:`_sql.select` function.  See that function for details.

    .. seealso::

        :func:`_sql.select`

        :ref:`tutorial_selecting_data` - in the 2.0 tutorial

    r,
r�r�rzTuple[TODO_Any, ...]r~r�r�Fr��	_distinctr�_distinct_onr�r�Nz Optional[Tuple[FromClause, ...]]r�r��_having_criteriar}Tr:�_compile_optionsrrr	r
rrr
rZrSr�
rvrwrx�_compile_state_factoryr�
rr�r(
c
K
st�
t�
}|j�|
�

|S)
z�Create a :class:`.Select` using raw ``__new__`` with no coercions.

        Used internally to build up :class:`.Select` constructs with
        pre-established state.

        )r+
rrV
r�
)r�
r�
rjr�r�r��_create_raw_select�s
	

zSelect._create_raw_select�entities�_ColumnsClauseArgument[Any]c

s"�f
d
d�|
D�
�_t
���

dS)z�Construct a new :class:`_expression.Select`.

        The public constructor for :class:`_expression.Select` is the
        :func:`_sql.select` function.

        c

�g|]}
tj
tj|
�d��qS�
rr��r
�entr�r�r�r
���
��z#Select.__init__.<locals>.<listcomp>N)r�rr�
�r�r�r�r�r�r�
�s
�zSelect.__init__r�c
C
s(|jst
S|jd
}
t|
j�
}|d
jSrb)r�rRr�
rc
r�)r�r�r\r�r�r�r��s








zSelect._scalar_type�criteria�_ColumnExpressionArgument[bool]r\c
G
s
|j|
�S)
z3A synonym for the :meth:`_sql.Select.where` method.�
�where)r�r�r�r�r��filter�s
z
Select.filter�FUnion[FromClause, _JoinTargetProtocol, ColumnElement[Any], TextClause]c
C
s@|jrt
�|�
j}
|
|�
}|du
r|S|jr|jd
S|jd
Srb)rr_rzr�r}r�)r��meth�_last_joined_entityr�r�r��_filter_by_zero�s

��




zSelect._filter_by_zeror��Select[Tuple[_MAYBE_ENTITY]]r�c


C
r�r�r�r�r�r�r�r�r�zSelect.scalar_subquery�Select[Tuple[_NOT_ENTITY]]�ScalarSelect[_NOT_ENTITY]c


C
r�r�r�r�r�r�r�r�r�c


C
r�r�r�r�r�r�r�r�r�c


C
r�r�r�r�r�r�r�r�rg
�kwargsc

s(|����f
d
d�|
�
�D�
}|j|�S)zWapply the given filtering criterion as a WHERE clause
        to this select.

        c

sg|]\}
}t�|
�|k�qSr�r/)r
r_
r#�
�from_entityr�r�r
s��z$Select.filter_by.<locals>.<listcomp>)r�r�r�)r�r�r6r�r�r��	filter_bys

�
zSelect.filter_byc
C
st�
|�
j}
|
|�
S)
a5Return a :term:`plugin-enabled` 'column descriptions' structure
        referring to the columns which are SELECTed by this statement.

        This attribute is generally useful when using the ORM, as an
        extended structure which includes information about mapped
        entities is returned.  The section :ref:`queryguide_inspection`
        contains more background.

        For a Core-only statement, the structure returned by this accessor
        is derived from the same objects that are returned by the
        :attr:`.Select.selected_columns` accessor, formatted as a list of
        dictionaries which contain the keys ``name``, ``type`` and ``expr``,
        which indicate the column expressions to be selected::

            >>> stmt = select(user_table)
            >>> stmt.column_descriptions
            [
                {
                    'name': 'id',
                    'type': Integer(),
                    'expr': Column('id', Integer(), ...)},
                {
                    'name': 'name',
                    'type': String(length=30),
                    'expr': Column('name', String(length=30), ...)}
            ]

        .. versionchanged:: 1.4.33 The :attr:`.Select.column_descriptions`
           attribute returns a structure for a Core-only set of entities,
           not just ORM-only entities.

        .. seealso::

            :attr:`.UpdateBase.entity_description` - entity information for
            an :func:`.insert`, :func:`.update`, or :func:`.delete`

            :ref:`queryguide_inspection` - ORM background

        )r_rzr��r�r�r�r�r��column_descriptionss)
zSelect.column_descriptionsrGr�r�cC
st�
|�
j}|||
�S)
a�Apply the columns which this :class:`.Select` would select
        onto another statement.

        This operation is :term:`plugin-specific` and will raise a not
        supported exception if this :class:`_sql.Select` does not select from
        plugin-enabled entities.


        The statement is typically either a :func:`_expression.text` or
        :func:`_expression.select` construct, and should return the set of
        columns appropriate to the entities represented by this
        :class:`.Select`.

        .. seealso::

            :ref:`orm_queryguide_selecting_text` - usage examples in the
            ORM Querying Guide

        )r_rzr�)r�rGr�r�r�r�r�Js

zSelect.from_statementr�
�targetrbr/
r�
r1
r2
cC
sPtj
tj|
|d
�}|du
rt�
tj|�}nd}|j||d||d�ff
7_|S)a�	Create a SQL JOIN against this :class:`_expression.Select`
        object's criterion
        and apply generatively, returning the newly resulting
        :class:`_expression.Select`.

        E.g.::

            stmt = select(user_table).join(
                address_table, user_table.c.id == address_table.c.user_id
            )

        The above statement generates SQL similar to:

        .. sourcecode:: sql

            SELECT user.id, user.name
            FROM user
            JOIN address ON user.id = address.user_id

        .. versionchanged:: 1.4 :meth:`_expression.Select.join` now creates
           a :class:`_sql.Join` object between a :class:`_sql.FromClause`
           source that is within the FROM clause of the existing SELECT,
           and a given target :class:`_sql.FromClause`, and then adds
           this :class:`_sql.Join` to the FROM clause of the newly generated
           SELECT statement.    This is completely reworked from the behavior
           in 1.3, which would instead create a subquery of the entire
           :class:`_expression.Select` and then join that subquery to the
           target.

           This is a **backwards incompatible change** as the previous behavior
           was mostly useless, producing an unnamed subquery rejected by
           most databases in any case.   The new behavior is modeled after
           that of the very successful :meth:`_orm.Query.join` method in the
           ORM, in order to support the functionality of :class:`_orm.Query`
           being available by using a :class:`_sql.Select` object with an
           :class:`_orm.Session`.

           See the notes for this change at :ref:`change_select_join`.


        :param target: target table to join towards

        :param onclause: ON clause of the join.  If omitted, an ON clause
         is generated automatically based on the :class:`_schema.ForeignKey`
         linkages between the two tables, if one can be unambiguously
         determined, otherwise an error is raised.

        :param isouter: if True, generate LEFT OUTER join.  Same as
         :meth:`_expression.Select.outerjoin`.

        :param full: if True, generate FULL OUTER join.

        .. seealso::

            :ref:`tutorial_select_join` - in the :doc:`/tutorial/index`

            :ref:`orm_queryguide_joins` - in the :ref:`queryguide_toplevel`

            :meth:`_expression.Select.join_from`

            :meth:`_expression.Select.outerjoin`

        rNr�
)rr�r�JoinTargetRoler�
r)r�r�r/
r1
r2
�join_target�onclause_elementr�r�r�r5
csH
�



��zSelect.join)
r2
�from_rac
C
s|j|
||d
|d�S)a
Create a SQL LEFT OUTER JOIN against this
        :class:`_expression.Select` object's criterion and apply generatively,
        returning the newly resulting :class:`_expression.Select`.

        Usage is the same as that of :meth:`_selectable.Select.join_from`.

        T�r/
r1
r2
)
�	join_from)r�r
r�r/
r2
r�r�r��outerjoin_from�s

�zSelect.outerjoin_fromcC
sbtj
tj|
|d
�}
tj
tj||d
�}|du
rt�
tj|�}nd}|j|||
||d�ff
7_|S)aCreate a SQL JOIN against this :class:`_expression.Select`
        object's criterion
        and apply generatively, returning the newly resulting
        :class:`_expression.Select`.

        E.g.::

            stmt = select(user_table, address_table).join_from(
                user_table, address_table, user_table.c.id == address_table.c.user_id
            )

        The above statement generates SQL similar to:

        .. sourcecode:: sql

            SELECT user.id, user.name, address.id, address.email, address.user_id
            FROM user JOIN address ON user.id = address.user_id

        .. versionadded:: 1.4

        :param from\_: the left side of the join, will be rendered in the
         FROM clause and is roughly equivalent to using the
         :meth:`.Select.select_from` method.

        :param target: target table to join towards

        :param onclause: ON clause of the join.

        :param isouter: if True, generate LEFT OUTER join.  Same as
         :meth:`_expression.Select.outerjoin`.

        :param full: if True, generate FULL OUTER join.

        .. seealso::

            :ref:`tutorial_select_join` - in the :doc:`/tutorial/index`

            :ref:`orm_queryguide_joins` - in the :ref:`queryguide_toplevel`

            :meth:`_expression.Select.join`

        rNr�
)rr�rr
r�r�
r)r�r
r�r/
r1
r2
r�rr�r�r�r�s"9
�
�



��zSelect.join_fromc
C
s|j|
|d
|d�S)a�Create a left outer join.

        Parameters are the same as that of :meth:`_expression.Select.join`.

        .. versionchanged:: 1.4 :meth:`_expression.Select.outerjoin` now
           creates a :class:`_sql.Join` object between a
           :class:`_sql.FromClause` source that is within the FROM clause of
           the existing SELECT, and a given target :class:`_sql.FromClause`,
           and then adds this :class:`_sql.Join` to the FROM clause of the
           newly generated SELECT statement.    This is completely reworked
           from the behavior in 1.3, which would instead create a subquery of
           the entire
           :class:`_expression.Select` and then join that subquery to the
           target.

           This is a **backwards incompatible change** as the previous behavior
           was mostly useless, producing an unnamed subquery rejected by
           most databases in any case.   The new behavior is modeled after
           that of the very successful :meth:`_orm.Query.join` method in the
           ORM, in order to support the functionality of :class:`_orm.Query`
           being available by using a :class:`_sql.Select` object with an
           :class:`_orm.Session`.

           See the notes for this change at :ref:`change_select_join`.

        .. seealso::

            :ref:`tutorial_select_join` - in the :doc:`/tutorial/index`

            :ref:`orm_queryguide_joins` - in the :ref:`queryguide_toplevel`

            :meth:`_expression.Select.join`

        Tr)
r5
)r�r�r/
r2
r�r�r�r6
s)zSelect.outerjoin�Sequence[FromClause]c

C
s|�|d
��
�S)aGCompute the final displayed list of :class:`_expression.FromClause`
        elements.

        This method will run through the full computation required to
        determine what FROM elements will be displayed in the resulting
        SELECT statement, including shadowing individual tables with
        JOIN objects, as well as full computation for ORM use cases including
        eager loading clauses.

        For ORM use, this accessor returns the **post compilation**
        list of FROM objects; this collection will include elements such as
        eagerly loaded tables and joins.  The objects will **not** be
        ORM enabled and not work as a replacement for the
        :meth:`_sql.Select.select_froms` collection; additionally, the
        method is not well performing for an ORM enabled statement as it
        will incur the full ORM construction process.

        To retrieve the FROM list that's implied by the "columns" collection
        passed to the :class:`_sql.Select` originally, use the
        :attr:`_sql.Select.columns_clause_froms` accessor.

        To select from an alternative set of columns while maintaining the
        FROM list, use the :meth:`_sql.Select.with_only_columns` method and
        pass the
        :paramref:`_sql.Select.with_only_columns.maintain_column_froms`
        parameter.

        .. versionadded:: 1.4.23 - the :meth:`_sql.Select.get_final_froms`
           method replaces the previous :attr:`_sql.Select.froms` accessor,
           which is deprecated.

        .. seealso::

            :attr:`_sql.Select.columns_clause_froms`

        N)r�r�r�r�r�r��get_final_fromsIs&zSelect.get_final_fromsz1.4.23zqThe :attr:`_expression.Select.froms` attribute is moved to the :meth:`_expression.Select.get_final_froms` method.c

C
r�)
zYReturn the displayed list of :class:`_expression.FromClause`
        elements.


        )
rr�r�r�r�rtqszSelect.fromsr�c

C
st�
|�
�|�
S)
a�
Return the set of :class:`_expression.FromClause` objects implied
        by the columns clause of this SELECT statement.

        .. versionadded:: 1.4.23

        .. seealso::

            :attr:`_sql.Select.froms` - "final" FROM list taking the full
            statement into account

            :meth:`_sql.Select.with_only_columns` - makes use of this
            collection to set up a new FROM list

        )r_rzr�r�r�r�r��columns_clause_fromss

�zSelect.columns_clause_fromsr�c

C
s
t|j
�
S)
a0
An iterator of all :class:`_expression.ColumnElement`
        expressions which would
        be rendered into the columns clause of the resulting SELECT statement.

        This method is legacy as of 1.4 and is superseded by the
        :attr:`_expression.Select.exported_columns` collection.

        )�iterr�r�r�r�r��
inner_columns�s
zSelect.inner_columnsr�r�cC
s8|
du
r||
jvrd
S|�
�D]
}|�|
�
r
d
SqdSrc)rA
r�r�)r�r�r�
r�r�r�r��s




�zSelect.is_derived_fromr�
r�r�c
s�tt
�t|j�t|j�td
d�|jD�
���
}��
fdd�|D�
���
fdd�|jD�
}dd����D�
�	|�
�	|�
}t
|�
t
|�
|_d�f
dd�}|�
d<t�jd�dd��
�
�

|�
�
dS)Nc
S
sg|]}
|
d�qS)
r
r�r�r�r�r�r
�r�
z*Select._copy_internals.<locals>.<listcomp>c

r�
r�r�r�
r�
r�r�r�
�r�
z*Select._copy_internals.<locals>.<dictcomp>c

sg|]
}
�|
f
i�
�
�
�qSr�r�r�
r�
r�r�r
�sc
S
sh|]	}
t|
t
�r|
�qSr�)r�
r3
r�
r�r�r�r�
�r
z)Select._copy_internals.<locals>.<setcomp>r�
r�
r�
rr�r�c

r�
r�r�
r�
r�
r�r�r�
�r�
z'Select._copy_internals.<locals>.replacer�
)
r})r�
�
omit_attrsr�
r�)rY
r�
r�
r4r�r�rr}r�
�
differencer
r�
r�
r�
)r�r�
r�
r�
�existing_from_obj�	add_fromsr�
r�
r�
r�r�
�s$



��

�	zSelect._copy_internals�Iterable[ClauseElement]c

s"t�
t�jdd
di
|
�
�
|���S)Nr
)r}r�r�r�)r�
r�
r�
�get_childrenr�r�r�
r�r�r�s



���zSelect.get_childrenc

s&���
�j
�f
d
d�|
D�
�_
�S)a�Return a new :func:`_expression.select` construct with
        the given entities appended to its columns clause.

        E.g.::

            my_select = my_select.add_columns(table.c.new_column)

        The original expressions in the columns clause remain in place.
        To replace the original expressions with new ones, see the method
        :meth:`_expression.Select.with_only_columns`.

        :param \*entities: column, table, or other entity expressions to be
         added to the columns clause

        .. seealso::

            :meth:`_expression.Select.with_only_columns` - replaces existing
            expressions rather than appending.

            :ref:`orm_queryguide_select_multiple_entities` - ORM-centric
            example

        c

r�r�r�)r
r�r�r�r�r

r�z&Select.add_columns.<locals>.<listcomp>)r�
r�r�r�r�r��add_columns�s

�zSelect.add_columns�%Iterable[_ColumnsClauseArgument[Any]]c
s�f
d
d�t�
|
�
D�
�_dS)Nc

r�r�r�r�r�r�r�r
r�z(Select._set_entities.<locals>.<listcomp>)rXr�r�r�r�r�r��
_set_entitiess
�zSelect._set_entitiesr�z�The :meth:`_expression.Select.column` method is deprecated and will be removed in a future release.  Please use :meth:`_expression.Select.add_columns`r�cC
s
|�|
�
S)
a�
Return a new :func:`_expression.select` construct with
        the given column expression added to its columns clause.

        E.g.::

            my_select = my_select.column(table.c.new_column)

        See the documentation for
        :meth:`_expression.Select.with_only_columns`
        for guidelines on adding /replacing the columns of a
        :class:`_expression.Select` object.

        )
rr�r�r�r�r�s
z
Select.columnr��
only_synonymscC
s0|jt
jjj|jg
|j|j�
Rd
|
i
�
�}|S)a"Return a new :func:`_expression.select` construct with redundantly
        named, equivalently-valued columns removed from the columns clause.

        "Redundant" here means two columns where one refers to the
        other either based on foreign key, or via a simple equality
        comparison in the WHERE clause of the statement.   The primary purpose
        of this method is to automatically construct a select statement
        with all uniquely-named columns, without the need to use
        table-qualified labels as
        :meth:`_expression.Select.set_label_style`
        does.

        When columns are omitted based on foreign key, the referred-to
        column is the one that's kept.  When columns are omitted based on
        WHERE equivalence, the first column in the columns clause is the
        one that's kept.

        :param only_synonyms: when True, limit the removal of columns
         to those which have the same name as the equivalent.   Otherwise,
         all columns that are equivalent to another are removed.

        r)�with_only_columnsrXr�r�r�
r�r�r})r�r�wocr�r�r�r�
2s

�
���zSelect.reduce_columns.)
�maintain_column_froms�
_Select__ent0�
_TCCA[_T0]r�Select[Tuple[_T0]]c

C
r�r�r�)r�rrr�r�r�rYr��Select.with_only_columns�
_Select__ent1�
_TCCA[_T1]�Select[Tuple[_T0, _T1]]c

C
r�r�r�)r�rrrr�r�r�r^s�
_Select__ent2�
_TCCA[_T2]�Select[Tuple[_T0, _T1, _T2]]c

C
r�r�r�)r�rrrrr�r�r�rgs�
_Select__ent3�
_TCCA[_T3]�!Select[Tuple[_T0, _T1, _T2, _T3]]c

C
r�r�r�)r�rrrr!rr�r�r�rqs	�
_Select__ent4�
_TCCA[_T4]�&Select[Tuple[_T0, _T1, _T2, _T3, _T4]]c

C
r�r�r�)r�rrrr!r$rr�r�r�r|s
�
_Select__ent5�
_TCCA[_T5]�+Select[Tuple[_T0, _T1, _T2, _T3, _T4, _T5]]c

C
r�r�r�)r�rrrr!r$r'rr�r�r�r�s�
_Select__ent6�
_TCCA[_T6]�0Select[Tuple[_T0, _T1, _T2, _T3, _T4, _T5, _T6]]c
	
C
r�r�r�)	r�rrrr!r$r'r*rr�r�r�r�s�
_Select__ent7�
_TCCA[_T7]�5Select[Tuple[_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7]]c	


C
r�r�r�)
r�rrrr!r$r'r*r-rr�r�r�r�s
�_Select__kwc


O
r�r�r��r�rr�r0r�r�r�r�sc

O
sT|rt��
|�
�
|
r|jj|g
|j�
R�
t�|�

d
d�t�dd|�D�
|_	|S)a�Return a new :func:`_expression.select` construct with its columns
        clause replaced with the given entities.

        By default, this method is exactly equivalent to as if the original
        :func:`_expression.select` had been called with the given entities.
        E.g. a statement::

            s = select(table1.c.a, table1.c.b)
            s = s.with_only_columns(table1.c.b)

        should be exactly equivalent to::

            s = select(table1.c.b)

        In this mode of operation, :meth:`_sql.Select.with_only_columns`
        will also dynamically alter the FROM clause of the
        statement if it is not explicitly stated.
        To maintain the existing set of FROMs including those implied by the
        current columns clause, add the
        :paramref:`_sql.Select.with_only_columns.maintain_column_froms`
        parameter::

            s = select(table1.c.a, table2.c.b)
            s = s.with_only_columns(table1.c.a, maintain_column_froms=True)

        The above parameter performs a transfer of the effective FROMs
        in the columns collection to the :meth:`_sql.Select.select_from`
        method, as though the following were invoked::

            s = select(table1.c.a, table2.c.b)
            s = s.select_from(table1, table2).with_only_columns(table1.c.a)

        The :paramref:`_sql.Select.with_only_columns.maintain_column_froms`
        parameter makes use of the :attr:`_sql.Select.columns_clause_froms`
        collection and performs an operation equivalent to the following::

            s = select(table1.c.a, table2.c.b)
            s = s.select_from(*s.columns_clause_froms).with_only_columns(table1.c.a)

        :param \*entities: column expressions to be used.

        :param maintain_column_froms: boolean parameter that will ensure the
         FROM list implied from the current columns clause will be transferred
         to the :meth:`_sql.Select.select_from` method first.

         .. versionadded:: 1.4.23

        c
S
r�r�r�rb
r�r�r�r
r�z,Select.with_only_columns.<locals>.<listcomp>r�r)
r!�_assert_no_memoizationsr�
�non_generativerr�r�r�!_expression_collection_was_a_listr�r1r�r�r�r�s 8


�
�

��rc

C
st�
|j�
S)
a
Return the completed WHERE clause for this
        :class:`_expression.Select` statement.

        This assembles the current collection of WHERE criteria
        into a single :class:`_expression.BooleanClauseList` construct.


        .. versionadded:: 1.4

        )rG�_construct_for_whereclauser�r�r�r�r��whereclauses

�zSelect.whereclauser6c
G
s@t|j
t�sJ�
|
D]}tjtj||d
�}|j
|f
7_
q
|S)z�Return a new :func:`_expression.select` construct with
        the given expression added to
        its WHERE clause, joined to the existing clause via AND, if any.

        r)r�
r�r
rr�r�WhereHavingRole)r�r6�	criterion�where_criteriar�r�r�r�s

�
zSelect.where�havingc
G
s0|
D]}tj
tj||d
�}|j|f
7_q|S)z�Return a new :func:`_expression.select` construct with
        the given expression added to
        its HAVING clause, joined to the existing clause via AND, if any.

        r)rr�rr7r�)r�r:r8�having_criteriar�r�r�r:0s

�
z
Select.havingr�r�c

s6|
rd
�_�j
t�f
dd�|
D�
�
�_
�Sd
�_�S)a.Return a new :func:`_expression.select` construct which
        will apply DISTINCT to the SELECT statement overall.

        E.g.::

            from sqlalchemy import select

            stmt = select(users_table.c.id, users_table.c.name).distinct()

        The above would produce an statement resembling:

        .. sourcecode:: sql

            SELECT DISTINCT user.id, user.name FROM user

        The method also accepts an ``*expr`` parameter which produces the
        PostgreSQL dialect-specific ``DISTINCT ON`` expression.  Using this
        parameter on other backends which don't support this syntax will
        raise an error.

        :param \*expr: optional column expressions.  When present,
         the PostgreSQL dialect will render a ``DISTINCT ON (<expressions>)``
         construct.  A deprecation warning and/or :class:`_exc.CompileError`
         will be raised on other backends.

         .. deprecated:: 1.4 Using \*expr in other dialects is deprecated
            and will raise :class:`_exc.CompileError` in a future version.

        Tc
3
r9r:)rr�r�ByOfRole)r
�
er�r�r�rQ
`s
��
�z"Select.distinct.<locals>.<genexpr>)r�r�r
)r�r�r�r�r��distinct?s

��
zSelect.distinctrtc

s$�jt
�f
d
d�|
D�
�
7_�S)aReturn a new :func:`_expression.select` construct with the
        given FROM expression(s)
        merged into its list of FROM objects.

        E.g.::

            table1 = table("t1", column("a"))
            table2 = table("t2", column("b"))
            s = select(table1.c.a).select_from(
                table1.join(table2, table1.c.a == table2.c.b)
            )

        The "from" list is a unique set on the identity of each element,
        so adding an already present :class:`_schema.Table`
        or other selectable
        will have no effect.   Passing a :class:`_expression.Join` that refers
        to an already present :class:`_schema.Table`
        or other selectable will have
        the effect of concealing the presence of that selectable as
        an individual element in the rendered FROM list, instead
        rendering it into a JOIN clause.

        While the typical purpose of :meth:`_expression.Select.select_from`
        is to
        replace the default, derived FROM clause with a join, it can
        also be called with individual table elements, multiple times
        if desired, in the case that the FROM clause cannot be fully
        derived from the columns clause::

            select(func.count("*")).select_from(table1)

        c
3
r9r:�rr�rr
)r
r�r�r�r�rQ
�r=z%Select.select_from.<locals>.<genexpr>)r}r
)r�rtr�r�r�r�
hs#�zSelect.select_from�fromclauses�0Union[Literal[None, False], _FromClauseArgument]c
G
sTd
|_|
r|
ddvrt
|
�
dkrt�d�
�
d|_|S|jtdd�|
D�
�
|_|S)	a�Return a new :class:`_expression.Select`
        which will correlate the given FROM
        clauses to that of an enclosing :class:`_expression.Select`.

        Calling this method turns off the :class:`_expression.Select` object's
        default behavior of "auto-correlation".  Normally, FROM elements
        which appear in a :class:`_expression.Select`
        that encloses this one via
        its :term:`WHERE clause`, ORDER BY, HAVING or
        :term:`columns clause` will be omitted from this
        :class:`_expression.Select`
        object's :term:`FROM clause`.
        Setting an explicit correlation collection using the
        :meth:`_expression.Select.correlate`
        method provides a fixed list of FROM objects
        that can potentially take place in this process.

        When :meth:`_expression.Select.correlate`
        is used to apply specific FROM clauses
        for correlation, the FROM elements become candidates for
        correlation regardless of how deeply nested this
        :class:`_expression.Select`
        object is, relative to an enclosing :class:`_expression.Select`
        which refers to
        the same FROM object.  This is in contrast to the behavior of
        "auto-correlation" which only correlates to an immediate enclosing
        :class:`_expression.Select`.
        Multi-level correlation ensures that the link
        between enclosed and enclosing :class:`_expression.Select`
        is always via
        at least one WHERE/ORDER BY/HAVING/columns clause in order for
        correlation to take place.

        If ``None`` is passed, the :class:`_expression.Select`
        object will correlate
        none of its FROM entries, and all will render unconditionally
        in the local FROM clause.

        :param \*fromclauses: one or more :class:`.FromClause` or other
         FROM-compatible construct such as an ORM mapped entity to become part
         of the correlate collection; alternatively pass a single value
         ``None`` to remove all existing correlations.

        .. seealso::

            :meth:`_expression.Select.correlate_except`

            :ref:`tutorial_scalar_subquery`

        Fr
�FNrzKadditional FROM objects not accepted when passing None/False to correlate()r�c
s
��|]
}
t�
tj|
�V
qdSr�r?r�
r�r�r�rQ
���

�z#Select.correlate.<locals>.<genexpr>)rrr�
rWr�r�r
�r�r@r�r�r�r�
�s;



��
�zSelect.correlatec
G
sXd
|_|
r|
ddvrt
|
�
dkrt�d�
�
d|_|S|jpdtdd�|
D�
�
|_|S)	a�Return a new :class:`_expression.Select`
        which will omit the given FROM
        clauses from the auto-correlation process.

        Calling :meth:`_expression.Select.correlate_except` turns off the
        :class:`_expression.Select` object's default behavior of
        "auto-correlation" for the given FROM elements.  An element
        specified here will unconditionally appear in the FROM list, while
        all other FROM elements remain subject to normal auto-correlation
        behaviors.

        If ``None`` is passed, or no arguments are passed,
        the :class:`_expression.Select` object will correlate all of its
        FROM entries.

        :param \*fromclauses: a list of one or more
         :class:`_expression.FromClause`
         constructs, or other compatible constructs (i.e. ORM-mapped
         classes) to become part of the correlate-exception collection.

        .. seealso::

            :meth:`_expression.Select.correlate`

            :ref:`tutorial_scalar_subquery`

        Fr
rBrzRadditional FROM objects not accepted when passing None/False to correlate_except()r�c
s
rCr�r?r�
r�r�r�rQ
rDz*Select.correlate_except.<locals>.<genexpr>)rrr�
rWr�r�r
rEr�r�r��correlate_except�s!



��
�zSelect.correlate_exceptr�c

s2td
t
�|j�
��t�f
dd�|jD�
�
}
|
��S)a�A :class:`_expression.ColumnCollection`
        representing the columns that
        this SELECT statement or similar construct returns in its result set,
        not including :class:`_sql.TextClause` constructs.

        This collection differs from the :attr:`_expression.FromClause.columns`
        collection of a :class:`_expression.FromClause` in that the columns
        within this collection cannot be directly nested inside another SELECT
        statement; a subquery must be applied first which provides for the
        necessary parenthesization required by SQL.

        For a :func:`_expression.select` construct, the collection here is
        exactly what would be rendered inside the "SELECT" statement, and the
        :class:`_expression.ColumnElement` objects are directly present as they
        were given, e.g.::

            col1 = column("q", Integer)
            col2 = column("p", Integer)
            stmt = select(col1, col2)

        Above, ``stmt.selected_columns`` would be a collection that contains
        the ``col1`` and ``col2`` objects directly. For a statement that is
        against a :class:`_schema.Table` or other
        :class:`_expression.FromClause`, the collection will use the
        :class:`_expression.ColumnElement` objects that are in the
        :attr:`_expression.FromClause.c` collection of the from element.

        A use case for the :attr:`_sql.Select.selected_columns` collection is
        to allow the existing columns to be referenced when adding additional
        criteria, e.g.::

            def filter_on_id(my_select, id):
                return my_select.where(my_select.selected_columns["id"] == id)


            stmt = select(MyModel)

            # adds "WHERE id=:param" to the statement
            stmt = filter_on_id(stmt, 42)

        .. note::

            The :attr:`_sql.Select.selected_columns` collection does not
            include expressions established in the columns clause using the
            :func:`_sql.text` construct; these are silently omitted from the
            collection. To use plain textual column expressions inside of a
            :class:`_sql.Select` construct, use the :func:`_sql.literal_column`
            construct.


        .. versionadded:: 1.4

        zCallable[[Any], str]c

s g|]}
t|
�
r�|
�
|
f�qSr�r#rb
�
�convr�r�r
Ps
�

�z+Select.selected_columns.<locals>.<listcomp>)rr_r`rZr;r�rX
)r��ccr�rGr�r�s>


�

��zSelect.selected_columnsc
C
st�
|�
j}
t|
|�
�
Sr�)r_rzr�r�
r�r�r�r�r�Xs
zSelect._all_selected_columnsc

C
s|jt
ur
|�t�
}|Sr�)rZr�
r�
r�
r�r�r�r�r�]s




z"Select._ensure_disambiguated_namesr�r�r�r�r�r�r<r�r�r�r�c

sV|r|}��
�fd
d�t|�
d�
|�D�
}n��
�fdd�|�
d�
D�
}|�|�

dS)zYGenerate column proxies to place in the exported ``.c``
        collection of a subquery.c

s:g|]\\}
}}}}}t|�
r|j
�||
d|�
�d
��qS)T)r_
r��name_is_truncatable�compound_select_colsr�r��r$rM
)r
rTrUrVrS
rX�
extra_cols�r�r�r�r�r�r
rs*






�







��z>Select._generate_fromclause_column_proxies.<locals>.<listcomp>Fc


s4g|]\}
}}}}t|�
r|j
�||
d�
�d
��qS)T)r_
r�rJr�r�rL)r
rTrUrVrS
rXrNr�r�r
�s$	




�






��N)rmrrrR
)r�r�r�r�r�r�ro�proxr�rNr�r�bs



���z*Select._generate_fromclause_column_proxiesc

C
s|jpt
|jj�
Sr�)r+r�rr6r�r�r�r��_needs_parens_for_grouping�s

�z!Select._needs_parens_for_groupingrl
rm
�*Union[SelectStatementGrouping[Self], Self]cC
st|
t
�r|��s|St|�
S)
a@
Return a 'grouping' construct as per the
        :class:`_expression.ClauseElement` specification.

        This produces an element that can be embedded in an expression. Note
        that this method is called automatically as needed when constructing
        expressions and should not require explicit use.

        )r�
rTrPr�ro
r�r�r�rp
�s��zSelect.self_grouprB
rgrTc
G
�tj
|g
|
�
R�S)
a�
Return a SQL ``UNION`` of this select() construct against
        the given selectables provided as positional arguments.

        :param \*other: one or more elements with which to create a
         UNION.

         .. versionchanged:: 1.4.28

            multiple elements are now accepted.

        :param \**kwargs: keyword arguments are forwarded to the constructor
         for the newly created :class:`_sql.CompoundSelect` object.

        )rTr[rD
r�r�r�r
��zSelect.unionc
G
rR)
a�
Return a SQL ``UNION ALL`` of this select() construct against
        the given selectables provided as positional arguments.

        :param \*other: one or more elements with which to create a
         UNION.

         .. versionchanged:: 1.4.28

            multiple elements are now accepted.

        :param \**kwargs: keyword arguments are forwarded to the constructor
         for the newly created :class:`_sql.CompoundSelect` object.

        )rTr]rD
r�r�r�rP�rSzSelect.union_allc
G
rR)
a.
Return a SQL ``EXCEPT`` of this select() construct against
        the given selectable provided as positional arguments.

        :param \*other: one or more elements with which to create a
         UNION.

         .. versionchanged:: 1.4.28

            multiple elements are now accepted.

        )rTr^rD
r�r�r��except_��zSelect.except_c
G
rR)
a3
Return a SQL ``EXCEPT ALL`` of this select() construct against
        the given selectables provided as positional arguments.

        :param \*other: one or more elements with which to create a
         UNION.

         .. versionchanged:: 1.4.28

            multiple elements are now accepted.

        )rTr_rD
r�r�r��
except_all�rUzSelect.except_allc
G
rR)
a�
Return a SQL ``INTERSECT`` of this select() construct against
        the given selectables provided as positional arguments.

        :param \*other: one or more elements with which to create a
         UNION.

         .. versionchanged:: 1.4.28

            multiple elements are now accepted.

        :param \**kwargs: keyword arguments are forwarded to the constructor
         for the newly created :class:`_sql.CompoundSelect` object.

        )rTr`rD
r�r�r��	intersect
rSzSelect.intersectc
G
rR)
a�
Return a SQL ``INTERSECT ALL`` of this select() construct
        against the given selectables provided as positional arguments.

        :param \*other: one or more elements with which to create a
         UNION.

         .. versionchanged:: 1.4.28

            multiple elements are now accepted.

        :param \**kwargs: keyword arguments are forwarded to the constructor
         for the newly created :class:`_sql.CompoundSelect` object.

        )rTrarD
r�r�r��
intersect_allrSzSelect.intersect_all)r�
rr�r(
)r�r�r�)r�r�r�r\)r�r�)r�r�r�r�)r�r�r�r�r�)r�rr�r\)r�r)rGr�r�r�r�)
r�rbr/
r�
r1
r�r2
r�r�r\)
r
rar�rbr/
r�
r2
r�r�r\)r
rar�rbr/
r�
r1
r�r2
r�r�r\)r�rbr/
r�
r2
r�r�r\)r�rr�r�r�r)r�
rr�r)r�r�r�r(
)r�rr�r�)r�r�r�r(
)
T)rr�r�r(
)rrrr�r�r)rrrrrr�r�r)
rrrrrrrr�r�r )rrrrrrr!r"rr�r�r#)rrrrrrr!r"r$r%rr�r�r&)rrrrrrr!r"r$r%r'r(rr�r�r))rrrrrrr!r"r$r%r'r(r*r+rr�r�r,)rrrrrrr!r"r$r%r'r(r*r+r-r.rr�r�r/)r�r�rr�r0rr�r(
)r�r)r6r�r�r\)r:r�r�r\)r�r�r�r\�rtrar�r\�r@rAr�r\r�rr
r�rz
)rl
rm
r�rQ)rB
rgr�rT)dr�r�r�r�r�rr
r~r�r�r�r�r�r�r}rrr�r_rvr�rTr}�dp_memoized_select_entities�dp_clauseelement_tupler�rrqrr~rIrur�r�r
r

r
r
r*rr?�_executable_traverse_internalsr�
�dp_has_cache_keyrwrr�r�
r�r�r�rrr�r�r�r�r�r5r5
rrr6
rrXr�rtrr	r�r+r�
rrrr�r�r�
rr6�_whereclauser�r:r>r�
r�
rFrYr�r�r�r�rPrp
r
rPrTrVrWrXrr�r�r�
r�r+
usf

	










�
�














�������
� 
�












+�
�]���
�P��+(


�


�:	
$


�
&���	�
	�
��
���O



(
*
H
/
K
�A�r+
c@
s�eZ
dZUd
ZdejfdejfgZded<gZ	ded<dZ
es!d	ZdZ
d
ed<d0d
d�Zd1dd�Zd2dd�Zd3dd�Zed4dd��
ZeZed5d d!��
Zd6d7d%d&�ZerXd8d(d)�Zed9d,d-��
Zed9d.d/��
Zd"S):r�a�
Represent a scalar subquery.


    A :class:`_sql.ScalarSelect` is created by invoking the
    :meth:`_sql.SelectBase.scalar_subquery` method.   The object
    then participates in other SQL expressions as a SQL column expression
    within the :class:`_sql.ColumnElement` hierarchy.

    .. seealso::

        :meth:`_sql.SelectBase.scalar_subquery`

        :ref:`tutorial_scalar_subquery` - in the 2.0 tutorial

    r
r�rSr�
r�r4TFr�r�r�cC
s|
|_|
�
�|_|
j|_dSr�)r
r�r��_propagate_attrsr�r�r�r�r�
Hs



zScalarSelect.__init__�attrr�rcC
st|j
|
�Sr�)rF
r
)r�rar�r�r��__getattr__Mr�zScalarSelect.__getattr__r�c

C
s|j|j
d
�S)N�r
r�rcr�r�r�r�r�Pr�zScalarSelect.__getstate__r�cC
s|
d
|_|
d|_
dS)Nr
r�rcr�r�r�r�r�Ss


zScalarSelect.__setstate__rc

C
s
t�
d
�
�
)NzcScalar Select expression has no columns; use this object directly within a column-level expression.)rWr�r�r�r�r�r�Ws
�zScalarSelect.columnsr�
r�r\cC
std
|j
��|
�
|_
|S)zuApply a WHERE clause to the SELECT statement referred to
        by this :class:`_expression.ScalarSelect`.

        r(
)rr
r�)r�r�
r�r�r�r�a�
zScalarSelect.whereNrl
rm
c
C
r�r�r�ro
r�r�r�rp
jr�zScalarSelect.self_groupr(
c


C
r�r�r�r�r�r�r�rorg
zScalarSelect._ungroupr@rAc
G
�td
|j
�j|
�|_
|S)a�Return a new :class:`_expression.ScalarSelect`
        which will correlate the given FROM
        clauses to that of an enclosing :class:`_expression.Select`.

        This method is mirrored from the :meth:`_sql.Select.correlate` method
        of the underlying :class:`_sql.Select`.  The method applies the
        :meth:_sql.Select.correlate` method, then returns a new
        :class:`_sql.ScalarSelect` against that statement.

        .. versionadded:: 1.4 Previously, the
           :meth:`_sql.ScalarSelect.correlate`
           method was only available from :class:`_sql.Select`.

        :param \*fromclauses: a list of one or more
         :class:`_expression.FromClause`
         constructs, or other compatible constructs (i.e. ORM-mapped
         classes) to become part of the correlate collection.

        .. seealso::

            :meth:`_expression.ScalarSelect.correlate_except`

            :ref:`tutorial_scalar_subquery` - in the 2.0 tutorial


        r(
)rr
r�
rEr�r�r�r�
qs
�zScalarSelect.correlatec
G
re)a�Return a new :class:`_expression.ScalarSelect`
        which will omit the given FROM
        clauses from the auto-correlation process.

        This method is mirrored from the
        :meth:`_sql.Select.correlate_except` method of the underlying
        :class:`_sql.Select`.  The method applies the
        :meth:_sql.Select.correlate_except` method, then returns a new
        :class:`_sql.ScalarSelect` against that statement.

        .. versionadded:: 1.4 Previously, the
           :meth:`_sql.ScalarSelect.correlate_except`
           method was only available from :class:`_sql.Select`.

        :param \*fromclauses: a list of one or more
         :class:`_expression.FromClause`
         constructs, or other compatible constructs (i.e. ORM-mapped
         classes) to become part of the correlate-exception collection.

        .. seealso::

            :meth:`_expression.ScalarSelect.correlate`

            :ref:`tutorial_scalar_subquery` - in the 2.0 tutorial


        r(
)rr
rFrEr�r�r�rF�s!
�zScalarSelect.correlate_except)r
r�r�r�)rar�r�r)r�r�)r�r�r�r�r�)r�
r�r�r\r�r�rr
rZ)r�r�r�r�rTrr7r�
r
r4r r�_is_implicitly_booleanr�r�
rbr�r�r�r�rS
r5r�rp
rr�
rFr�r�r�r�r�(s6

�











#
r�c@
sxeZ
dZUd
ZdZded<	d%d&dd	�Zejd'dd
��
Z	d(dd�Z
d)dd�Zd*dd�Zd*dd�Z
d+dd �Zd,d#d$�ZdS)-r�z�Represent an ``EXISTS`` clause.

    See :func:`_sql.exists` for a description of usage.

    An ``EXISTS`` clause can also be constructed from a :func:`_sql.select`
    instance by calling :meth:`_sql.SelectBase.exists`.

    Tz>Union[SelectStatementGrouping[Select[Any]], ScalarSelect[Any]]r
N�_Exists__argument�KOptional[Union[_ColumnsClauseArgument[Any], SelectBase, ScalarSelect[Any]]]cC
sn|
dur
tt
d
�
�
��}nt|
t�r|
��}|
j|_nt|
t�r#|
}nt|
�
��}tj||t	j
tjdd�
dS)Nr�T)�operatorr�wraps_column_expression)
r+
rNr�r�
r�r`r�rPr�
rr�r�BOOLEANTYPE)r�rgrXr�r�r�r�
�s	














�zExists.__init__r�r�c


C
sgSr�r�r�r�r�r�r4�r�zExists._from_objects�fn�$Callable[[Select[Any]], Select[Any]]�$SelectStatementGrouping[Select[Any]]cC
s2|j�
�}|
|�
}|jtjd
�
}t|t�sJ�
|S)Nr�
)r
rrp
rr�r�
r�)r�rlr
r��return_valuer�r�r��_regroup�s




zExists._regroup�Select[Tuple[bool]]c

C
r)
)
a�
Return a SELECT of this :class:`_expression.Exists`.

        e.g.::

            stmt = exists(some_table.c.id).where(some_table.c.id == 5).select()

        This will produce a statement resembling:

        .. sourcecode:: sql

            SELECT EXISTS (SELECT id FROM some_table WHERE some_table = :param) AS anon_1

        .. seealso::

            :func:`_expression.select` - general purpose
            method which allows for arbitrary column lists.

        r*
r�r�r�r�r,
�sz
Exists.selectr@rAr\c

� |��}|�
�f
d
d��
|_|S)z�Apply correlation to the subquery noted by this
        :class:`_sql.Exists`.

        .. seealso::

            :meth:`_sql.ScalarSelect.correlate`

        c


�
|j��Sr�)
r�
r�
r@r�r�r�
�
z"Exists.correlate.<locals>.<lambda>�r+rpr
�r�r@r=r�rtr�r�
s



�zExists.correlatec

rr)z�Apply correlation to the subquery noted by this
        :class:`_sql.Exists`.

        .. seealso::

            :meth:`_sql.ScalarSelect.correlate_except`

        c


rsr�)
rFrrtr�r�r�
)ruz)Exists.correlate_except.<locals>.<lambda>rvrwr�rtr�rFs




�zExists.correlate_exceptrtrac

rr)a�
Return a new :class:`_expression.Exists` construct,
        applying the given
        expression to the :meth:`_expression.Select.select_from`
        method of the select
        statement contained.

        .. note:: it is typically preferable to build a :class:`_sql.Select`
           statement first, including the desired WHERE clause, then use the
           :meth:`_sql.SelectBase.exists` method to produce an
           :class:`_sql.Exists` object at once.

        c


rsr�)
r�
r�
rtr�r�r�
;ruz$Exists.select_from.<locals>.<lambda>rv)r�rtr=r�rxr�r�
-s


zExists.select_fromrr�c

rr)a�
Return a new :func:`_expression.exists` construct with the
        given expression added to
        its WHERE clause, joined to the existing clause via AND, if any.


        .. note:: it is typically preferable to build a :class:`_sql.Select`
           statement first, including the desired WHERE clause, then use the
           :meth:`_sql.SelectBase.exists` method to produce an
           :class:`_sql.Exists` object at once.

        c


rsr�r�r�
rr�r�r�
KruzExists.where.<locals>.<lambda>rv)r�rr=r�ryr�r�>s

zExists.wherer�)rgrhr�)rlrmr�rn)r�rqrZrY)rr�r�r\)r�r�r�r�r�r
r�
rXr�r4rpr,
r�
rFr�
r�r�r�r�r�r��s

	
�






r�c@
s�eZ
dZUd
ZdZeZdejfdej	fge
jej
Zded<dZdZdZ	d8d9dd�Z	d8d:dd�Zed;dd��
Zejd<dd��
Zd=dd�Zd>d d!�Zed?d'd(��
Zd)d*�
d@d3d4�ZdAd6d7�Zd)S)B�
TextualSelectaFWrap a :class:`_expression.TextClause` construct within a
    :class:`_expression.SelectBase`
    interface.

    This allows the :class:`_expression.TextClause` object to gain a
    ``.c`` collection
    and other FROM-like capabilities such as
    :meth:`_expression.FromClause.alias`,
    :meth:`_expression.SelectBase.cte`, etc.

    The :class:`_expression.TextualSelect` construct is produced via the
    :meth:`_expression.TextClause.columns`
    method - see that method for details.

    .. versionchanged:: 1.4 the :class:`_expression.TextualSelect`
       class was renamed
       from ``TextAsFrom``, to more correctly suit its role as a
       SELECT-oriented object and not a FROM clause.

    .. seealso::

        :func:`_expression.text`

        :meth:`_expression.TextClause.columns` - primary creation interface.

    �textual_selectr
�column_argsrSr�
TFr
r~r��$List[_ColumnExpressionArgument[Any]]�
positionalr�r�r�cC
s|�|
d
d�|D�
|�
dS)Nc
S
r�r�)rr�r�LabeledColumnExprRolerb
r�r�r�r
�r�z*TextualSelect.__init__.<locals>.<listcomp>)
r�r�r
r�r~r�r�r�r�
}s
��zTextualSelect.__init__�List[NamedColumn[Any]]cC
s|
|_||_
||_dSr�)r
r|r~r�r�r�r�r�s


zTextualSelect._initr�c

C
std
d�|j
D�
�
��S)amA :class:`_expression.ColumnCollection`
        representing the columns that
        this SELECT statement or similar construct returns in its result set,
        not including :class:`_sql.TextClause` constructs.

        This collection differs from the :attr:`_expression.FromClause.columns`
        collection of a :class:`_expression.FromClause` in that the columns
        within this collection cannot be directly nested inside another SELECT
        statement; a subquery must be applied first which provides for the
        necessary parenthesization required by SQL.

        For a :class:`_expression.TextualSelect` construct, the collection
        contains the :class:`_expression.ColumnElement` objects that were
        passed to the constructor, typically via the
        :meth:`_expression.TextClause.columns` method.


        .. versionadded:: 1.4

        c
s
r�
r�r�
rb
r�r�r�rQ
�r�
z1TextualSelect.selected_columns.<locals>.<genexpr>)r;r|rX
r�r�r�r�r��s

��zTextualSelect.selected_columnsr�c


C
r�r�)
r|r�r�r�r�r��r�z#TextualSelect._all_selected_columnsr�r�
c
C
r�r�r�r�r�r�r�r�
�r�zTextualSelect.set_label_stylec


C
r�r�r�r�r�r�r�r��r�z)TextualSelect._ensure_disambiguated_names�binds�BindParameter[Any]�bind_as_valuesrr\c
O
s|jj
|
i|�
�
|_|Sr�)r
�
bindparams)r�r�r�r�r�r�r��rdzTextualSelect.bindparamsNr�r�r�r�r<r�r�r�r�c

s`tr	t
�
t�s	J�
|r|���
�fd
d�t|j|�D�
�

dS|���
�fdd�|jD�
�

dS)Nc
3
s&�|]\}
}|
j�
|��d�V
qd
S))rKr�r�NrL
)r
rS
rMrP
r�r�rQ
�s��



�
�zDTextualSelect._generate_fromclause_column_proxies.<locals>.<genexpr>c
3
rI
rJ
rL
rb
rP
r�r�rQ
�s��


�
�)rr�
rrR
rmr|)r�r�r�r�r�r�r�rP
r�r��s


���z1TextualSelect._generate_fromclause_column_proxies�Union[TypeEngine[Any], Any]c

C
rprb)r|r�r�r�r�r�r��r�zTextualSelect._scalar_typer�)r
r~r�r}r~r�r�r�)r
r~r�r�r~r�r�r�)r�r�r�)r�r�
r�rz)r�rz)r�r�r�rr�r\)r�r�r�r�r�r<r�r�r�r�r�r�)r�r�) r�r�r�r�r�r�
rZrTrr}r*rrIrur�
r
�_is_textual�is_textr�r�
rrYr�rXr�r�r�
r�r5r�r�r�r�r�r�r�rzOs<


���
�	
��





�$rzc
s.eZ
dZd
�f
dd�Zejddd	��
Z�ZS)�AnnotatedFromClauser�
rr�r�c

s<t�j
di|
�
�

|
�d
d�r|j}|jj�|�
|_dSdS)N�ind_cols_on_fromclauseFr�)r�
r�
r��_Annotated__elementrG
rS
�fget)r�r�
�eer�
r�r�r�
�s



�z#AnnotatedFromClause._copy_internalsrT
c

C
s|j}
|
j
S)
aoproxy the .c collection of the underlying FromClause.

        Originally implemented in 2008 as a simple load of the .c collection
        when the annotated construct was created (see d3621ae961a), in modern
        SQLAlchemy versions this can be expensive for statements constructed
        with ORM aliases.   So for #8796 SQLAlchemy 2.0 we instead proxy
        it, which works just as well.

        Two different use cases seem to require the collection either copied
        from the underlying one, or unique to this AnnotatedFromClause.

        See test_selectable->test_annotated_corresponding_column

        )r�rS
)r�r�r�r�r�rS
�s
zAnnotatedFromClause.c)r�
rr�r�rw
)r�r�r�r�
rXr
rS
rr�r�r�
r�r��s

r�)�r��
__future__rr�
�enumrr�
�typingrrr�
rrrr	r
rrr
rrrrrrrrrrr�
rrrrrrr�_typingr r!r"r$r%r&r'r(�
annotationr)r*�baser+r,r.r0r1r2r4r5r7r8r9r:r;r<r=r>r?r@rArBrCrDr�
rErFrGrHrIrJrKrLrMrNrOrPrQ�sqltypesrRrSrTrUrWrXrY�util.typingrZr[r\r�
r]r_r`rarbrcrdrerfrgrhrirjrkrlrmrnrorprq�_TCCArrrsrtrurvr{rw�dmlrxryrzr{r|r}r~r@rr'
r�r�r�r�r��_ColumnsClauseElementr�r�r�r��_OnClauseElement�_ForUpdateOfArgument�_SetupJoinsElementr�r�r�rr�r�r�r�r�r
r
�AnonymizedFromClauseRoler�r8
r�
r�
r�
r�
r�
r�
r�
�DMLTableRoler3
rr�rr$r�r)r�r>
ryrCrRrSrYrJrIrr�
r�r�r�r�r��
InElementRoler�r�r��
DMLSelectRolerWr�r�r�r�
plugin_forrErMrTr��setattrr��
MemoizedSlotsr_r��HasCacheKey�HasCopyInternals�Traversibler�r+
r�r�rz�
TextAsFromr�r�r�r�r��<module>
s(



























































































































�

���




��XN34~G,{�



5c$9!
:





�D!/'=> F
.






�Lh
u
	V


b

�
:






�
>
�