SELECT и связанные с ним конструкции¶

Выбираемые фундаментальные конструкторы¶

Конструкторы верхнего уровня «FROM clause» и «SELECT».

function sqlalchemy.sql.expression.except_(*selects: _SelectStatementForCompoundArgument) → CompoundSelect¶

Возвращает EXCEPT из нескольких выбираемых элементов.

Возвращаемый объект является экземпляром CompoundSelect.

Параметры:

*selects – список экземпляров Select.

function sqlalchemy.sql.expression.except_all(*selects: _SelectStatementForCompoundArgument) → CompoundSelect¶

Возвращает EXCEPT ALL из нескольких выбираемых элементов.

Возвращаемый объект является экземпляром CompoundSelect.

Параметры:

*selects – список экземпляров Select.

function sqlalchemy.sql.expression.exists(__argument: Optional[Union[_ColumnsClauseArgument[Any], SelectBase, ScalarSelect[Any]]] = None) → Exists¶

Создайте новую конструкцию Exists.

exists() может быть вызвана сама по себе для создания конструкции Exists, которая будет принимать простые критерии WHERE:

exists_criteria = exists().where(table1.c.col1 == table2.c.col2)

Однако для большей гибкости при построении SELECT существующая конструкция Select может быть преобразована в Exists, что наиболее удобно при использовании метода SelectBase.exists():

exists_criteria = (
    select(table2.c.col2).
    where(table1.c.col1 == table2.c.col2).
    exists()
)

Критерий EXISTS затем используется внутри вложенного SELECT:

stmt = select(table1.c.col1).where(exists_criteria)

Тогда приведенное выше утверждение будет иметь вид:

SELECT col1 FROM table1 WHERE EXISTS
(SELECT table2.col2 FROM table2 WHERE table2.col2 = table1.col1)

См.также

подзапросы EXISTS - в учебнике 2.0 style.

SelectBase.exists() - метод преобразования предложения SELECT в предложение EXISTS.

function sqlalchemy.sql.expression.intersect(*selects: _SelectStatementForCompoundArgument) → CompoundSelect¶

Возвращает INTERSECT из нескольких выбираемых элементов.

Возвращаемый объект является экземпляром CompoundSelect.

Параметры:

*selects – список экземпляров Select.

function sqlalchemy.sql.expression.intersect_all(*selects: _SelectStatementForCompoundArgument) → CompoundSelect¶

Возвращает INTERSECT ALL из нескольких выбираемых элементов.

Возвращаемый объект является экземпляром CompoundSelect.

Параметры:

*selects – список экземпляров Select.

function sqlalchemy.sql.expression.select(*entities: _ColumnsClauseArgument[Any], **__kw: Any) → Select[Any]¶

Создайте новый Select.

Добавлено в версии 1.4: - The select() function now accepts column arguments positionally. The top-level select() function will automatically use the 1.x or 2.x style API based on the incoming arguments; using select() from the sqlalchemy.future module will enforce that only the 2.x style constructor is used.

Подобная функциональность также доступна через метод FromClause.select() на любом FromClause.

См.также

Использование операторов SELECT - в Унифицированный учебник по SQLAlchemy

Параметры:

*entities – Объекты для ВЫБОРА. Для использования в Core это обычно серия объектов ColumnElement и/или FromClause, которые образуют пункт columns результирующего оператора. Для тех объектов, которые являются экземплярами FromClause (обычно Table или Alias), коллекция FromClause.c извлекается для формирования коллекции ColumnElement объектов. Этот параметр также принимает конструкции TextClause как заданные, а также ORM-сопоставленные классы.

function sqlalchemy.sql.expression.table(name: str, *columns: ColumnClause[Any], **kw: Any) → TableClause¶

Произведите новый TableClause.

Возвращаемый объект является экземпляром TableClause, который представляет собой «синтаксическую» часть объекта уровня схемы Table. Он может быть использован для построения облегченных конструкций таблиц.

Параметры:

• name – Название таблицы.

• columns – Коллекция конструкций column().

• schema – Имя схемы для этой таблицы. … versionadded:: 1.3.18 table() теперь может принимать аргумент schema.

function sqlalchemy.sql.expression.union(*selects: _SelectStatementForCompoundArgument) → CompoundSelect¶

Возвращает UNION из нескольких выбираемых элементов.

Возвращаемый объект является экземпляром CompoundSelect.

Аналогичный метод union() доступен для всех подклассов FromClause.

Параметры:

• *selects – список экземпляров Select.

• **kwargs – доступные аргументы ключевых слов такие же, как и в select().

function sqlalchemy.sql.expression.union_all(*selects: _SelectStatementForCompoundArgument) → CompoundSelect¶

Возвращает UNION ALL из нескольких выбираемых элементов.

Возвращаемый объект является экземпляром CompoundSelect.

Аналогичный метод union_all() доступен для всех подклассов FromClause.

Параметры:

*selects – список экземпляров Select.

function sqlalchemy.sql.expression.values(*columns: ColumnClause[Any], name: Optional[str] = None, literal_binds: bool = False) → Values¶

Создайте конструкцию Values.

Выражения столбцов и фактические данные для Values передаются в два отдельных этапа. Конструктор получает выражения столбцов обычно в виде конструкций column(), а данные затем передаются через метод Values.data() в виде списка, который можно вызывать несколько раз для добавления дополнительных данных, например:

from sqlalchemy import column
from sqlalchemy import values

value_expr = values(
    column('id', Integer),
    column('name', String),
    name="my_values"
).data(
    [(1, 'name1'), (2, 'name2'), (3, 'name3')]
)

Параметры:

• *columns – выражения столбцов, обычно составленные с использованием объектов column().

• name – имя для данной конструкции VALUES. Если опущено, конструкция VALUES будет безымянной в выражении SQL. Различные бэкенды могут предъявлять разные требования.

• literal_binds – По умолчанию имеет значение False. Выводить или нет значения данных в линию в выводе SQL, а не использовать связанные параметры.

Конструкторы модификаторов с возможностью выбора¶

Перечисленные здесь функции чаще всего доступны как методы из элементов FromClause и Selectable, например, функция alias() обычно вызывается через метод FromClause.alias().

function sqlalchemy.sql.expression.alias(selectable: FromClause, name: Optional[str] = None, flat: bool = False) → NamedFromClause¶

Возвращает именованный псевдоним заданного FromClause.

Для объектов Table и Join возвращаемым типом является объект Alias. Для других видов объектов NamedFromClause могут быть возвращены другие виды объектов FromClause.

Именованный псевдоним представляет собой любое FromClause с альтернативным именем, назначенным в SQL, обычно с помощью предложения AS при генерации, например SELECT * FROM table AS aliasname.

Эквивалентная функциональность доступна через метод FromClause.alias(), доступный для всех объектов FromClause.

Параметры:

• selectable – любой подкласс FromClause, такой как таблица, оператор select и т.д.

• name – строковое имя, которое будет назначено в качестве псевдонима. Если None, имя будет детерминированно генерироваться во время компиляции. Детерминированность означает, что имя гарантированно будет уникальным по отношению к другим конструкциям, используемым в том же операторе, а также будет тем же именем при каждой последующей компиляции одного и того же объекта оператора.

• flat – Будет передан, если данный selectable является экземпляром Join - подробности см. в Join.alias().

function sqlalchemy.sql.expression.cte(selectable: HasCTE, name: Optional[str] = None, recursive: bool = False) → CTE¶

