,hOSSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SS K J r SS K J r SS K J r SS K Jr SS KJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr \(axSSK Jr SSK Jr SSK J r SSK J!r! SSK J"r" SSK J#r# SS K J$r$ SS!K J%r% SS"K J&r& SS#K J'r' SS$K J(r( SS%K J)r) SS&K J*r* SS'K J+r+ SS(K J,r- SS)K.J/r/ SS*KJ0r0 SS+KJ1r1 SS,KJ2r2 SS-KJ3r3 SYSZS0jjr4SYS[S1jjr5\S2r6\S\S3j5r7\S]S4j5r7S]S5jr7\S\S6j5r8\S]S7j5r8S]S8jr8S^S_S9jjr9\S\S:j5r:\S]S;j5r:S]S<jr:\S\S=j5r;\S]S>j5r;S]S?jr;S`SaS@jjr<S^SbSAjjr=SYScSBjjr>\SdSCj5r?\SeSDj5r?\SfSEj5r?\SgSFj5r?\ShSGj5r?\SiSHj5r?\SjSIj5r?\SkSJj5r?\SlSKj5r?\SmSLj5r?\SnSMj5r?SnSNjr?SoSOjr@SpSqSPjjrA\S\SQj5rB\S]SRj5rBS]SSjrB\S\STj5rC\S]SUj5rCS]SVjrCS.S/SW.SrSXjjrDg.)s) annotations)Any)Optional)overload)Tuple) TYPE_CHECKING)Union) coercions)roles)_ColumnsClauseArgument)_no_kw) ColumnClause)Alias)CompoundSelectExists) FromClauseJoin)Lateral)LateralFromClause)NamedFromClause)Select TableClause) TableSampleValues)_FromClauseArgument)_OnClauseArgument)#_SelectStatementForCompoundArgument)_T0)_T1)_T2)_T3)_T4)_T5)_T6)_T7)_T8)_T9)_TP)_TypedColumnClauseArgument)Function)CTE)HasCTE) ScalarSelect) SelectBaseNFc,[R"XUS9$)aReturn a named alias of the given :class:`.FromClause`. For :class:`.Table` and :class:`.Join` objects, the return type is the :class:`_expression.Alias` object. Other kinds of :class:`.NamedFromClause` objects may be returned for other kinds of :class:`.FromClause` objects. The named alias represents any :class:`_expression.FromClause` with an alternate name assigned within SQL, typically using the ``AS`` clause when generated, e.g. ``SELECT * FROM table AS aliasname``. Equivalent functionality is available via the :meth:`_expression.FromClause.alias` method available on all :class:`_expression.FromClause` objects. :param selectable: any :class:`_expression.FromClause` subclass, such as a table, select statement, etc. :param name: string name to be assigned as the alias. If ``None``, a name will be deterministically generated at compile time. Deterministic means the name is guaranteed to be unique against other constructs used in the same statement, and will also be the same name for each successive compilation of the same statement object. :param flat: Will be passed through to if the given selectable is an instance of :class:`_expression.Join` - see :meth:`_expression.Join.alias` for details. )nameflat)r_factory) selectabler5r6s _/var/www/auris/envauris/lib/python3.13/site-packages/sqlalchemy/sql/_selectable_constructors.pyaliasr::s> >>*d ;;cf[R"[RU5R XS9$)zReturn a new :class:`_expression.CTE`, or Common Table Expression instance. Please see :meth:`_expression.HasCTE.cte` for detail on CTE usage. )r5 recursive)r expectr HasCTERolecte)r8r5r=s r9r@r@\s2   E,,j 9 = =  > r;)z Select[_TP]CompoundSelect[_TP]cgNselectss r9except_rGqr;cgrCrDrEs r9rGrGwrHr;c([R"U6$)zReturn an ``EXCEPT`` of multiple selectables. The returned object is an instance of :class:`_expression.CompoundSelect`. :param \*selects: a list of :class:`_expression.Select` instances. )r_create_exceptrEs r9rGrG}s  ( (' 22r;cgrCrDrEs r9 except_allrMrHr;cgrCrDrEs r9rMrMrHr;c([R"U6$)zReturn an ``EXCEPT ALL`` of multiple selectables. The returned object is an instance of :class:`_expression.CompoundSelect`. :param \*selects: a list of :class:`_expression.Select` instances. )r_create_except_allrEs r9rMrMs  , ,g 66r;c[U5$)a:Construct a new :class:`_expression.Exists` construct. The :func:`_sql.exists` can be invoked by itself to produce an :class:`_sql.Exists` construct, which will accept simple WHERE criteria:: exists_criteria = exists().where(table1.c.col1 == table2.c.col2) However, for greater flexibility in constructing the SELECT, an existing :class:`_sql.Select` construct may be converted to an :class:`_sql.Exists`, most conveniently by making use of the :meth:`_sql.SelectBase.exists` method:: exists_criteria = ( select(table2.c.col2).where(table1.c.col1 == table2.c.col2).exists() ) The EXISTS criteria is then used inside of an enclosing SELECT:: stmt = select(table1.c.col1).where(exists_criteria) The above statement will then be of the form: .. sourcecode:: sql SELECT col1 FROM table1 WHERE EXISTS (SELECT table2.col2 FROM table2 WHERE table2.col2 = table1.col1) .. seealso:: :ref:`tutorial_exists` - in the :term:`2.0 style` tutorial. :meth:`_sql.SelectBase.exists` - method to transform a ``SELECT`` to an ``EXISTS`` clause. r) __arguments r9existsrSsT * r;cgrCrDrEs r9 intersectrUrHr;cgrCrDrEs r9rUrUrHr;c([R"U6$)zReturn an ``INTERSECT`` of multiple selectables. The returned object is an instance of :class:`_expression.CompoundSelect`. :param \*selects: a list of :class:`_expression.Select` instances. )r_create_intersectrEs r9rUrUs  + +W 55r;cgrCrDrEs r9 intersect_allrZrHr;cgrCrDrEs r9rZrZrHr;c([R"U6$)zReturn an ``INTERSECT ALL`` of multiple selectables. The returned object is an instance of :class:`_expression.CompoundSelect`. :param \*selects: a list of :class:`_expression.Select` instances. )r_create_intersect_allrEs r9rZrZs  / / 99r;c[XX#U5$)a;Produce a :class:`_expression.Join` object, given two :class:`_expression.FromClause` expressions. E.g.:: j = join( user_table, 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 Similar functionality is available given any :class:`_expression.FromClause` object (e.g. such as a :class:`_schema.Table`) using the :meth:`_expression.FromClause.join` method. :param left: The left side of the join. :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 JOIN. .. seealso:: :meth:`_expression.FromClause.join` - method form, based on a given left side. :class:`_expression.Join` - the type of object produced. r)leftrightonclauseisouterfulls r9joinrd sp X 55r;c*[R"XS9$)a%Return a :class:`_expression.Lateral` object. :class:`_expression.Lateral` is an :class:`_expression.Alias` subclass that represents a subquery with the LATERAL keyword applied to it. The special behavior of a LATERAL subquery is that it appears in the FROM clause of an enclosing SELECT, but may correlate to other FROM clauses of that SELECT. It is a special case of subquery only supported by a small number of backends, currently more recent PostgreSQL versions. .. seealso:: :ref:`tutorial_lateral_correlation` - overview of usage. )r5)rr7)r8r5s r9lateralrfFs*   J 22r;c[XUSUS9$)aReturn an ``OUTER JOIN`` clause element. The returned object is an instance of :class:`_expression.Join`. Similar functionality is also available via the :meth:`_expression.FromClause.outerjoin` method on any :class:`_expression.FromClause`. :param left: The left side of the join. :param right: The right side of the join. :param onclause: Optional criterion for the ``ON`` clause, is derived from foreign key relationships established between left and right otherwise. To chain joins together, use the :meth:`_expression.FromClause.join` or :meth:`_expression.FromClause.outerjoin` methods on the resulting :class:`_expression.Join` object. T)rbrcr)r_r`rarcs r9 outerjoinrh^s8 Xt$ ??r;cgrCrD)__ent0s r9selectrks69r;cgrCrD)rj__ent1s r9rkrks"r;cgrCrD)rjrm__ent2s r9rkrks$'r;cgrCrD)rjrmro__ent3s r9rkrks ),r;cgrCrD)rjrmrorq__ent4s r9rkrks.1r;cgrCrD)rjrmrorqrs__ent5s r9rkrks36r;cgrCrD)rjrmrorqrsru__ent6s r9rkrks8;r;cgrCrD)rjrmrorqrsrurw__ent7s r9rkrks=@r;c grCrD) rjrmrorqrsrurwry__ent8s r9rkrks BEr;c grCrD) rjrmrorqrsrurwryr{__ent9s r9rkrks GJr;cgrCrDentities__kws r9rkrksr;c4U(a [5e[U6$)aConstruct a new :class:`_expression.Select`. .. versionadded:: 1.4 - The :func:`_sql.select` function now accepts column arguments positionally. The top-level :func:`_sql.select` function will automatically use the 1.x or 2.x style API based on the incoming arguments; using :func:`_sql.select` from the ``sqlalchemy.future`` module will enforce that only the 2.x style constructor is used. Similar functionality is also available via the :meth:`_expression.FromClause.select` method on any :class:`_expression.FromClause`. .. seealso:: :ref:`tutorial_selecting_data` - in the :ref:`unified_tutorial` :param \*entities: Entities to SELECT from. For Core usage, this is typically a series of :class:`_expression.ColumnElement` and / or :class:`_expression.FromClause` objects which will form the columns clause of the resulting statement. For those objects that are instances of :class:`_expression.FromClause` (typically :class:`_schema.Table` or :class:`_expression.Alias` objects), the :attr:`_expression.FromClause.c` collection is extracted to form a collection of :class:`_expression.ColumnElement` objects. This parameter will also accept :class:`_expression.TextClause` constructs as given, as well as ORM-mapped classes. )rrrs r9rkrksN h 8 r;c [U/UQ70UD6$)aProduce a new :class:`_expression.TableClause`. The object returned is an instance of :class:`_expression.TableClause`, which represents the "syntactical" portion of the schema-level :class:`_schema.Table` object. It may be used to construct lightweight table constructs. :param name: Name of the table. :param columns: A collection of :func:`_expression.column` constructs. :param schema: The schema name for this table. .. versionadded:: 1.3.18 :func:`_expression.table` can now accept a ``schema`` argument. r)r5columnskws r9tablers& t ,g , ,,r;c,[R"XX#S9$)aReturn a :class:`_expression.TableSample` object. :class:`_expression.TableSample` is an :class:`_expression.Alias` subclass that represents a table with the TABLESAMPLE clause applied to it. :func:`_expression.tablesample` is also available from the :class:`_expression.FromClause` class via the :meth:`_expression.FromClause.tablesample` method. The TABLESAMPLE clause allows selecting a randomly selected approximate percentage of rows from a table. It supports multiple sampling methods, most commonly BERNOULLI and SYSTEM. e.g.:: from sqlalchemy import func selectable = people.tablesample( func.bernoulli(1), name="alias", seed=func.random() ) stmt = select(selectable.c.people_id) Assuming ``people`` with a column ``people_id``, the above statement would render as: .. sourcecode:: sql SELECT alias.people_id FROM people AS alias TABLESAMPLE bernoulli(:bernoulli_1) REPEATABLE (random()) :param sampling: a ``float`` percentage between 0 and 100 or :class:`_functions.Function`. :param name: optional alias name :param seed: any real-valued SQL expression. When specified, the REPEATABLE sub-clause is also rendered. )r5seed)rr7)r8samplingr5rs r9 tablesampler2s^    4 KKr;cgrCrDrEs r9unionrdrHr;cgrCrDrEs r9rrjrHr;c([R"U6$)a}Return a ``UNION`` of multiple selectables. The returned object is an instance of :class:`_expression.CompoundSelect`. A similar :func:`union()` method is available on all :class:`_expression.FromClause` subclasses. :param \*selects: a list of :class:`_expression.Select` instances. :param \**kwargs: available keyword arguments are the same as those of :func:`select`. )r _create_unionrEs r9rrps&  ' ' 11r;cgrCrDrEs r9 union_allrrHr;cgrCrDrEs r9rrrHr;c([R"U6$)a)Return a ``UNION ALL`` of multiple selectables. The returned object is an instance of :class:`_expression.CompoundSelect`. A similar :func:`union_all()` method is available on all :class:`_expression.FromClause` subclasses. :param \*selects: a list of :class:`_expression.Select` instances. )r_create_union_allrEs r9rrs  + +W 55r;)r5 literal_bindsc[X!US.6$)a{Construct a :class:`_expression.Values` construct. The column expressions and the actual data for :class:`_expression.Values` are given in two separate steps. The constructor receives the column expressions typically as :func:`_expression.column` constructs, and the data is then passed via the :meth:`_expression.Values.data` method as a list, which can be called multiple times to add more data, e.g.:: from sqlalchemy import column from sqlalchemy import values from sqlalchemy import Integer from sqlalchemy import String value_expr = values( column("id", Integer), column("name", String), name="my_values", ).data([(1, "name1"), (2, "name2"), (3, "name3")]) :param \*columns: column expressions, typically composed using :func:`_expression.column` objects. :param name: the name for this VALUES construct. If omitted, the VALUES construct will be unnamed in a SQL expression. Different backends may have different requirements here. :param literal_binds: Defaults to False. Whether or not to render the data values inline in the SQL output, rather than using bound parameters. )rr5r)r5rrs r9valuesrsN 7d CCr;)NF)r8rr5 Optional[str]r6boolreturnr)r8r1r5rr=rrr0)rFz_TypedSelectable[_TP]rrA)rFz(_SelectStatementForCompoundArgument[_TP]rrArC)rRzKOptional[Union[_ColumnsClauseArgument[Any], SelectBase, ScalarSelect[Any]]]rr)NFF) r_r r`r raOptional[_OnClauseArgument]rbrrcrrr)r8z&Union[SelectBase, _FromClauseArgument]r5rrr) r_r r`r rarrcrrr)rj _TCCA[_T0]rzSelect[Tuple[_T0]])rjrrm _TCCA[_T1]rzSelect[Tuple[_T0, _T1]])rjrrmrro _TCCA[_T2]rzSelect[Tuple[_T0, _T1, _T2]]) rjrrmrrorrq _TCCA[_T3]rz!Select[Tuple[_T0, _T1, _T2, _T3]]) rjrrmrrorrqrrs _TCCA[_T4]rz&Select[Tuple[_T0, _T1, _T2, _T3, _T4]])rjrrmrrorrqrrsrru _TCCA[_T5]rz+Select[Tuple[_T0, _T1, _T2, _T3, _T4, _T5]])rjrrmrrorrqrrsrrurrw _TCCA[_T6]rz0Select[Tuple[_T0, _T1, _T2, _T3, _T4, _T5, _T6]])rjrrmrrorrqrrsrrurrwrry _TCCA[_T7]rz5Select[Tuple[_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7]])rjrrmrrorrqrrsrrurrwrryrr{ _TCCA[_T8]rz:Select[Tuple[_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8]])rjrrmrrorrqrrsrrurrwrryrr{rr}z _TCCA[_T9]rz?Select[Tuple[_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9]])rz_ColumnsClauseArgument[Any]rrrz Select[Any])r5strrColumnClause[Any]rrrr)NN) r8r rzUnion[float, Function[Any]]r5rrz*Optional[roles.ExpressionElementRole[Any]]rr)rrr5rrrrr)E __future__rtypingrrrrrr r r _typingr relementsrr8rrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r._TCCA functionsr/r0r1r2r3r:r@_TypedSelectablerGrMrSrUrZrdrfrhrkrrrrrrDr;r9rs# +"&")'##,*<<#"(&FK<<"/<>B< #   6  36 3 3 #   6  76 7 7$ ** *Z #   6  66 6 6 #   6  :6 : :&-1 86 86 86*86 86  86  86z363 336-1 @ @ @*@  @  @J 9 9 " " *"" "  ' ' *'4>'!' '  , , , ,  , ' , , 1 1 1 1  1  1 , 1 1 6 6 6 6  6  6  616 6 ; ; ; ;  ;  ;  ; ;6; ;  @  @  @  @  @  @  @  @  @; @  @  E  E  E  E  E  E  E  E  E  E@ E  E  J  J  J  J  J  J  J  J  J  J  JE J  J" *47  )X-27; /L#/L)/L /L 5 /L  /Ld #   6  2622, #   6  6666('D'D 'D'D 'Dr;