Возвращает новый экземпляр CTE, или Common Table Expression.

Подробную информацию об использовании CTE смотрите в HasCTE.cte().

function sqlalchemy.sql.expression.join(left: _FromClauseArgument, right: _FromClauseArgument, onclause: Optional[_OnClauseArgument] = None, isouter: bool = False, full: bool = False) → Join¶

Произвести объект Join, заданный двумя выражениями FromClause.

Например:

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

будет выдавать SQL примерно следующего содержания:

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

Аналогичная функциональность доступна для любого объекта FromClause (например, такого как Table) с помощью метода FromClause.join().

Параметры:

• left – Левая сторона соединения.

• right – правая сторона соединения; это любой объект FromClause, например, объект Table, а также может быть совместимым с selectable объектом, например, ORM-mapped class.

• onclause – выражение SQL, представляющее предложение ON для объединения. Если оставить значение None, FromClause.join() попытается объединить две таблицы на основе отношения внешнего ключа.

• isouter – если True, отображает LEFT OUTER JOIN вместо JOIN.

• full – если True, отображает FULL OUTER JOIN, вместо JOIN.

См.также

FromClause.join() - форма метода, основанная на заданной левой части.

Join - тип производимого объекта.

function sqlalchemy.sql.expression.lateral(selectable: Union[SelectBase, _FromClauseArgument], name: Optional[str] = None) → LateralFromClause¶

Возвращает объект Lateral.

Lateral является подклассом Alias, который представляет подзапрос с примененным к нему ключевым словом LATERAL.

Особенность поведения подзапроса LATERAL заключается в том, что он появляется в предложении FROM вложенного SELECT, но может соотноситься с другими предложениями FROM этого SELECT. Это особый случай подзапроса, который поддерживается только небольшим числом бэкендов, в настоящее время более поздними версиями PostgreSQL.

См.также

ЛАТЕРАЛЬНАЯ корреляция - обзор использования.

function sqlalchemy.sql.expression.outerjoin(left: _FromClauseArgument, right: _FromClauseArgument, onclause: Optional[_OnClauseArgument] = None, full: bool = False) → Join¶

Возвращает элемент клаузулы OUTER JOIN.

Возвращаемый объект является экземпляром Join.

Подобная функциональность также доступна через метод FromClause.outerjoin() на любом FromClause.

Параметры:

• left – Левая сторона соединения.

• right – Правая сторона соединения.

• onclause – Необязательный критерий для условия ON, выводится из отношений внешних ключей, установленных между левым и правым иными.

Чтобы составить цепочку соединений, используйте методы FromClause.join() или FromClause.outerjoin() для результирующего объекта Join.

function sqlalchemy.sql.expression.tablesample(selectable: _FromClauseArgument, sampling: Union[float, Function[Any]], name: Optional[str] = None, seed: Optional[roles.ExpressionElementRole[Any]] = None) → TableSample¶

Возвращает объект TableSample.

TableSample - это подкласс Alias, который представляет таблицу с примененным к ней предложением TABLESAMPLE. tablesample() также доступен из класса FromClause через метод FromClause.tablesample().

Пункт TABLESAMPLE позволяет выбрать случайным образом приблизительный процент строк из таблицы. Он поддерживает несколько методов выборки, чаще всего BERNOULLI и SYSTEM.

например:

from sqlalchemy import func

selectable = people.tablesample(
            func.bernoulli(1),
            name='alias',
            seed=func.random())
stmt = select(selectable.c.people_id)

Если предположить, что people с колонкой people_id, то вышеприведенное утверждение будет выглядеть так:

SELECT alias.people_id FROM
people AS alias TABLESAMPLE bernoulli(:bernoulli_1)
REPEATABLE (random())

Параметры:

• sampling – процент float между 0 и 100 или Function.

• name – необязательное имя псевдонима

• seed – любое действительное выражение SQL. Если указано, то подпункт REPEATABLE также отображается.

Документация выбираемого класса¶

Классы, представленные здесь, создаются с помощью конструкторов, перечисленных в Выбираемые фундаментальные конструкторы и Конструкторы модификаторов с возможностью выбора.

class sqlalchemy.sql.expression.Alias¶

Представляет собой таблицу или выбираемый псевдоним (AS).

Представляет собой псевдоним, который обычно применяется к любой таблице или подвыборке в операторе SQL с помощью ключевого слова AS (или без ключевого слова в некоторых базах данных, таких как Oracle).

Этот объект строится из функции уровня модуля alias(), а также метода FromClause.alias(), доступного для всех подклассов FromClause.

См.также

FromClause.alias()

Members

inherit_cache

Классная подпись

класс sqlalchemy.sql.expression.Alias (sqlalchemy.sql.roles.DMLTableRole, sqlalchemy.sql.expression.FromClauseAlias)

attribute sqlalchemy.sql.expression.Alias.inherit_cache: Optional[bool] = True¶

Укажите, должен ли данный экземпляр HasCacheKey использовать схему генерации ключей кэша, используемую его непосредственным суперклассом.

По умолчанию атрибут имеет значение None, что указывает на то, что конструкция еще не приняла во внимание целесообразность ее участия в кэшировании; функционально это эквивалентно установке значения False, за исключением того, что при этом выдается предупреждение.

Этот флаг может быть установлен в True на определенном классе, если SQL, соответствующий объекту, не изменяется на основе атрибутов, локальных для этого класса, а не его суперкласса.

См.также

Включение поддержки кэширования для пользовательских конструкций - общие направляющие для установки атрибута HasCacheKey.inherit_cache для сторонних или определенных пользователем конструкций SQL.

class sqlalchemy.sql.expression.AliasedReturnsRows¶

Базовый класс псевдонимов для таблиц, подзапросов и других selectables.

Members

description, is_derived_from(), original

Классная подпись

класс sqlalchemy.sql.expression.AliasedReturnsRows (sqlalchemy.sql.expression.NoInit, sqlalchemy.sql.expression.NamedFromClause)

attribute sqlalchemy.sql.expression.AliasedReturnsRows.description¶

method sqlalchemy.sql.expression.AliasedReturnsRows.is_derived_from(fromclause: Optional[FromClause]) → bool¶

Возвращает True, если данный FromClause является «производным» от данного FromClause.

Например, псевдоним таблицы является производным от этой таблицы.

attribute sqlalchemy.sql.expression.AliasedReturnsRows.original¶

Наследие для диалектов, которые ссылаются на Alias.original.

class sqlalchemy.sql.expression.CompoundSelect¶

Формирует основу UNION, UNION ALL и других операций с множествами на основе SELECT.

См.также

union()

union_all()

intersect()

intersect_all()

except()

except_all()

Members

add_cte(), alias(), as_scalar(), c, corresponding_column(), cte(), execution_options(), exists(), exported_columns, fetch(), get_execution_options(), get_label_style(), group_by(), is_derived_from(), label(), lateral(), limit(), offset(), options(), order_by(), replace_selectable(), scalar_subquery(), select(), selected_columns, self_group(), set_label_style(), slice(), subquery(), with_for_update()

Классная подпись

class sqlalchemy.sql.expression.CompoundSelect (sqlalchemy.sql.expression.HasCompileState, sqlalchemy.sql.expression.GenerativeSelect, sqlalchemy.sql.expression.ExecutableReturnsRows)

method sqlalchemy.sql.expression.CompoundSelect.add_cte(*ctes: CTE, nest_here: bool = False) → Self¶

наследуется от HasCTE.add_cte() метода HasCTE

Добавьте к этому утверждению одну или несколько конструкций CTE.

Этот метод свяжет заданные конструкции CTE с родительским оператором таким образом, что каждая из них будет безоговорочно отображена в предложение WITH конечного оператора, даже если на нее нет ссылок в других местах оператора или вложенных селектов.

Необязательный параметр HasCTE.add_cte.nest_here при установке в True будет иметь тот эффект, что каждый данный CTE будет отображаться в предложении WITH, отображаемом непосредственно вместе с этим утверждением, а не перемещаться в начало конечного отображаемого утверждения, даже если это утверждение отображается как подзапрос внутри более крупного утверждения.

Этот метод имеет два общих применения. Первое - это встраивание операторов CTE, которые служат некоторым целям без явных ссылок, например, в случае встраивания оператора DML, такого как INSERT или UPDATE, в качестве CTE в линию с основным оператором, который может косвенно использовать его результаты. Другая задача - обеспечить контроль над точным размещением определенной серии конструкций CTE, которые должны оставаться отображенными непосредственно в терминах конкретного оператора, который может быть вложен в более крупный оператор.

Например:

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)

Будет оказывать:

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

Выше, CTE «anon_1» не упоминается в операторе SELECT, но все же выполняет задачу запуска оператора INSERT.

Аналогично в контексте, связанном с DML, использование конструкции PostgreSQL Insert для создания «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)

Вышеприведенное утверждение выглядит следующим образом:

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

Добавлено в версии 1.4.21.

Параметры:

• *ctes – ноль или более конструкций CTE. … versionchanged:: 2.0 Принимаются несколько экземпляров CTE

• nest_here – если True, то данный CTE или CTE будут отображаться так, как если бы при добавлении их в данный HasCTE был указан флаг HasCTE.cte.nesting в True. Если предполагается, что на данные CTE не ссылаются во внешнем охватывающем утверждении, то при установке этого флага данные CTE будут отображаться на уровне этого утверждения. … версия добавлена:: 2.0 .. seealso:: HasCTE.cte.nesting

method sqlalchemy.sql.expression.CompoundSelect.alias(name: Optional[str] = None, flat: bool = False) → Subquery¶

наследуется от SelectBase.alias() метода SelectBase

Возвращает именованный подзапрос к данному SelectBase.

Для SelectBase (в отличие от FromClause) это возвращает объект Subquery, который ведет себя в основном так же, как объект Alias, который используется с FromClause.

Изменено в версии 1.4: Метод SelectBase.alias() теперь является синонимом метода SelectBase.subquery().

method sqlalchemy.sql.expression.CompoundSelect.as_scalar() → ScalarSelect[Any]¶

наследуется от SelectBase.as_scalar() метода SelectBase

Не рекомендуется, начиная с версии 1.4: Метод SelectBase.as_scalar() является устаревшим и будет удален в одном из будущих выпусков. Пожалуйста, обратитесь к SelectBase.scalar_subquery().

attribute sqlalchemy.sql.expression.CompoundSelect.c¶

наследуется от SelectBase.c атрибута SelectBase

Не рекомендуется, начиная с версии 1.4: Атрибуты SelectBase.c и SelectBase.columns устарели и будут удалены в будущем релизе; эти атрибуты неявно создают подзапрос, который должен быть явным. Пожалуйста, сначала вызовите SelectBase.subquery(), чтобы создать подзапрос, который затем будет содержать этот атрибут. Для доступа к столбцам, из которых выбирает данный объект SELECT, используйте атрибут SelectBase.selected_columns.

method sqlalchemy.sql.expression.CompoundSelect.corresponding_column(column: KeyedColumnElement[Any], require_embedded: bool = False) → Optional[KeyedColumnElement[Any]]¶

наследуется от Selectable.corresponding_column() метода Selectable

Учитывая ColumnElement, возвращает экспортированный объект ColumnElement из коллекции Selectable.exported_columns данного Selectable, который соответствует исходному ColumnElement через общий граф предков.

Параметры:

• column – цель ColumnElement для сопоставления.

• require_embedded – возвращает соответствующие столбцы для данного ColumnElement только в том случае, если данный ColumnElement действительно присутствует в подэлементе данного Selectable. Обычно столбец будет соответствовать, если он просто имеет общего предка с одним из экспортированных столбцов данного Selectable.

См.также

Selectable.exported_columns - ColumnCollection, который используется для операции.

ColumnCollection.corresponding_column() - метод реализации.

method sqlalchemy.sql.expression.CompoundSelect.cte(name: Optional[str] = None, recursive: bool = False, nesting: bool = False) → CTE¶

наследуется от HasCTE.cte() метода HasCTE

Возвращает новый экземпляр CTE, или Common Table Expression.

Общие табличные выражения - это стандарт SQL, согласно которому операторы SELECT могут использовать вторичные операторы, указанные вместе с первичным оператором, используя предложение под названием «WITH». Специальная семантика UNION также может быть использована для обеспечения «рекурсивных» запросов, когда оператор SELECT может использовать набор строк, которые были выбраны ранее.

CTE также могут применяться к конструкциям DML UPDATE, INSERT и DELETE в некоторых базах данных, как в качестве источника строк CTE в сочетании с RETURNING, так и в качестве потребителя строк CTE.

SQLAlchemy определяет объекты CTE, которые рассматриваются аналогично объектам Alias, как специальные элементы, которые должны быть доставлены в предложение FROM оператора, а также в предложение WITH в верхней части оператора.

Для специальных префиксов, таких как PostgreSQL «MATERIALIZED» и «NOT MATERIALIZED», можно использовать метод CTE.prefix_with() для их установления.

Изменено в версии 1.3.13: Добавлена поддержка префиксов. В частности - МАТЕРИАЛИЗОВАННЫЙ и НЕ МАТЕРИАЛИЗОВАННЫЙ.

Параметры:

• name – имя, присваиваемое общему табличному выражению. Как и FromClause.alias(), имя может быть оставлено как None, в этом случае во время компиляции запроса будет использоваться анонимный символ.

• recursive – если True, будет отображаться WITH RECURSIVE. Рекурсивное выражение общей таблицы предназначено для использования в сочетании с UNION ALL, чтобы вывести строки из уже выбранных.

• nesting – если True, то CTE будет отображаться локально в операторе, в котором на него ссылаются. Для более сложных сценариев можно также использовать метод HasCTE.add_cte() с параметром HasCTE.add_cte.nest_here для более тщательного контроля точного размещения конкретного CTE. … версия добавлена:: 1.4.24 .. seealso:: HasCTE.add_cte()

Ниже приведены два примера из документации PostgreSQL по адресу https://www.postgresql.org/docs/current/static/queries-with.html, а также дополнительные примеры.

Пример 1, нерекурсивный:

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()

Пример 2, С РЕКУРСИВНЫМ:

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()

Пример 3, апсерт с использованием UPDATE и INSERT с CTE:

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)

Пример 4, Вложение CTE (SQLAlchemy 1.4.24 и выше):

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"))

Приведенный выше запрос выведет второй CTE, вложенный в первый, показанный с инлайн-параметрами ниже как:

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

Тот же CTE можно настроить с помощью метода HasCTE.add_cte() следующим образом (SQLAlchemy 2.0 и выше):

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"))

Пример 5, нелинейный CTE (SQLAlchemy 1.4.28 и выше):

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)

Приведенный выше запрос выведет 2 UNION внутри рекурсивного CTE:

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

См.также

Query.cte() - ORM-версия HasCTE.cte().

method sqlalchemy.sql.expression.CompoundSelect.execution_options(**kw: Any) → Self¶

наследуется от Executable.execution_options() метода Executable

Установите для оператора параметры, не относящиеся к SQL, которые вступают в силу во время выполнения.

Параметры выполнения могут быть установлены в различных масштабах, в том числе на запрос, на соединение или на выполнение, с помощью таких методов, как Connection.execution_options() и параметров, которые принимают словарь параметров, таких как Connection.execute.execution_options и Session.execute.execution_options.

Основной характеристикой опции выполнения, в отличие от других видов опций, таких как опции загрузчика ORM, является то, что опции выполнения никогда не влияют на скомпилированный SQL запроса, только на то, что влияет на то, как вызывается сам SQL-запрос или как извлекаются результаты. То есть опции выполнения не являются частью того, что учитывается при компиляции SQL, и не считаются частью кэшированного состояния оператора.

Метод Executable.execution_options() является generative, как и в случае применения метода к объектам Engine и Query, что означает, что при вызове метода возвращается копия объекта, которая применяет заданные параметры к этой новой копии, но оставляет оригинал неизменным:

statement = select(table.c.x, table.c.y)
new_statement = statement.execution_options(my_option=True)

Исключением из этого поведения является объект Connection, где метод Connection.execution_options() явно не генеративный.

Типы параметров, которые могут быть переданы в Executable.execution_options() и другие связанные методы и словари параметров, включают параметры, которые явно потребляются SQLAlchemy Core или ORM, а также произвольные аргументы ключевых слов, не определенные SQLAlchemy, что означает, что методы и/или словари параметров могут использоваться для определяемых пользователем параметров, которые взаимодействуют с пользовательским кодом, который может обращаться к параметрам с помощью таких методов, как Executable.get_execution_options() и Connection.get_execution_options(), или в рамках выбранных крючков событий с помощью специального параметра события execution_options, такого как ConnectionEvents.before_execute.execution_options или ORMExecuteState.execution_options, например. g.:

from sqlalchemy import event

@event.listens_for(some_engine, "before_execute")
def _process_opt(conn, statement, multiparams, params, execution_options):
    "run a SQL function before invoking a statement"

    if execution_options.get("do_special_thing", False):
        conn.exec_driver_sql("run_special_function()")

В рамках опций, которые явно распознаются SQLAlchemy, большинство из них применяются к определенным классам объектов, а не к другим. К наиболее распространенным опциям выполнения относятся:

• Connection.execution_options.isolation_level - устанавливает уровень изоляции для соединения или класса соединений через Engine. Этот параметр принимается только Connection или Engine.

• Connection.execution_options.stream_results - указывает, что результаты должны быть получены с помощью курсора на стороне сервера; эта опция принимается Connection, параметром Connection.execute.execution_options на Connection.execute(), и дополнительно Executable.execution_options() на объекте оператора SQL, а также конструкциями ORM, такими как Session.execute().

• Connection.execution_options.compiled_cache - указывает словарь, который будет служить SQL compilation cache для Connection или Engine, а также для методов ORM, таких как Session.execute(). Может быть передан как None, чтобы отключить кэширование для утверждений. Эта опция не принимается Executable.execution_options(), поскольку нежелательно переносить кэш компиляции внутри объекта statement.

• Connection.execution_options.schema_translate_map - отображение имен схем, используемых функцией Schema Translate Map, принимаемых функциями Connection, Engine, Executable, а также конструкциями ORM, такими как Session.execute().

См.также

Connection.execution_options()

Connection.execute.execution_options

Session.execute.execution_options

Варианты выполнения ORM - документация по всем специфическим для ORM опциям исполнения

method sqlalchemy.sql.expression.CompoundSelect.exists() → Exists¶

наследуется от SelectBase.exists() метода SelectBase

Возвращает Exists представление этого selectable, которое может быть использовано как выражение столбца.

Возвращаемый объект является экземпляром Exists.

См.также

exists()

подзапросы EXISTS - в учебнике 2.0 style.

Добавлено в версии 1.4.

attribute sqlalchemy.sql.expression.CompoundSelect.exported_columns¶

наследуется от SelectBase.exported_columns атрибута SelectBase

ColumnCollection, который представляет «экспортированные» столбцы данного Selectable, не включая конструкции TextClause.

«Экспортируемые» столбцы для объекта SelectBase являются синонимом коллекции SelectBase.selected_columns.

Добавлено в версии 1.4.

См.также

Select.exported_columns

Selectable.exported_columns

FromClause.exported_columns

method sqlalchemy.sql.expression.CompoundSelect.fetch(count: _LimitOffsetType, with_ties: bool = False, percent: bool = False) → Self¶

наследуется от GenerativeSelect.fetch() метода GenerativeSelect

Возвращает новый selectable с заданным критерием FETCH FIRST.

Это числовое значение, которое обычно отображается как выражение FETCH {FIRST | NEXT} [ count ] {ROW | ROWS} {ONLY | WITH TIES} в результирующем select. Эта функциональность в настоящее время реализована для Oracle, PostgreSQL, MSSQL.

Используйте GenerativeSelect.offset() для указания смещения.

Примечание

Метод GenerativeSelect.fetch() заменит любую оговорку, примененную с помощью GenerativeSelect.limit().

Добавлено в версии 1.4.

Параметры:

• count – целочисленный параметр COUNT или выражение SQL, которое дает целочисленный результат. При percent=True это значение будет представлять процент возвращаемых строк, а не абсолютное значение. Передайте None, чтобы сбросить его.

• with_ties – Когда True, опция WITH TIES используется для возврата всех дополнительных строк, которые занимают последнее место в наборе результатов в соответствии с предложением ORDER BY. Параметр ORDER BY может быть обязательным в этом случае. По умолчанию используется False.

• percent – Когда True, count представляет собой процент от общего числа выбранных строк для возврата. По умолчанию False.

См.также

GenerativeSelect.limit()

GenerativeSelect.offset()

method sqlalchemy.sql.expression.CompoundSelect.get_execution_options() → _ExecuteOptions¶

наследуется от Executable.get_execution_options() метода Executable

Получить параметры, не относящиеся к SQL, которые будут действовать во время выполнения.

Добавлено в версии 1.3.

См.также

Executable.execution_options()

method sqlalchemy.sql.expression.CompoundSelect.get_label_style() → SelectLabelStyle¶

наследуется от GenerativeSelect.get_label_style() метода GenerativeSelect

Получение текущего стиля этикетки.

Добавлено в версии 1.4.

method sqlalchemy.sql.expression.CompoundSelect.group_by(_GenerativeSelect__first: Union[Literal[None, _NoArg.NO_ARG], _ColumnExpressionOrStrLabelArgument[Any]] = _NoArg.NO_ARG, *clauses: _ColumnExpressionOrStrLabelArgument[Any]) → Self¶

наследуется от GenerativeSelect.group_by() метода GenerativeSelect

Возвращает новый selectable с заданным списком критериев GROUP BY.

Все существующие настройки GROUP BY могут быть подавлены путем передачи None.

например:

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

Параметры:

*clauses – серию конструкций ColumnElement, которые будут использоваться для создания предложения GROUP BY.

См.также

Агрегатные функции с GROUP BY / HAVING - в Унифицированный учебник по SQLAlchemy

Упорядочивание или группировка по метке - в Унифицированный учебник по SQLAlchemy

method sqlalchemy.sql.expression.CompoundSelect.is_derived_from(fromclause: Optional[FromClause]) → bool¶

Возвращает True, если данный ReturnsRows является «производным» от данного FromClause.

Например, псевдоним таблицы является производным от этой таблицы.

method sqlalchemy.sql.expression.CompoundSelect.label(name: Optional[str]) → Label[Any]¶

наследуется от SelectBase.label() метода SelectBase

Возвращает «скалярное» представление этого selectable, встроенное в виде подзапроса с меткой.

См.также

SelectBase.scalar_subquery().

method sqlalchemy.sql.expression.CompoundSelect.lateral(name: Optional[str] = None) → LateralFromClause¶

наследуется от SelectBase.lateral() метода SelectBase

Возвращает ЛАТЕРАЛЬНЫЙ псевдоним данного Selectable.

Возвращаемым значением является конструкция Lateral, также предоставляемая функцией верхнего уровня lateral().

См.также

ЛАТЕРАЛЬНАЯ корреляция - обзор использования.

method sqlalchemy.sql.expression.CompoundSelect.limit(limit: _LimitOffsetType) → Self¶

наследуется от GenerativeSelect.limit() метода GenerativeSelect

Возвращает новый selectable с заданным критерием LIMIT.

Это числовое значение, которое обычно отображается как выражение LIMIT в результирующем select. Бэкенды, не поддерживающие LIMIT, будут пытаться обеспечить аналогичную функциональность.

Примечание

Метод GenerativeSelect.limit() заменит любую оговорку, примененную с помощью GenerativeSelect.fetch().

Параметры:

limit – целочисленный параметр LIMIT, или выражение SQL, которое дает целочисленный результат. Передайте None, чтобы сбросить его.

См.также

GenerativeSelect.fetch()

GenerativeSelect.offset()

method sqlalchemy.sql.expression.CompoundSelect.offset(offset: _LimitOffsetType) → Self¶

наследуется от GenerativeSelect.offset() метода GenerativeSelect

Возвращает новый selectable с заданным критерием OFFSET.

Это числовое значение, которое обычно отображается как выражение OFFSET в результирующем select. Бэкенды, не поддерживающие OFFSET, будут пытаться обеспечить аналогичную функциональность.

Параметры:

offset – целочисленный параметр OFFSET, или выражение SQL, которое дает целочисленный результат. Передайте None, чтобы сбросить его.

См.также

GenerativeSelect.limit()

GenerativeSelect.fetch()

method sqlalchemy.sql.expression.CompoundSelect.options(*options: ExecutableOption) → Self¶

наследуется от Executable.options() метода Executable

Примените варианты к этому утверждению.

В общем смысле опции - это любой вид объекта Python, который может быть интерпретирован компилятором SQL для оператора. Эти опции могут потребляться конкретными диалектами или конкретными видами компиляторов.

Наиболее известным видом опций являются опции уровня ORM, которые применяют «жаждущую загрузку» и другие способы загрузки к запросам ORM. Однако теоретически опции могут использоваться и для многих других целей.

Для получения информации о конкретных видах опций для конкретных видов утверждений, обратитесь к документации для этих объектов опций.

Изменено в версии 1.4: - added Executable.options() to Core statement objects towards the goal of allowing unified Core / ORM querying capabilities.

См.также

Варианты загрузки колонн - относится к опциям, специфичным для использования ORM-запросов

Загрузка отношений с помощью опций загрузчика - относится к опциям, специфичным для использования ORM-запросов

method sqlalchemy.sql.expression.CompoundSelect.order_by(_GenerativeSelect__first: Union[Literal[None, _NoArg.NO_ARG], _ColumnExpressionOrStrLabelArgument[Any]] = _NoArg.NO_ARG, *clauses: _ColumnExpressionOrStrLabelArgument[Any]) → Self¶

наследуется от GenerativeSelect.order_by() метода GenerativeSelect

Возвращает новый selectable с заданным списком критериев ORDER BY.

например:

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

Вызов этого метода несколько раз эквивалентен вызову его один раз с конкатенацией всех пунктов. Все существующие критерии ORDER BY могут быть отменены, передав None сам по себе. Новые критерии ORDER BY могут быть добавлены путем повторного вызова Query.order_by(), например:

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

Параметры:

*clauses – серию конструкций ColumnElement, которые будут использоваться для создания предложения ORDER BY.

См.также

ПОРЯДОК СЛЕДОВАНИЯ - в Унифицированный учебник по SQLAlchemy

Упорядочивание или группировка по метке - в Унифицированный учебник по SQLAlchemy

method sqlalchemy.sql.expression.CompoundSelect.replace_selectable(old: FromClause, alias: Alias) → Self¶

наследуется от Selectable.replace_selectable() метода Selectable

Заменяет все вхождения FromClause „old“ на данный объект Alias, возвращая копию этого FromClause.

Не рекомендуется, начиная с версии 1.4: Метод Selectable.replace_selectable() является устаревшим и будет удален в одном из будущих выпусков. Аналогичная функциональность доступна через модуль sqlalchemy.sql.visitors.

method sqlalchemy.sql.expression.CompoundSelect.scalar_subquery() → ScalarSelect[Any]¶

наследуется от SelectBase.scalar_subquery() метода SelectBase

Возвращает «скалярное» представление этого selectable, которое может быть использовано в качестве выражения столбца.

Возвращаемый объект является экземпляром ScalarSelect.

Как правило, оператор select, имеющий только один столбец в пункте columns, может быть использован в качестве скалярного выражения. Затем скалярный подзапрос можно использовать в пункте WHERE или в пункте columns заключающего оператора SELECT.

Обратите внимание, что скалярный подзапрос отличается от подзапроса уровня FROM, который может быть получен с помощью метода SelectBase.subquery().

См.также

Скалярные и коррелированные подзапросы - в учебнике 2.0

method sqlalchemy.sql.expression.CompoundSelect.select(*arg: Any, **kw: Any) → Select¶

наследуется от SelectBase.select() метода SelectBase

Не рекомендуется, начиная с версии 1.4: Метод SelectBase.select() является устаревшим и будет удален в будущем выпуске; этот метод неявно создает подзапрос, который должен быть явным. Пожалуйста, сначала вызовите SelectBase.subquery(), чтобы создать подзапрос, который затем можно будет выбрать.

attribute sqlalchemy.sql.expression.CompoundSelect.selected_columns¶

ColumnCollection, представляющий столбцы, которые данный оператор SELECT или аналогичная конструкция возвращает в свой набор результатов, не включая конструкции TextClause.

Для CompoundSelect атрибут CompoundSelect.selected_columns возвращает выбранные столбцы первого оператора SELECT, содержащегося в серии операторов в рамках операции set.

См.также

Select.selected_columns

Добавлено в версии 1.4.

method sqlalchemy.sql.expression.CompoundSelect.self_group(against: Optional[OperatorType] = None) → GroupedElement¶

Примените «группировку» к этому ClauseElement.

Этот метод переопределяется подклассами для возврата конструкции «группировки», т.е. круглой скобки. В частности, она используется «бинарными» выражениями для обеспечения группировки вокруг себя при помещении в более крупное выражение, а также конструкциями select() при помещении в предложение FROM другого select(). (Обратите внимание, что подзапросы обычно следует создавать с помощью метода Select.alias(), поскольку многие платформы требуют, чтобы вложенные операторы SELECT были именованными).

Поскольку выражения составляются вместе, применение self_group() происходит автоматически - код конечного пользователя никогда не должен использовать этот метод напрямую. Обратите внимание, что в конструкциях клаузул SQLAlchemy учитывается приоритет операторов - поэтому скобки могут не понадобиться, например, в выражении x OR (y AND z) - AND имеет приоритет над OR.

Базовый метод self_group() ClauseElement просто возвращает self.

method sqlalchemy.sql.expression.CompoundSelect.set_label_style(style: SelectLabelStyle) → CompoundSelect¶

Возвращает новый selectable с указанным стилем метки.

Существует три «стиля этикеток»: SelectLabelStyle.LABEL_STYLE_DISAMBIGUATE_ONLY, SelectLabelStyle.LABEL_STYLE_TABLENAME_PLUS_COL и SelectLabelStyle.LABEL_STYLE_NONE. По умолчанию используется стиль SelectLabelStyle.LABEL_STYLE_TABLENAME_PLUS_COL.

В современной SQLAlchemy, как правило, нет необходимости менять стиль маркировки, поскольку метки на выражение более эффективно используются с помощью метода ColumnElement.label(). В прошлых версиях LABEL_STYLE_TABLENAME_PLUS_COL использовался для однозначного определения одноименных колонок из разных таблиц, псевдонимов или подзапросов; более новый LABEL_STYLE_DISAMBIGUATE_ONLY теперь применяет метки только к именам, которые конфликтуют с существующими именами, так что влияние этой маркировки минимально.

Разграничение необходимо для того, чтобы при создании подзапроса все выражения столбцов были доступны из данной коллекции FromClause.c.

Добавлено в версии 1.4: - the GenerativeSelect.set_label_style() method replaces the previous combination of .apply_labels(), .with_labels() and use_labels=True methods and/or parameters.

См.также

LABEL_STYLE_DISAMBIGUATE_ONLY

LABEL_STYLE_TABLENAME_PLUS_COL

LABEL_STYLE_NONE

LABEL_STYLE_DEFAULT

method sqlalchemy.sql.expression.CompoundSelect.slice(start: int, stop: int) → Self¶

наследуется от GenerativeSelect.slice() метода GenerativeSelect

Примените LIMIT / OFFSET к этому утверждению на основе среза.

Индексы start и stop ведут себя как аргументы встроенной в Python функции range(). Этот метод является альтернативой использованию LIMIT/OFFSET для получения фрагмента запроса.

Например,

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

отображается как

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

Примечание

Метод GenerativeSelect.slice() заменит любую оговорку, примененную с помощью GenerativeSelect.fetch().

Добавлено в версии 1.4: Добавлен метод GenerativeSelect.slice(), обобщенный из ORM.

См.также

GenerativeSelect.limit()

GenerativeSelect.offset()

GenerativeSelect.fetch()

method sqlalchemy.sql.expression.CompoundSelect.subquery(name: Optional[str] = None) → Subquery¶

наследуется от SelectBase.subquery() метода SelectBase

Возвращает подзапрос данного SelectBase.

С точки зрения SQL подзапрос - это именованная конструкция со скобками, которая может быть помещена в предложение FROM другого оператора SELECT.

Учитывая оператор SELECT, такой как:

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

Приведенное выше утверждение может выглядеть следующим образом:

SELECT table.id, table.name FROM table

Форма подзапроса сама по себе отображается таким же образом, однако при вставке в предложение FROM другого оператора SELECT она становится именованным подэлементом:

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

Вышеуказанное переводится как:

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

Исторически, SelectBase.subquery() эквивалентен вызову метода FromClause.alias() на объекте FROM; однако, поскольку объект SelectBase не является непосредственно объектом FROM, метод SelectBase.subquery() обеспечивает более четкую семантику.

Добавлено в версии 1.4.

method sqlalchemy.sql.expression.CompoundSelect.with_for_update(*, nowait: bool = False, read: bool = False, of: Optional[_ForUpdateOfArgument] = None, skip_locked: bool = False, key_share: bool = False) → Self¶

наследуется от GenerativeSelect.with_for_update() метода GenerativeSelect

Укажите условие FOR UPDATE для этого GenerativeSelect.

Например:

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

В базе данных, например, PostgreSQL или Oracle, вышеприведенное выражение будет выглядеть так:

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

на других бэкендах опция nowait игнорируется и вместо нее выдается:

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

При вызове без аргументов утверждение будет отображаться с суффиксом FOR UPDATE. Затем могут быть предоставлены дополнительные аргументы, которые позволяют использовать общие варианты, специфичные для базы данных.

Параметры:

• nowait – boolean; будет отображать FOR UPDATE NOWAIT на диалектах Oracle и PostgreSQL.

• read – boolean; будет отображать LOCK IN SHARE MODE на MySQL, FOR SHARE на PostgreSQL. На PostgreSQL, в сочетании с nowait, будет отображаться FOR SHARE NOWAIT.

• of – SQL-выражение или список элементов SQL-выражения (обычно Column объектов или совместимое выражение, для некоторых бэкендов может быть и табличным выражением), которое будет отображаться в предложение FOR UPDATE OF; поддерживается PostgreSQL, Oracle, некоторыми версиями MySQL и, возможно, другими. Может отображаться как таблица или как столбец в зависимости от бэкенда.

• skip_locked – boolean, будет выводить FOR UPDATE SKIP LOCKED на диалектах Oracle и PostgreSQL или FOR SHARE SKIP LOCKED, если также указано read=True.

• key_share – boolean, будет отображать FOR NO KEY UPDATE, или в сочетании с read=True будет отображать FOR KEY SHARE, на диалекте PostgreSQL.

class sqlalchemy.sql.expression.CTE¶

Представьте общее табличное выражение.

Объект CTE получается с помощью метода SelectBase.cte() из любого оператора SELECT. Менее часто доступный синтаксис также позволяет использовать метод HasCTE.cte(), присутствующий в конструкциях DML, таких как Insert, Update и Delete. Подробности использования метода для CTE см. в разделе Метод HasCTE.cte().

См.также

Подзапросы и CTE - в учебнике 2.0

HasCTE.cte() - примеры стилей вызова

Members

alias(), union(), union_all()

Классная подпись

class sqlalchemy.sql.expression.CTE (sqlalchemy.sql.roles.DMLTableRole, sqlalchemy.sql.roles.IsCTERole, sqlalchemy.sql.expression.Generative, sqlalchemy.sql.expression.HasPrefixes, sqlalchemy.sql.expression.HasSuffixes, sqlalchemy.sql.expression.AliasedReturnsRows)

method sqlalchemy.sql.expression.CTE.alias(name: Optional[str] = None, flat: bool = False) → CTE¶

Возвращает Alias данного CTE.

Этот метод является специфической для CTE специализацией метода FromClause.alias().

См.также

Использование псевдонимов

alias()

method sqlalchemy.sql.expression.CTE.union(*other: _SelectStatementForCompoundArgument) → CTE¶

Возвращает новый CTE с SQL UNION исходного CTE против заданных selectables, представленных в качестве позиционных аргументов.

Параметры:

*other – один или несколько элементов, с помощью которых можно создать объединение. … versionchanged:: 1.4.28 теперь принимаются множественные элементы.

См.также

HasCTE.cte() - примеры стилей вызова

method sqlalchemy.sql.expression.CTE.union_all(*other: _SelectStatementForCompoundArgument) → CTE¶

Возвращает новый CTE с SQL UNION ALL исходного CTE против заданных selectables, представленных в качестве позиционных аргументов.

Параметры:

*other – один или несколько элементов, с помощью которых можно создать объединение. … versionchanged:: 1.4.28 теперь принимаются множественные элементы.

См.также

HasCTE.cte() - примеры стилей вызова

class sqlalchemy.sql.expression.Executable¶

Пометить ClauseElement как поддерживающий выполнение.

Executable является суперклассом для всех объектов типа «statement», включая select(), delete(), update(), insert(), text().

Members

execution_options(), get_execution_options(), options()

Классная подпись

класс sqlalchemy.sql.expression.Executable (sqlalchemy.sql.roles.StatementRole)

method sqlalchemy.sql.expression.Executable.execution_options(**kw: Any) → Self¶

Установите для оператора параметры, не относящиеся к SQL, которые вступают в силу во время выполнения.

Параметры выполнения могут быть установлены в различных масштабах, в том числе на запрос, на соединение или на выполнение, с помощью таких методов, как Connection.execution_options() и параметров, которые принимают словарь параметров, таких как Connection.execute.execution_options и Session.execute.execution_options.

Основной характеристикой опции выполнения, в отличие от других видов опций, таких как опции загрузчика ORM, является то, что опции выполнения никогда не влияют на скомпилированный SQL запроса, только на то, что влияет на то, как вызывается сам SQL-запрос или как извлекаются результаты. То есть опции выполнения не являются частью того, что учитывается при компиляции SQL, и не считаются частью кэшированного состояния оператора.

Метод Executable.execution_options() является generative, как и в случае применения метода к объектам Engine и Query, что означает, что при вызове метода возвращается копия объекта, которая применяет заданные параметры к этой новой копии, но оставляет оригинал неизменным:

statement = select(table.c.x, table.c.y)
new_statement = statement.execution_options(my_option=True)

Исключением из этого поведения является объект Connection, где метод Connection.execution_options() явно не генеративный.

Типы параметров, которые могут быть переданы в Executable.execution_options() и другие связанные методы и словари параметров, включают параметры, которые явно потребляются SQLAlchemy Core или ORM, а также произвольные аргументы ключевых слов, не определенные SQLAlchemy, что означает, что методы и/или словари параметров могут использоваться для определяемых пользователем параметров, которые взаимодействуют с пользовательским кодом, который может обращаться к параметрам с помощью таких методов, как Executable.get_execution_options() и Connection.get_execution_options(), или в рамках выбранных крючков событий с помощью специального параметра события execution_options, такого как ConnectionEvents.before_execute.execution_options или ORMExecuteState.execution_options, например. g.:

from sqlalchemy import event

@event.listens_for(some_engine, "before_execute")
def _process_opt(conn, statement, multiparams, params, execution_options):
    "run a SQL function before invoking a statement"

    if execution_options.get("do_special_thing", False):
        conn.exec_driver_sql("run_special_function()")

В рамках опций, которые явно распознаются SQLAlchemy, большинство из них применяются к определенным классам объектов, а не к другим. К наиболее распространенным опциям выполнения относятся:

• Connection.execution_options.isolation_level - устанавливает уровень изоляции для соединения или класса соединений через Engine. Этот параметр принимается только Connection или Engine.

• Connection.execution_options.stream_results - указывает, что результаты должны быть получены с помощью курсора на стороне сервера; эта опция принимается Connection, параметром Connection.execute.execution_options на Connection.execute(), и дополнительно Executable.execution_options() на объекте оператора SQL, а также конструкциями ORM, такими как Session.execute().

• Connection.execution_options.compiled_cache - указывает словарь, который будет служить SQL compilation cache для Connection или Engine, а также для методов ORM, таких как Session.execute(). Может быть передан как None, чтобы отключить кэширование для утверждений. Эта опция не принимается Executable.execution_options(), поскольку нежелательно переносить кэш компиляции внутри объекта statement.

• Connection.execution_options.schema_translate_map - отображение имен схем, используемых функцией Schema Translate Map, принимаемых функциями Connection, Engine, Executable, а также конструкциями ORM, такими как Session.execute().

См.также

Connection.execution_options()

Connection.execute.execution_options

Session.execute.execution_options

Варианты выполнения ORM - документация по всем специфическим для ORM опциям исполнения

method sqlalchemy.sql.expression.Executable.get_execution_options() → _ExecuteOptions¶

Получить параметры, не относящиеся к SQL, которые будут действовать во время выполнения.

Добавлено в версии 1.3.

См.также

Executable.execution_options()

method sqlalchemy.sql.expression.Executable.options(*options: ExecutableOption) → Self¶

Примените варианты к этому утверждению.

В общем смысле опции - это любой вид объекта Python, который может быть интерпретирован компилятором SQL для оператора. Эти опции могут потребляться конкретными диалектами или конкретными видами компиляторов.

Наиболее известным видом опций являются опции уровня ORM, которые применяют «жаждущую загрузку» и другие способы загрузки к запросам ORM. Однако теоретически опции могут использоваться и для многих других целей.

Для получения информации о конкретных видах опций для конкретных видов утверждений, обратитесь к документации для этих объектов опций.

Изменено в версии 1.4: - added Executable.options() to Core statement objects towards the goal of allowing unified Core / ORM querying capabilities.

См.также

Варианты загрузки колонн - относится к опциям, специфичным для использования ORM-запросов

Загрузка отношений с помощью опций загрузчика - относится к опциям, специфичным для использования ORM-запросов

class sqlalchemy.sql.expression.Exists¶

Представляет собой клаузулу EXISTS.

Описание использования см. в exists().

Клаузулу EXISTS можно также построить из экземпляра select(), вызвав SelectBase.exists().

Members

correlate(), correlate_except(), inherit_cache, select(), select_from(), where()

Классная подпись

класс sqlalchemy.sql.expression.Exists (sqlalchemy.sql.expression.UnaryExpression)

method sqlalchemy.sql.expression.Exists.correlate(*fromclauses: Union[Literal[None, False], _FromClauseArgument]) → Self¶

Примените корреляцию к подзапросу, отмеченному этим Exists.

См.также

ScalarSelect.correlate()

method sqlalchemy.sql.expression.Exists.correlate_except(*fromclauses: Union[Literal[None, False], _FromClauseArgument]) → Self¶

Примените корреляцию к подзапросу, отмеченному этим Exists.

См.также

ScalarSelect.correlate_except()

attribute sqlalchemy.sql.expression.Exists.inherit_cache: Optional[bool] = True¶

Укажите, должен ли данный экземпляр HasCacheKey использовать схему генерации ключей кэша, используемую его непосредственным суперклассом.

По умолчанию атрибут имеет значение None, что указывает на то, что конструкция еще не приняла во внимание целесообразность ее участия в кэшировании; функционально это эквивалентно установке значения False, за исключением того, что при этом выдается предупреждение.

Этот флаг может быть установлен в True на определенном классе, если SQL, соответствующий объекту, не изменяется на основе атрибутов, локальных для этого класса, а не его суперкласса.

См.также

Включение поддержки кэширования для пользовательских конструкций - общие направляющие для установки атрибута HasCacheKey.inherit_cache для сторонних или определенных пользователем конструкций SQL.

method sqlalchemy.sql.expression.Exists.select() → Select¶

Возвращает SELECT данного Exists.

например:

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

Это приведет к появлению сообщения, напоминающего:

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

См.также

select() - метод общего назначения, позволяющий создавать произвольные списки столбцов.

method sqlalchemy.sql.expression.Exists.select_from(*froms: FromClause) → Self¶

Возвращает новую конструкцию Exists, применяющую данное выражение к методу Select.select_from() содержащегося оператора select.

Примечание

обычно предпочтительнее сначала построить оператор Select, включая желаемое предложение WHERE, а затем использовать метод SelectBase.exists() для создания объекта Exists сразу.

method sqlalchemy.sql.expression.Exists.where(*clause: _ColumnExpressionArgument[bool]) → Self¶

Возвращает новую конструкцию exists() с заданным выражением, добавленным к пункту WHERE, присоединенным к существующему пункту через AND, если таковой имеется.

Примечание

обычно предпочтительнее сначала построить оператор Select, включая желаемое предложение WHERE, а затем использовать метод SelectBase.exists() для создания объекта Exists сразу.

class sqlalchemy.sql.expression.FromClause¶

Представляет собой элемент, который может быть использован в пункте FROM оператора SELECT.

Наиболее распространенными формами FromClause являются конструкции Table и select(). Ключевые характеристики, общие для всех объектов FromClause, включают:

• коллекция c, которая обеспечивает доступ по имени к коллекции объектов ColumnElement.

• атрибут primary_key, который представляет собой коллекцию всех тех объектов ColumnElement, которые указывают на флаг primary_key.

• Методы генерации различных производных клаузулы «от», включая FromClause.alias(), FromClause.join(), FromClause.select().

Members

alias(), c, columns, description, entity_namespace, exported_columns, foreign_keys, is_derived_from(), join(), outerjoin(), primary_key, schema, select(), tablesample()

Классная подпись

класс sqlalchemy.sql.expression.FromClause (sqlalchemy.sql.roles.AnonymizedFromClauseRole, sqlalchemy.sql.expression.Selectable)

method sqlalchemy.sql.expression.FromClause.alias(name: Optional[str] = None, flat: bool = False) → NamedFromClause¶

Возвращает псевдоним данного FromClause.

Например:

a2 = some_table.alias('a2')

Приведенный выше код создает объект Alias, который можно использовать как предложение FROM в любом операторе SELECT.

См.также

Использование псевдонимов

alias()

attribute sqlalchemy.sql.expression.FromClause.c¶

Синоним для FromClause.columns

Результат:

a ColumnCollection

attribute sqlalchemy.sql.expression.FromClause.columns¶

Коллекция объектов ColumnElement, поддерживаемых данным FromClause, основанная на именах.

Коллекция columns, или c, является шлюзом для построения SQL-выражений, использующих столбцы, связанные с таблицей или другими выбираемыми столбцами:

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

Результат:

объект ColumnCollection.

attribute sqlalchemy.sql.expression.FromClause.description¶

Краткое описание этого FromClause.

Используется в основном для форматирования сообщений об ошибках.

attribute sqlalchemy.sql.expression.FromClause.entity_namespace¶

Возвращает пространство имен, используемое для доступа на основе имен в выражениях SQL.

Это пространство имен, которое используется для разрешения выражений типа «filter_by()», таких как:

stmt.filter_by(address='some address')

По умолчанию используется коллекция .c, однако внутренне ее можно переопределить с помощью аннотации «entity_namespace» для получения альтернативных результатов.

attribute sqlalchemy.sql.expression.FromClause.exported_columns¶

ColumnCollection, который представляет «экспортированные» столбцы данного Selectable.

«Экспортируемые» столбцы для объекта FromClause являются синонимом коллекции FromClause.columns.

Добавлено в версии 1.4.

См.также

Selectable.exported_columns

SelectBase.exported_columns

attribute sqlalchemy.sql.expression.FromClause.foreign_keys¶

Возвращает коллекцию объектов маркеров ForeignKey, на которые ссылается данный FromClause.

Каждый ForeignKey является членом Table широкого ForeignKeyConstraint.

См.также

Table.foreign_key_constraints

method sqlalchemy.sql.expression.FromClause.is_derived_from(fromclause: Optional[FromClause]) → bool¶

Возвращает True, если данный FromClause является «производным» от данного FromClause.

Например, псевдоним таблицы является производным от этой таблицы.

method sqlalchemy.sql.expression.FromClause.join(right: _FromClauseArgument, onclause: Optional[_ColumnExpressionArgument[bool]] = None, isouter: bool = False, full: bool = False) → Join¶

Возвращает Join из данного FromClause в другой FromClause.

Например:

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)

будет выдавать SQL примерно следующего содержания:

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

Параметры:

• right – правая сторона соединения; это любой объект FromClause, например, объект Table, а также может быть совместимым с selectable объектом, например, ORM-mapped class.

• onclause – выражение SQL, представляющее предложение ON для объединения. Если оставить значение None, FromClause.join() попытается объединить две таблицы на основе отношения внешнего ключа.

• isouter – если True, отображает LEFT OUTER JOIN вместо JOIN.

• full – если True, отображает FULL OUTER JOIN, вместо LEFT OUTER JOIN. Подразумевает FromClause.join.isouter.

См.также

join() - автономная функция

Join - тип производимого объекта

method sqlalchemy.sql.expression.FromClause.outerjoin(right: _FromClauseArgument, onclause: Optional[_ColumnExpressionArgument[bool]] = None, full: bool = False) → Join¶

Возвращает Join из данного FromClause в другой FromClause, с флагом «isouter», установленным в True.

Например:

from sqlalchemy import outerjoin

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

Вышесказанное эквивалентно:

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

Параметры:

• right – правая сторона соединения; это любой объект FromClause, например, объект Table, а также может быть совместимым с selectable объектом, например, ORM-mapped class.

• onclause – выражение SQL, представляющее предложение ON для объединения. Если оставить значение None, FromClause.join() попытается объединить две таблицы на основе отношения внешнего ключа.

• full – если True, отображает ПОЛНОЕ ВНЕШНЕЕ СОЕДИНЕНИЕ вместо ЛЕВОГО ВНЕШНЕГО СОЕДИНЕНИЯ.

См.также

FromClause.join()

Join

attribute sqlalchemy.sql.expression.FromClause.primary_key¶

Возвращает итерируемую коллекцию объектов Column, составляющих первичный ключ данного _selectable.FromClause.

Для объекта Table эта коллекция представлена объектом PrimaryKeyConstraint, который сам является итерируемой коллекцией объектов Column.

attribute sqlalchemy.sql.expression.FromClause.schema: Optional[str] = None¶

Определите атрибут „schema“ для данного FromClause.

Обычно это None для большинства объектов, за исключением Table, где оно принимается как значение аргумента Table.schema.

method sqlalchemy.sql.expression.FromClause.select() → Select¶

Возвращает SELECT данного FromClause.

например:

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

См.также

select() - метод общего назначения, позволяющий создавать произвольные списки столбцов.

method sqlalchemy.sql.expression.FromClause.tablesample(sampling: Union[float, Function[Any]], name: Optional[str] = None, seed: Optional[roles.ExpressionElementRole[Any]] = None) → TableSample¶

Возвращает псевдоним TABLESAMPLE данного FromClause.

Возвращаемым значением является конструкция TableSample, также предоставляемая функцией верхнего уровня tablesample().

См.также

tablesample() - руководство по использованию и параметры