Элементы столбцов и выражения¶

Выбор с помощью текстовых выражений столбцов

try_cast() - альтернатива CAST, которая приводит к NULL, если приведение не удалось, вместо того, чтобы выдать ошибку. Поддерживается только некоторыми диалектами.

type_coerce() - альтернатива CAST, которая коэрцитирует тип только на стороне Python, что часто достаточно для генерации правильного SQL и коэрцитирования данных.

function sqlalchemy.sql.expression.column(text: str, type_: Optional[_TypeEngineArgument[_T]] = None, is_literal: bool = False, _selectable: Optional[FromClause] = None) → ColumnClause[_T]¶

Произвести объект ColumnClause.

ColumnClause является облегченным аналогом класса Column. Функция column() может быть вызвана только именем, как в:

from sqlalchemy import column

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

Вышеприведенный оператор выдаст SQL вида:

SELECT id, name FROM user

После создания column() может использоваться как любой другой элемент выражения SQL, например, в конструкциях select():

from sqlalchemy.sql import column

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

Предполагается, что текст, обрабатываемый column(), будет обрабатываться как имя колонки базы данных; если строка содержит смешанный регистр, специальные символы или совпадает с известным зарезервированным словом на целевом бэкенде, выражение колонки будет отображаться с использованием поведения цитирования, определенного бэкендом. Чтобы получить текстовое выражение SQL, которое будет отображаться точно без кавычек, используйте вместо него literal_column() или передайте True в качестве значения column.is_literal. Кроме того, полные SQL-выражения лучше всего обрабатывать с помощью конструкции text().

column() можно использовать в виде таблицы, комбинируя ее с функцией table() (которая является облегченным аналогом Table) для создания рабочей конструкции таблицы с минимальным количеством шаблонов:

from sqlalchemy import table, column, select

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

stmt = select(user.c.description).where(user.c.name == 'wendy')

Конструкция column() / table(), как показано выше, может быть создана в произвольном порядке и не связана ни с MetaData, ни с DDL, ни с событиями, в отличие от своего аналога Table.

Параметры:

text – текст элемента.
type – TypeEngine объект, который может связать данный ColumnClause с типом.
is_literal – если True, то предполагается, что ColumnClause является точным выражением, которое будет передано на вывод без применения правил кавычек, независимо от настроек, учитывающих регистр. функция literal_column() по существу вызывает column(), передавая is_literal=True.

См.также

class sqlalchemy.sql.expression.custom_op¶

Представьте «пользовательский» оператор.

custom_op обычно инстанцируется, когда методы Operators.op() или Operators.bool_op() используются для создания пользовательского оператора callable. Класс также может быть использован непосредственно при программном построении выражений. Например, для представления операции «факториал»:

from sqlalchemy.sql import UnaryExpression
from sqlalchemy.sql import operators
from sqlalchemy import Numeric

unary = UnaryExpression(table.c.somecolumn,
        modifier=operators.custom_op("!"),
        type_=Numeric)

См.также

ColumnElement.distinct()

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

класс sqlalchemy.sql.expression.custom_op (sqlalchemy.sql.expression.OperatorType, typing.Generic)

function sqlalchemy.sql.expression.distinct(expr: _ColumnExpressionArgument[_T]) → UnaryExpression[_T]¶

Произведите унарное предложение DISTINCT на уровне столбца-выражения.

Применяет ключевое слово DISTINCT к выражению отдельного столбца и обычно содержится в агрегатной функции, как в:

from sqlalchemy import distinct, func
stmt = select(func.count(distinct(users_table.c.name)))

Вышеприведенные действия приведут к выражению, похожему на:

SELECT COUNT(DISTINCT name) FROM user

Функция distinct() также доступна как метод на уровне столбцов, например ColumnElement.distinct(), как в:

stmt = select(func.count(users_table.c.name.distinct()))

Оператор distinct() отличается от метода Select.distinct() в Select, который производит оператор SELECT, причем DISTINCT применяется к набору результатов в целом, например, к выражению SELECT DISTINCT. Дополнительную информацию см. в этом методе.

См.также

Select.distinct()

func

function sqlalchemy.sql.expression.extract(field: str, expr: _ColumnExpressionArgument[Any]) → Extract¶

Возвращает конструкцию Extract.

Обычно это доступно как extract(), так и func.extract из пространства имен func.

Параметры:

field – Поле для извлечения.
expr – Столбец или скалярное выражение Python, служащее правой частью выражения EXTRACT.

Например:

from sqlalchemy import extract
from sqlalchemy import table, column

logged_table = table("user",
        column("id"),
        column("date_created"),
)

stmt = select(logged_table.c.id).where(
    extract("YEAR", logged_table.c.date_created) == 2021
)

В приведенном выше примере оператор используется для выбора идентификаторов из базы данных, где компонент YEAR совпадает с определенным значением.

Аналогичным образом можно также выбрать извлеченный компонент:

stmt = select(
    extract("YEAR", logged_table.c.date_created)
).where(logged_table.c.id == 1)

Реализация EXTRACT может отличаться в разных бэкендах баз данных. Пользователям рекомендуется ознакомиться с документацией к своей базе данных.

function sqlalchemy.sql.expression.false() → False_¶

Возвращает конструкцию False_.

Например:

>>> from sqlalchemy import false
>>> print(select(t.c.x).where(false()))
{printsql}SELECT x FROM t WHERE false

Бэкенд, не поддерживающий константы true/false, будет отображать выражение в виде 1 или 0:

>>> print(select(t.c.x).where(false()))
{printsql}SELECT x FROM t WHERE 0 = 1

Константы true() и false() также поддерживают функцию «короткого замыкания» внутри конъюнкции and_() или or_():

>>> print(select(t.c.x).where(or_(t.c.x > 5, true())))
{printsql}SELECT x FROM t WHERE true{stop}

>>> print(select(t.c.x).where(and_(t.c.x > 5, false())))
{printsql}SELECT x FROM t WHERE false{stop}

См.также

true()

sqlalchemy.sql.expression.func = <sqlalchemy.sql.functions._FunctionGenerator object>¶

Генерируйте выражения функций SQL.

func - это специальный экземпляр объекта, который генерирует функции SQL на основе атрибутов, основанных на имени, например:

>>> print(func.count(1))
{printsql}count(:param_1)

Возвращаемый объект является экземпляром Function, это ориентированный на столбец элемент SQL, как и любой другой, и используется именно таким образом:

>>> print(select(func.count(table.c.id)))
{printsql}SELECT count(sometable.id) FROM sometable

Для функции func может быть задано любое имя. Если имя функции неизвестно SQLAlchemy, она будет отображена точно так, как есть. Для обычных SQL-функций, которые известны SQLAlchemy, имя может быть интерпретировано как генеральная функция, которая будет скомпилирована соответствующим образом для целевой базы данных:

>>> print(func.current_timestamp())
{printsql}CURRENT_TIMESTAMP

Для вызова функций, которые присутствуют в пакетах, разделенных точками, укажите их таким же образом:

>>> print(func.stats.yield_curve(5, 10))
{printsql}stats.yield_curve(:yield_curve_1, :yield_curve_2)

SQLAlchemy может быть осведомлена о возвращаемом типе функций, чтобы обеспечить специфическое для типа лексическое поведение и поведение, основанное на результатах. Например, чтобы убедиться, что строковая функция возвращает значение Unicode и в выражениях рассматривается как строка, укажите в качестве типа Unicode:

>>> print(func.my_string(u'hi', type_=Unicode) + ' ' +
...       func.my_string(u'there', type_=Unicode))
{printsql}my_string(:my_string_1) || :my_string_2 || my_string(:my_string_3)

Объект, возвращаемый вызовом func, обычно является экземпляром Function. Этот объект соответствует интерфейсу «столбец», включая функции сравнения и маркировки. Объект также может быть передан методу Connectable.execute() из Connection или Engine, где он будет сначала обернут внутри оператора SELECT:

print(connection.execute(func.current_timestamp()).scalar())

В нескольких исключительных случаях аксессор func перенаправит имя во встроенное выражение, такое как cast() или extract(), поскольку эти имена имеют хорошо известный смысл, но не совсем то же самое, что «функции» с точки зрения SQLAlchemy.

Функции, которые интерпретируются как «общие», умеют автоматически вычислять свой возвращаемый тип. Список известных родовых функций приведен в разделе SQL и общие функции.

Примечание

Конструкция func имеет лишь ограниченную поддержку для вызова автономных «хранимых процедур», особенно тех, которые имеют особые параметры.

Подробнее о том, как использовать метод уровня DBAPI Вызов хранимых процедур и функций, определяемых пользователем для полностью традиционных хранимых процедур, смотрите в разделе callproc().

См.также

Работа с функциями SQL - в Унифицированный учебник по SQLAlchemy

Function

function sqlalchemy.sql.expression.lambda_stmt(lmb: Callable[[], Any], enable_tracking: bool = True, track_closure_variables: bool = True, track_on: Optional[object] = None, global_track_bound_values: bool = True, track_bound_values: bool = True, lambda_cache: Optional[MutableMapping[Tuple[Any, ...], Union[NonAnalyzedFunction, AnalyzedFunction]]] = None) → StatementLambdaElement¶

Создайте SQL-оператор, который кэшируется как лямбда.

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

Например:

from sqlalchemy import lambda_stmt

stmt = lambda_stmt(lambda: table.select())
stmt += lambda s: s.where(table.c.id == 5)

result = connection.execute(stmt)

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

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

Параметры:

lmb – функция Python, обычно лямбда, которая не принимает аргументов и возвращает конструкцию выражения SQL
enable_tracking – при False все сканирование данной лямбды на предмет изменения закрывающих переменных или связанных параметров отключается. Используется для лямбды, которая выдает одинаковые результаты во всех случаях без параметризации.
track_closure_variables – если False, изменения в закрывающих переменных внутри лямбды не будут сканироваться. Используется для лямбды, состояние закрывающих переменных которой никогда не изменит структуру SQL, возвращаемую лямбдой.
track_bound_values – если False, отслеживание связанных параметров будет отключено для данной лямбды. Используется для лямбды, которая либо не производит никаких связанных значений, либо начальные связанные значения никогда не меняются.
global_track_bound_values – если False, отслеживание связанных параметров будет отключено для всего оператора, включая дополнительные ссылки, добавленные с помощью метода StatementLambdaElement.add_criteria().
lambda_cache – словарь или другой объект типа mapping, в котором будет храниться информация о Python-коде лямбды, а также отслеживаемые переменные закрытия в самой лямбде. По умолчанию используется глобальный кэш LRU. Этот кэш не зависит от «compiled_cache», используемого объектом Connection.

См.также

Использование ламбдас для значительного увеличения скорости создания операторов

function sqlalchemy.sql.expression.literal(value: Any, type_: Optional[_TypeEngineArgument[_T]] = None, literal_execute: bool = False) → BindParameter[_T]¶

Возвращает литеральную клаузулу, связанную с параметром bind.

Буквальные предложения создаются автоматически, когда не ClauseElement объекты (такие как строки, инты, даты и т.д.) используются в операции сравнения с ColumnElement подклассом, таким как Column объект. Используйте эту функцию для принудительной генерации литерального выражения, которое будет создано как BindParameter со связанным значением.

Параметры:

value – значение, которое необходимо связать. Может быть любым объектом Python, поддерживаемым базовым DB-API, или переводимым через заданный аргумент type.
type_ – необязательный TypeEngine, который обеспечит перевод bind-параметров для этого литерала.
literal_execute – необязательный bool, при значении True SQL-движок попытается отобразить связанное значение непосредственно в SQL-операторе во время выполнения, а не предоставлять его в качестве значения параметра. … версия добавлена:: 2.0

function sqlalchemy.sql.expression.literal_column(text: str, type_: Optional[_TypeEngineArgument[_T]] = None) → ColumnClause[_T]¶

Произвести объект ColumnClause, у которого флаг column.is_literal установлен в True.

literal_column() похож на column(), за исключением того, что он чаще используется как «отдельное» выражение для столбцов, которое отображается именно так, как указано; в то время как column() хранит строковое имя, которое будет считаться частью таблицы и может быть заключено в кавычки, literal_column() может быть этим или любым другим произвольным выражением, ориентированным на столбцы.

Параметры:

text – текст выражения; может быть любым выражением SQL. Правила кавычек не применяются. Чтобы указать выражение с именем столбца, к которому должны применяться правила цитирования, используйте функцию column().
type_ – необязательный объект TypeEngine, который будет обеспечивать перевод набора результатов и дополнительную семантику выражения для этого столбца. Если оставить значение None, то тип будет NullType.

См.также

column()

text()

Выбор с помощью текстовых выражений столбцов

function sqlalchemy.sql.expression.not_(clause: _ColumnExpressionArgument[_T]) → ColumnElement[_T]¶

Возвращает отрицание заданного предложения, т.е. NOT(clause).

Оператор ~ также перегружен во всех подклассах ColumnElement для получения того же результата.

function sqlalchemy.sql.expression.null() → Null¶: Возвращает константную конструкцию Null.

function sqlalchemy.sql.expression.or_(*clauses)¶

Произвести конъюнкцию выражений, соединенных OR.

Например:

from sqlalchemy import or_

stmt = select(users_table).where(
                or_(
                    users_table.c.name == 'wendy',
                    users_table.c.name == 'jack'
                )
            )

Соединение or_() также доступно с помощью оператора Python | (хотя обратите внимание, что составные выражения должны быть заключены в круглые скобки, чтобы функционировать с учетом поведения старшинства операторов Python):

stmt = select(users_table).where(
                (users_table.c.name == 'wendy') |
                (users_table.c.name == 'jack')
            )

Для того чтобы конструкция or_() была действительной, ей должен быть передан хотя бы один позиционный аргумент; конструкция or_() без аргументов является неоднозначной. Для создания «пустого» или динамически генерируемого выражения or_() из заданного списка выражений следует указать элемент «по умолчанию» false() (или просто False):

from sqlalchemy import false
or_criteria = or_(false(), *expressions)

Приведенное выше выражение будет компилироваться в SQL как выражение false или 0 = 1, в зависимости от бэкенда, если нет других выражений. Если выражения присутствуют, то значение false() игнорируется, поскольку оно не влияет на результат выражения OR, имеющего другие элементы.

Не рекомендуется, начиная с версии 1.4: Элемент or_() теперь требует передачи хотя бы одного аргумента; создание конструкции or_() без аргументов является устаревшим и будет выдавать предупреждение об устаревании, продолжая выдавать пустую строку SQL.

См.также

and_()

function sqlalchemy.sql.expression.outparam(key: str, type_: Optional[TypeEngine[_T]] = None) → BindParameter[_T]¶

Создайте параметр „OUT“ для использования в функциях (хранимых процедурах) для баз данных, которые их поддерживают.

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

function sqlalchemy.sql.expression.text(text: str) → TextClause¶

Создайте новый пункт TextClause, представляющий непосредственно текстовую строку SQL.

Например:

from sqlalchemy import text

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

Преимуществами text() перед простой строкой являются нейтральная к бэкенду поддержка параметров связывания, опций выполнения каждого запроса, а также поведение типизации параметров связывания и столбцов результатов, что позволяет конструкциям типа SQLAlchemy играть роль при выполнении оператора, который задан буквально. Конструкция также может быть снабжена коллекцией элементов столбцов .c, что позволяет встраивать ее в другие конструкции выражений SQL в качестве подзапроса.

Параметры привязки указываются по имени, используя формат :name. Например:

t = text("SELECT * FROM users WHERE id=:user_id")
result = connection.execute(t, user_id=12)

Для операторов SQL, где двоеточие требуется дословно, как в строке инлайн, используйте обратную косую черту для экранирования:

t = text(r"SELECT * FROM users WHERE name='\:username'")

Конструкция TextClause включает методы, которые могут предоставить информацию о связанных параметрах, а также значения столбцов, которые будут возвращены из текстового оператора, предполагая, что это исполняемый оператор типа SELECT. Метод TextClause.bindparams() используется для предоставления подробной информации о связанных параметрах, а метод TextClause.columns() позволяет указать возвращаемые столбцы, включая имена и типы:

t = text("SELECT * FROM users WHERE id=:user_id").\
        bindparams(user_id=7).\
        columns(id=Integer, name=String)

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

Конструкция text() используется в тех случаях, когда буквальный строковый SQL-фрагмент указывается как часть более крупного запроса, например, для пункта WHERE оператора SELECT:

s = select(users.c.id, users.c.name).where(text("id=:user_id"))
result = connection.execute(s, user_id=12)

text() также используется для построения полного, отдельного оператора с использованием обычного текста. Как таковой, SQLAlchemy называет его объектом Executable и может использоваться как любой другой оператор, передаваемый методу .execute().

Параметры:: text – текст создаваемого SQL-оператора. Используйте :<param> для указания параметров связывания; они будут скомпилированы в формат, специфичный для движка. … предупреждение:: Аргумент text.text в text() может быть передан как строковый аргумент Python, который будет рассматриваться как доверенный текст SQL и отображаться как задано. НЕ ПЕРЕДАВАЙТЕ НЕДОВЕРЕННЫЙ ВВОД В ЭТОТ ПАРАМЕТР.

См.также

Выбор с помощью текстовых выражений столбцов

function sqlalchemy.sql.expression.true() → True_¶

Возвращает константную конструкцию True_.

Например:

>>> from sqlalchemy import true
>>> print(select(t.c.x).where(true()))
{printsql}SELECT x FROM t WHERE true

Бэкенд, не поддерживающий константы true/false, будет отображать выражение в виде 1 или 0:

>>> print(select(t.c.x).where(true()))
{printsql}SELECT x FROM t WHERE 1 = 1

Константы true() и false() также поддерживают функцию «короткого замыкания» внутри конъюнкции and_() или or_():

>>> print(select(t.c.x).where(or_(t.c.x > 5, true())))
{printsql}SELECT x FROM t WHERE true{stop}

>>> print(select(t.c.x).where(and_(t.c.x > 5, false())))
{printsql}SELECT x FROM t WHERE false{stop}

См.также

false()

function sqlalchemy.sql.expression.try_cast(expression: _ColumnExpressionOrLiteralArgument[Any], type_: _TypeEngineArgument[_T]) → TryCast[_T]¶

Выражение TRY_CAST для бэкендов, которые его поддерживают; это CAST, которое возвращает NULL для некастируемых преобразований.

В SQLAlchemy эта конструкция поддерживается только диалектом SQL Server, и при ее использовании на других включенных бэкендах будет возникать ошибка CompileError. Однако сторонние бэкенды также могут поддерживать эту конструкцию.

Совет

Поскольку try_cast() происходит из диалекта SQL Server, его можно импортировать как из sqlalchemy., так и из sqlalchemy.dialects.mssql.

try_cast() возвращает экземпляр TryCast и в целом ведет себя аналогично конструкции Cast; на уровне SQL разница между CAST и TRY_CAST заключается в том, что TRY_CAST возвращает NULL для некастируемого выражения, например, при попытке привести строку "hi" к целочисленному значению.

Например:

from sqlalchemy import select, try_cast, Numeric

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

На Microsoft SQL Server вышеприведенные данные будут выглядеть следующим образом:

SELECT TRY_CAST (product_table.unit_price AS NUMERIC(10, 4))
FROM product_table

Добавлено в версии 2.0.14: try_cast() был обобщен из диалекта SQL Server в конструкцию общего использования, которая может поддерживаться другими диалектами.

function sqlalchemy.sql.expression.tuple_(*clauses: _ColumnExpressionArgument[Any], types: Optional[Sequence[_TypeEngineArgument[Any]]] = None) → Tuple¶

Возвращает Tuple.

Основное использование - создание составной конструкции IN с помощью ColumnOperators.in_()

from sqlalchemy import tuple_

tuple_(table.c.col1, table.c.col2).in_(
    [(1, 2), (5, 12), (10, 19)]
)

Изменено в версии 1.3.6: Добавлена поддержка кортежей SQLite IN.

Предупреждение

Составная конструкция IN поддерживается не всеми бэкендами, и в настоящее время известно, что она работает в PostgreSQL, MySQL и SQLite. Неподдерживаемые бэкенды при вызове такого выражения выдадут подкласс DBAPIError.

function sqlalchemy.sql.expression.type_coerce(expression: _ColumnExpressionOrLiteralArgument[Any], type_: _TypeEngineArgument[_T]) → TypeCoerce[_T]¶

Ассоциируйте выражение SQL с определенным типом, не отображая CAST.

Например:

from sqlalchemy import type_coerce

stmt = select(type_coerce(log_table.date_string, StringDateTime()))

Приведенная выше конструкция создает объект TypeCoerce, который никак не модифицирует рендеринг на стороне SQL, за исключением, возможно, сгенерированной метки, если она используется в контексте предложения columns:

SELECT date_string AS date_string FROM log

Когда происходит выборка строк результата, процессор типа StringDateTime будет применен к строкам результата от имени столбца date_string.

Примечание

конструкция type_coerce() не имеет собственного синтаксиса SQL, включая то, что она не подразумевает использование круглых скобок. Пожалуйста, используйте TypeCoerce.self_group(), если требуется явное раскрытие скобок.

Чтобы задать именованную метку для выражения, используйте ColumnElement.label():

stmt = select(
    type_coerce(log_table.date_string, StringDateTime()).label('date')
)

Тип, в котором реализована обработка связанных значений, также будет иметь такое поведение, когда в качестве целей в type_coerce() передаются литеральные значения или конструкции bindparam(). Например, если тип реализует метод TypeEngine.bind_expression(), метод TypeEngine.bind_processor() или эквивалентный метод, эти функции будут действовать во время компиляции/исполнения оператора, когда передается литеральное значение, как в:

# bound-value handling of MyStringType will be applied to the
# literal value "some string"
stmt = select(type_coerce("some string", MyStringType))

При использовании type_coerce() с составленными выражениями, обратите внимание, что скобки не применяются. Если type_coerce() используется в контексте оператора, где необходимы скобки, обычно присутствующие в CAST, используйте метод TypeCoerce.self_group():

>>> some_integer = column("someint", Integer)
>>> some_string = column("somestr", String)
>>> expr = type_coerce(some_integer + 5, String) + some_string
>>> print(expr)
{printsql}someint + :someint_1 || somestr{stop}
>>> expr = type_coerce(some_integer + 5, String).self_group() + some_string
>>> print(expr)
{printsql}(someint + :someint_1) || somestr{stop}

Параметры:

expression – Выражение SQL, например, выражение ColumnElement или строка Python, которая будет преобразована в связанное литеральное значение.
type_ – Класс или экземпляр TypeEngine, указывающий тип, к которому принуждается выражение.

См.также

ColumnElement.between()

class sqlalchemy.sql.expression.quoted_name¶

Представляют собой SQL-идентификатор в сочетании с предпочтениями при цитировании.

quoted_name - это подкласс Python unicode/str, который представляет определенное имя идентификатора вместе с флагом quote. Этот флаг quote, если он установлен в True или False, переопределяет автоматическое поведение кавычек для этого идентификатора, чтобы либо безоговорочно заключить имя в кавычки, либо не заключать его в кавычки. Если оставить значение по умолчанию None, то поведение кавычек применяется к идентификатору на основе анализа самого токена для каждого бэкенда.

Объект quoted_name с quote=True также не может быть изменен в случае так называемой опции «нормализации имени». Некоторые бэкенды баз данных, такие как Oracle, Firebird и DB2 «нормализуют» имена, нечувствительные к регистру, в верхний регистр. Диалекты SQLAlchemy для этих бэкендов конвертируют из конвенции SQLAlchemy «нижний регистр-значения-нечувствительные» в конвенцию «верхний регистр-значения-нечувствительные» этих бэкендов. Флаг quote=True здесь предотвратит это преобразование, чтобы поддержать идентификатор, который цитируется в нижнем регистре в таком бэкенде.

Объект quoted_name обычно создается автоматически при указании имени для конструкций схемы ключей, таких как Table, Column и других. Класс также может быть передан явно в качестве имени любой функции, которая получает имя, которое можно заключить в кавычки. Например, чтобы использовать метод Engine.has_table() с безусловно кавычным именем:

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

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

Приведенная выше логика запустит логику «has table» против бэкенда Oracle, передавая имя в точности как "some_table" без преобразования в верхний регистр.

Изменено в версии 1.2: Конструкция quoted_name теперь импортируется из sqlalchemy.sql, в дополнение к предыдущему расположению sqlalchemy.sql.elements.

Members

quote

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

класс sqlalchemy.sql.expression.quoted_name (sqlalchemy.util.langhelpers.MemoizedSlots, builtins.str)

attribute sqlalchemy.sql.expression.quoted_name.quote¶: должна ли строка быть безусловно заключена в кавычки

Конструкторы модификаторов элементов колонок¶

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

Object Name	Description
all_(expr)	Произведите выражение ALL.
any_(expr)	Произведите выражение ANY.
asc(column)	Произвести возрастающий элемент клаузулы `ORDER BY`.
between(expr, lower_bound, upper_bound[, symmetric])	Произведите предикатное предложение `BETWEEN`.
collate(expression, collation)	Возвращает предложение `expression COLLATE collation`.
desc(column)	Произвести нисходящий элемент клаузулы `ORDER BY`.
funcfilter(func, *criterion)	Произвести объект `FunctionFilter` против функции.
label(name, element[, type_])	Возвращает объект `Label` для заданного `ColumnElement`.
nulls_first(column)	Произвести модификатор `NULLS FIRST` для выражения `ORDER BY`.
nulls_last(column)	Произвести модификатор `NULLS LAST` для выражения `ORDER BY`.
nullsfirst	Синоним функции `nulls_first()`.
nullslast	Наследный синоним функции `nulls_last()`.
over(element[, partition_by, order_by, range_, ...])	Произвести объект `Over` против функции.
within_group(element, *order_by)	Произвести объект `WithinGroup` против функции.

function sqlalchemy.sql.expression.all_(expr: _ColumnExpressionArgument[_T]) → CollectionAggregate[bool]¶

Произведите выражение ALL.

Для таких диалектов, как PostgreSQL, этот оператор применяется к использованию типа данных ARRAY, для MySQL он может применяться к подзапросу. например:

# renders on PostgreSQL:
# '5 = ALL (somearray)'
expr = 5 == all_(mytable.c.somearray)

# renders on MySQL:
# '5 = ALL (SELECT value FROM table)'
expr = 5 == all_(select(table.c.value))

Сравнение с NULL может работать с использованием None:

None == all_(mytable.c.somearray)

Операторы any_() / all_() также имеют специальное поведение «переворачивания операнда»: если any_() / all_() используются в левой части сравнения, использующего отдельный оператор, такой как ==, != и т.д. (не включая методы оператора, такие как ColumnOperators.is_()), то полученное выражение переворачивается:

# would render '5 = ALL (column)`
all_(mytable.c.column) == 5

Или с помощью None, примечание которого не будет выполнять обычный шаг рендеринга «IS», как это обычно происходит для NULL:

# would render 'NULL = ALL(somearray)'
all_(mytable.c.somearray) == None

Изменено в версии 1.4.26: восстановлено использование any_() / all_(), сравнивающих с NULL в правой части для перебрасывания в левую.

Метод уровня колонок ColumnElement.all_() (не путать с ARRAY уровня Comparator.all()) является сокращением для all_(col):

5 == mytable.c.somearray.all_()

См.также

ColumnOperators.all_()

any_()

function sqlalchemy.sql.expression.any_(expr: _ColumnExpressionArgument[_T]) → CollectionAggregate[bool]¶

Произведите выражение ANY.

# renders on PostgreSQL:
# '5 = ANY (somearray)'
expr = 5 == any_(mytable.c.somearray)

# renders on MySQL:
# '5 = ANY (SELECT value FROM table)'
expr = 5 == any_(select(table.c.value))

Сравнение с NULL может работать с использованием None или null():

None == any_(mytable.c.somearray)

# would render '5 = ANY (column)`
any_(mytable.c.column) == 5

# would render 'NULL = ANY(somearray)'
any_(mytable.c.somearray) == None

Метод уровня колонок ColumnElement.any_() (не путать с ARRAY уровня Comparator.any()) является сокращением для any_(col):

5 = mytable.c.somearray.any_()

См.также

ColumnOperators.any_()

all_()

function sqlalchemy.sql.expression.asc(column: _ColumnExpressionOrStrLabelArgument[_T]) → UnaryExpression[_T]¶

Произвести возрастающий элемент клаузулы ORDER BY.

например:

from sqlalchemy import asc
stmt = select(users_table).order_by(asc(users_table.c.name))

будет выдавать SQL как:

SELECT id, name FROM user ORDER BY name ASC

Функция asc() является самостоятельной версией метода ColumnElement.asc(), доступного для всех SQL-выражений, например:

stmt = select(users_table).order_by(users_table.c.name.asc())

Параметры:: column – ColumnElement (например, скалярное выражение SQL), с которым применяется операция asc().

См.также

function sqlalchemy.sql.expression.between(expr: _ColumnExpressionOrLiteralArgument[_T], lower_bound: Any, upper_bound: Any, symmetric: bool = False) → BinaryExpression[bool]¶

Произведите предикатное предложение BETWEEN.

Например:

from sqlalchemy import between
stmt = select(users_table).where(between(users_table.c.id, 5, 7))

Выдаст SQL, похожий на:

SELECT id, name FROM user WHERE id BETWEEN :id_1 AND :id_2

Функция between() представляет собой отдельную версию метода ColumnElement.between(), доступного для всех выражений SQL, как в:

stmt = select(users_table).where(users_table.c.id.between(5, 7))

Все аргументы, передаваемые в between(), включая выражение левого столбца, принудительно извлекаются из скалярных значений Python, если значение не является подклассом ColumnElement. Например, три фиксированных значения можно сравнить так:

print(between(5, 3, 7))

В результате чего будут получены:

:param_1 BETWEEN :param_2 AND :param_3

Параметры:

expr – выражение столбца, обычно экземпляр ColumnElement или альтернативное скалярное выражение Python, которое должно быть принудительно преобразовано в выражение столбца, служащее левой частью выражения BETWEEN.
lower_bound – столбец или скалярное выражение Python, служащее нижней границей правой части выражения BETWEEN.
upper_bound – столбец или скалярное выражение Python, служащее верхней границей правой части выражения BETWEEN.
symmetric – если True, будет отображаться » BETWEEN SYMMETRIC «. Обратите внимание, что не все базы данных поддерживают этот синтаксис.

См.также

function sqlalchemy.sql.expression.collate(expression: _ColumnExpressionArgument[str], collation: str) → BinaryExpression[str]¶

Возвращает предложение expression COLLATE collation.

например:

collate(mycolumn, 'utf8_bin')

производит:

mycolumn COLLATE utf8_bin

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

Изменено в версии 1.2: кавычки автоматически применяются к выражениям COLLATE, если они чувствительны к регистру.

function sqlalchemy.sql.expression.desc(column: _ColumnExpressionOrStrLabelArgument[_T]) → UnaryExpression[_T]¶

Произвести нисходящий элемент клаузулы ORDER BY.

например:

from sqlalchemy import desc

stmt = select(users_table).order_by(desc(users_table.c.name))

будет выдавать SQL как:

SELECT id, name FROM user ORDER BY name DESC

Функция desc() является самостоятельной версией метода ColumnElement.desc(), доступного для всех SQL-выражений, например:

stmt = select(users_table).order_by(users_table.c.name.desc())

Параметры:: column – ColumnElement (например, скалярное выражение SQL), с которым применяется операция desc().

См.также

function sqlalchemy.sql.expression.funcfilter(func: FunctionElement[_T], *criterion: _ColumnExpressionArgument[bool]) → FunctionFilter[_T]¶

Произвести объект FunctionFilter против функции.

Используется против агрегатных и оконных функций, для бэкендов баз данных, поддерживающих условие «FILTER».

Например:

from sqlalchemy import funcfilter
funcfilter(func.count(1), MyClass.name == 'some name')

Получится «COUNT(1) FILTER (WHERE myclass.name = „some name“)».

Эта функция также доступна из самой конструкции func через метод FunctionElement.filter().

См.также

Специальные модификаторы WITHIN GROUP, FILTER - в Унифицированный учебник по SQLAlchemy

FunctionElement.filter()

function sqlalchemy.sql.expression.label(name: str, element: _ColumnExpressionArgument[_T], type_: Optional[_TypeEngineArgument[_T]] = None) → Label[_T]¶

Возвращает объект Label для заданного ColumnElement.

Метка изменяет имя элемента в предложении columns оператора SELECT, обычно с помощью ключевого слова SQL AS.

Эта функциональность более удобно доступна через метод ColumnElement.label() на ColumnElement.

Параметры:

name – название этикетки
obj – a ColumnElement.

function sqlalchemy.sql.expression.nulls_first(column: _ColumnExpressionArgument[_T]) → UnaryExpression[_T]¶

Произвести модификатор NULLS FIRST для выражения ORDER BY.

nulls_first() предназначен для модификации выражения, полученного с помощью asc() или desc(), и указывает, как следует обрабатывать значения NULL, когда они встречаются при упорядочивании:

from sqlalchemy import desc, nulls_first

stmt = select(users_table).order_by(
    nulls_first(desc(users_table.c.name)))

SQL-выражение, полученное из вышеприведенного, будет выглядеть так:

SELECT id, name FROM user ORDER BY name DESC NULLS FIRST

Как и asc() и desc(), nulls_first() обычно вызывается из самого выражения столбца с помощью ColumnElement.nulls_first(), а не как отдельная версия функции, как в:

stmt = select(users_table).order_by(
    users_table.c.name.desc().nulls_first())

Изменено в версии 1.4: nulls_first() переименовано из nullsfirst() в предыдущих выпусках. Предыдущее имя остается доступным для обратной совместимости.

См.также

function sqlalchemy.sql.expression.nullsfirst()¶: Синоним функции nulls_first().

Изменено в версии 2.0.5: восстановил отсутствующий унаследованный символ nullsfirst().

function sqlalchemy.sql.expression.nulls_last(column: _ColumnExpressionArgument[_T]) → UnaryExpression[_T]¶

Произвести модификатор NULLS LAST для выражения ORDER BY.

nulls_last() предназначен для модификации выражения, полученного с помощью asc() или desc(), и указывает, как следует обрабатывать значения NULL, когда они встречаются при упорядочивании:

from sqlalchemy import desc, nulls_last

stmt = select(users_table).order_by(
    nulls_last(desc(users_table.c.name)))

SQL-выражение, полученное из вышеприведенного, будет выглядеть так:

SELECT id, name FROM user ORDER BY name DESC NULLS LAST

Как и asc() и desc(), nulls_last() обычно вызывается из самого выражения столбца с помощью ColumnElement.nulls_last(), а не как отдельная версия функции, как в:

stmt = select(users_table).order_by(
    users_table.c.name.desc().nulls_last())

Изменено в версии 1.4: nulls_last() переименовано из nullslast() в предыдущих выпусках. Предыдущее имя остается доступным для обратной совместимости.

См.также

function sqlalchemy.sql.expression.nullslast()¶: Наследный синоним функции nulls_last().

Изменено в версии 2.0.5: восстановил отсутствующий унаследованный символ nullslast().

function sqlalchemy.sql.expression.over(element: FunctionElement[_T], partition_by: Optional[Union[Iterable[_ColumnExpressionArgument[Any]], _ColumnExpressionArgument[Any]]] = None, order_by: Optional[Union[Iterable[_ColumnExpressionArgument[Any]], _ColumnExpressionArgument[Any]]] = None, range_: Optional[typing_Tuple[Optional[int], Optional[int]]] = None, rows: Optional[typing_Tuple[Optional[int], Optional[int]]] = None) → Over[_T]¶

Произвести объект Over против функции.

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

over() обычно вызывается с помощью метода FunctionElement.over(), например:

func.row_number().over(order_by=mytable.c.some_column)

Будет производить:

ROW_NUMBER() OVER(ORDER BY some_column)

Диапазоны также возможны с помощью параметров over.range_ и over.rows. Эти взаимоисключающие параметры принимают каждый по 2 кортежа, которые содержат комбинацию целых чисел и None:

func.row_number().over(
    order_by=my_table.c.some_column, range_=(None, 0))

Вышеуказанное приведет к следующим результатам:

ROW_NUMBER() OVER(ORDER BY some_column
RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)

Значение None означает «не ограниченный», значение ноль означает «текущий ряд», а отрицательные/положительные целые числа означают «предшествующий» и «последующий»:

В ДИАПАЗОНЕ ОТ 5 ПРЕДШЕСТВУЮЩИХ ДО 10 ПОСЛЕДУЮЩИХ:
```
func.row_number().over(order_by='x', range_=(-5, 10))
```
РЯДОВ МЕЖДУ НЕОГРАНИЧЕННЫМ ПРЕДЫДУЩИМ И ТЕКУЩИМ РЯДОМ:
```
func.row_number().over(order_by='x', rows=(None, 0))
```
ДИАПАЗОН МЕЖДУ 2 ПРЕДШЕСТВУЮЩИМИ И НЕОГРАНИЧЕННЫМ ПОСЛЕДУЮЩИМ:
```
func.row_number().over(order_by='x', range_=(-2, None))
```
В ДИАПАЗОНЕ ОТ 1 СЛЕДУЮЩЕГО ДО 3 СЛЕДУЮЩЕГО:
```
func.row_number().over(order_by='x', range_=(1, 3))
```

Параметры:

element – FunctionElement, WithinGroup или другой совместимой конструкции.
partition_by – элемент столбца или строка, или их список, который будет использоваться в качестве пункта PARTITION BY конструкции OVER.
order_by – элемент столбца или строка, или их список, который будет использоваться в качестве пункта ORDER BY конструкции OVER.
range_ – необязательное условие диапазона для окна. Это кортеж, который может содержать целочисленные значения или None, и будет отображать предложение RANGE BETWEEN PRECEDING / FOLLOWING.
rows – необязательный пункт rows для окна. Это кортеж, который может содержать целочисленные значения или None, и будет отображать предложение ROWS BETWEEN PRECEDING / FOLLOWING.

Эта функция также доступна из самой конструкции func через метод FunctionElement.over().

См.также

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

func

within_group()

function sqlalchemy.sql.expression.within_group(element: FunctionElement[_T], *order_by: _ColumnExpressionArgument[Any]) → WithinGroup[_T]¶

Произвести объект WithinGroup против функции.

Используется против так называемых «упорядоченных агрегатов множеств» и «гипотетических агрегатов множеств», включая функции percentile_cont, rank, dense_rank и т.д.

within_group() обычно вызывается с помощью метода FunctionElement.within_group(), например:

from sqlalchemy import within_group
stmt = select(
    department.c.id,
    func.percentile_cont(0.5).within_group(
        department.c.salary.desc()
    )
)

Приведенное выше утверждение произведет SQL, аналогичный SELECT department.id, percentile_cont(0.5) WITHIN GROUP (ORDER BY department.salary DESC).

Параметры:

element – конструкция FunctionElement, обычно генерируемая func.
*order_by – один или несколько элементов столбцов, которые будут использоваться в качестве пункта ORDER BY конструкции WITHIN GROUP.

См.также

Специальные модификаторы WITHIN GROUP, FILTER - в Унифицированный учебник по SQLAlchemy

func

over()

Документация класса элемента колонки¶

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

Object Name	Description
BinaryExpression	Представьте выражение, которое является `LEFT <operator> RIGHT`.
BindParameter	Представляют собой «связанное выражение».
Case	Представляет собой выражение `CASE`.
Cast	Представляет собой выражение `CAST`.
ClauseList	Опишите список пунктов, разделенных оператором.
ColumnClause	Представляет собой выражение столбца из любой текстовой строки.
ColumnCollection	Коллекция экземпляров `ColumnElement`, обычно для объектов `FromClause`.
ColumnElement	Представляет собой ориентированное на столбцы выражение SQL, подходящее для использования в пункте «столбцы», пункте WHERE и т.д. оператора.
ColumnExpressionArgument	Аргумент общего назначения «выражение столбца».
ColumnOperators	Определяет булевы, сравнительные и другие операторы для выражений `ColumnElement`.
Extract	Представьте предложение SQL EXTRACT, `extract(field FROM expr)`.
False_	Представьте ключевое слово `false` или его эквивалент в операторе SQL.
FunctionFilter	Представьте предложение функции FILTER.
Label	Представляет собой метку столбца (AS).
Null	Представьте ключевое слово NULL в операторе SQL.
Operators	База операторов сравнения и логических операторов.
Over	Представьте пункт OVER.
SQLColumnExpression	Тип, который может использоваться для указания любого элемента столбца SQL или объекта, который действует вместо него.
TextClause	Представляет собой литеральный фрагмент текста SQL.
True_	Представьте ключевое слово `true` или его эквивалент в операторе SQL.
TryCast	Представляет собой выражение TRY_CAST.
Tuple	Представляет собой кортеж SQL.
TypeCoerce	Представляет собой обертку для приведения типов со стороны Python.
UnaryExpression	Определите «унарное» выражение.
WithinGroup	Представьте предложение WITHIN GROUP (ORDER BY).
WrapsColumnExpression	Миксин, определяющий `ColumnElement` как обертку со специальным поведением метки для выражения, которое уже имеет имя.

class sqlalchemy.sql.expression.BinaryExpression¶

Представьте выражение, которое является LEFT <operator> RIGHT.

BinaryExpression генерируется автоматически всякий раз, когда в двоичном выражении Python используются два столбцовых выражения:

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

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

класс sqlalchemy.sql.expression.BinaryExpression (sqlalchemy.sql.expression.OperatorExpression)

class sqlalchemy.sql.expression.BindParameter¶

Представляют собой «связанное выражение».

BindParameter вызывается явно с помощью функции bindparam(), как в:

from sqlalchemy import bindparam

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

Подробное обсуждение того, как используется BindParameter, находится в bindparam().

См.также

bindparam()

Members

effective_value, inherit_cache, render_literal_execute()

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

класс sqlalchemy.sql.expression.BindParameter (sqlalchemy.sql.roles.InElementRole, sqlalchemy.sql.expression.KeyedColumnElement)

attribute sqlalchemy.sql.expression.BindParameter.effective_value¶

Возвращает значение этого связанного параметра с учетом того, был ли установлен параметр callable.

Значение callable будет оценено и возвращено, если оно присутствует, иначе value.

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

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

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

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

См.также

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

method sqlalchemy.sql.expression.BindParameter.render_literal_execute() → BindParameter[_T]¶

Произведите копию этого связанного параметра, которая включит флаг BindParameter.literal_execute.

Флаг BindParameter.literal_execute будет иметь эффект отображения параметра в скомпилированной строке SQL с использованием формы [POSTCOMPILE], которая является специальной формой, преобразуемой в отображение литерального значения параметра во время выполнения SQL. Это необходимо для поддержки кэширования строк SQL-операторов, которые могут встраивать литеральные значения для каждого оператора, такие как параметры LIMIT и OFFSET, в конечную строку SQL, передаваемую DBAPI. Диалекты, в частности, могут захотеть использовать этот метод в рамках пользовательских схем компиляции.

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

См.также

Кэширование для диалектов сторонних производителей

class sqlalchemy.sql.expression.Case¶

Представляет собой выражение CASE.

Case производится с помощью фабричной функции case(), как в:

from sqlalchemy import case

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

Подробности об использовании Case приведены в case().

См.также

case()

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

класс sqlalchemy.sql.expression.Case (sqlalchemy.sql.expression.ColumnElement)

class sqlalchemy.sql.expression.Cast¶

Представляет собой выражение CAST.

Cast производится с помощью фабричной функции cast(), как в:

from sqlalchemy import cast, Numeric

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

Подробности об использовании Cast приведены в cast().

См.также

try_cast()

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

класс sqlalchemy.sql.expression.Cast (sqlalchemy.sql.expression.WrapsColumnExpression)

class sqlalchemy.sql.expression.ClauseList¶

Опишите список пунктов, разделенных оператором.

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

Members

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

class sqlalchemy.sql.expression.ClauseList (sqlalchemy.sql.roles.InElementRole, sqlalchemy.sql.roles.OrderByRole, sqlalchemy.sql.roles.ColumnsClauseRole, sqlalchemy.sql.roles.DMLColumnRole, sqlalchemy.sql.expression.DQLDMLClauseElement)

method sqlalchemy.sql.expression.ClauseList.self_group(against=None)¶

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

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

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

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

class sqlalchemy.sql.expression.ColumnClause¶

Представляет собой выражение столбца из любой текстовой строки.

Класс ColumnClause, облегченный аналог класса Column, обычно вызывается с помощью функции column(), как в:

from sqlalchemy import column

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

Вышеприведенный оператор выдаст SQL вида:

SELECT id, name FROM user

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

Полная информация об использовании ColumnClause находится на сайте column().

См.также

column()

Column

Members

get_children()

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

class sqlalchemy.sql.expression.ColumnClause (sqlalchemy.sql.roles.DDLReferredColumnRole, sqlalchemy.sql.roles.LabeledColumnExprRole, sqlalchemy.sql.roles.StrAsPlainColumnRole, sqlalchemy.sql.expression.Immutable, sqlalchemy.sql.expression.NamedColumn)

method sqlalchemy.sql.expression.ColumnClause.get_children(*, column_tables=False, **kw)¶

Возвращает непосредственные дочерние HasTraverseInternals элементы данного HasTraverseInternals.

Используется для обхода посещений.

**kw может содержать флаги, изменяющие возвращаемую коллекцию, например, для возврата подмножества элементов, чтобы сократить время обхода, или для возврата дочерних элементов из другого контекста (например, коллекции на уровне схемы, а не на уровне пункта).

class sqlalchemy.sql.expression.ColumnCollection¶

Коллекция экземпляров ColumnElement, обычно для объектов FromClause.

Объект ColumnCollection чаще всего доступен как коллекция Table.c или Table.columns на объекте Table, представленном в Доступ к таблицам и столбцам.

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

Чтобы получить доступ к объектам Column с помощью обычного доступа в стиле атрибутов, укажите имя как любой другой атрибут объекта, например, как показано ниже для доступа к столбцу с именем employee_name:

>>> employee_table.c.employee_name

Для доступа к столбцам, имена которых содержат специальные символы или пробелы, используется доступ в индексном стиле, как показано ниже, где показан доступ к столбцу с именем employee ' payment:

>>> employee_table.c["employee ' payment"]

Поскольку объект ColumnCollection предоставляет интерфейс словаря Python, доступны такие распространенные имена методов словаря, как ColumnCollection.keys(), ColumnCollection.values() и ColumnCollection.items(), что означает, что столбцы базы данных, имеющие ключи под этими именами, также должны использовать индексированный доступ:

>>> employee_table.c["values"]

Имя, для которого будет присутствовать Column, обычно является именем параметра Column.key. В некоторых контекстах, например, в объекте Select, использующем стиль меток, установленный с помощью метода Select.set_label_style(), столбец определенного ключа может вместо этого быть представлен под определенным именем метки, например tablename_columnname:

>>> from sqlalchemy import select, column, table
>>> from sqlalchemy import LABEL_STYLE_TABLENAME_PLUS_COL
>>> t = table("t", column("c"))
>>> stmt = select(t).set_label_style(LABEL_STYLE_TABLENAME_PLUS_COL)
>>> subq = stmt.subquery()
>>> subq.c.t_c
<sqlalchemy.sql.elements.ColumnClause at 0x7f59dcf04fa0; t_c>

ColumnCollection также индексирует столбцы по порядку и позволяет получить к ним доступ по их целочисленной позиции:

>>> cc[0]
Column('x', Integer(), table=None)
>>> cc[1]
Column('y', Integer(), table=None)

Добавлено в версии 1.4: ColumnCollection позволяет получить доступ к коллекции по целочисленному индексу.

Итерация коллекции дает выражения столбцов в следующем порядке:

>>> list(cc)
[Column('x', Integer(), table=None),
 Column('y', Integer(), table=None)]

Базовый объект ColumnCollection может хранить дубликаты, что может означать либо два столбца с одинаковым ключом, в этом случае столбец, возвращаемый доступом к ключу, является арбитражным:

>>> x1, x2 = Column('x', Integer), Column('x', Integer)
>>> cc = ColumnCollection(columns=[(x1.name, x1), (x2.name, x2)])
>>> list(cc)
[Column('x', Integer(), table=None),
 Column('x', Integer(), table=None)]
>>> cc['x'] is x1
False
>>> cc['x'] is x2
True

Или это также может означать один и тот же столбец несколько раз. Эти случаи поддерживаются, поскольку ColumnCollection используется для представления столбцов в операторе SELECT, который может включать дубликаты.

Существует специальный подкласс DedupeColumnCollection, который вместо этого сохраняет старое поведение SQLAlchemy - не допускать дубликатов; эта коллекция используется для объектов уровня схемы, таких как Table и PrimaryKeyConstraint, где такое дедублирование полезно. Класс DedupeColumnCollection также имеет дополнительные методы мутации, поскольку конструкции схемы имеют больше случаев использования, требующих удаления и замены столбцов.

Изменено в версии 1.4: ColumnCollection теперь хранит дублирующиеся ключи столбцов, а также один и тот же столбец в нескольких позициях. Класс DedupeColumnCollection добавлен для сохранения прежнего поведения в тех случаях, когда требуется дедупликация, а также дополнительные операции замены/удаления.

Members

add(), as_readonly(), clear(), compare(), contains_column(), corresponding_column(), get(), items(), keys(), update(), values()

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

класс sqlalchemy.sql.expression.ColumnCollection (typing.Generic)

method sqlalchemy.sql.expression.ColumnCollection.add(column: ColumnElement[Any], key: Optional[_COLKEY] = None) → None¶: Добавьте колонку к этому ColumnCollection.

Примечание

Этот метод обычно не используется в пользовательском коде, поскольку ColumnCollection обычно является частью существующего объекта, такого как Table. Чтобы добавить Column к существующему объекту Table, используйте метод Table.append_column().

method sqlalchemy.sql.expression.ColumnCollection.as_readonly() → ReadOnlyColumnCollection[_COLKEY, _COL_co]¶: Возвращает «только для чтения» форму этого ColumnCollection.

method sqlalchemy.sql.expression.ColumnCollection.clear() → NoReturn¶: Dictionary clear() не реализована для ColumnCollection.

method sqlalchemy.sql.expression.ColumnCollection.compare(other: ColumnCollection[Any, Any]) → bool¶: Сравните этот ColumnCollection с другим на основе имен ключей

method sqlalchemy.sql.expression.ColumnCollection.contains_column(col: ColumnElement[Any]) → bool¶: Проверяет, существует ли объект колонки в данной коллекции

method sqlalchemy.sql.expression.ColumnCollection.corresponding_column(column: _COL, require_embedded: bool = False) → Optional[Union[_COL, _COL_co]]¶

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

Параметры:

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

См.также

Selectable.corresponding_column() - вызывает этот метод против коллекции, возвращенной Selectable.exported_columns.

Изменено в версии 1.4: реализация для corresponding_column была перенесена на сам ColumnCollection.

method sqlalchemy.sql.expression.ColumnCollection.get(key: str, default: Optional[_COL_co] = None) → Optional[_COL_co]¶: Получить объект ColumnClause или Column на основе строкового имени ключа из данного ColumnCollection.

method sqlalchemy.sql.expression.ColumnCollection.items() → List[Tuple[_COLKEY, _COL_co]]¶: Возвращает последовательность кортежей (key, column) для всех столбцов данной коллекции, каждый из которых состоит из строкового имени ключа и объекта ColumnClause или Column.

method sqlalchemy.sql.expression.ColumnCollection.keys() → List[_COLKEY]¶: Возвращает последовательность строковых имен ключей для всех столбцов в данной коллекции.

method sqlalchemy.sql.expression.ColumnCollection.update(iter_: Any) → NoReturn¶: Функция update() не реализована для ColumnCollection.

method sqlalchemy.sql.expression.ColumnCollection.values() → List[_COL_co]¶: Возвращает последовательность объектов ColumnClause или Column для всех столбцов в данной коллекции.

class sqlalchemy.sql.expression.ColumnElement¶

Представляет собой ориентированное на столбцы выражение SQL, подходящее для использования в пункте «столбцы», пункте WHERE и т.д. оператора.

Хотя наиболее знакомым видом ColumnElement является объект Column, ColumnElement служит основой для любого элемента, который может присутствовать в выражении SQL, включая сами выражения, функции SQL, связанные параметры, литеральные выражения, ключевые слова, такие как NULL, и т.д. ColumnElement является конечным базовым классом для всех таких элементов.

Множество функций SQLAlchemy Core работают на уровне SQL-выражений и предназначены для приема в качестве аргументов экземпляров ColumnElement. Эти функции обычно указывают в документации, что в качестве аргумента они принимают «SQL-выражение». В терминах SQLAlchemy это обычно означает входные данные, которые либо уже имеют форму объекта ColumnElement, либо значение, которое можно принудительно преобразовать в такой объект. Правила принуждения, которым следуют большинство, но не все функции SQLAlchemy Core в отношении выражений SQL, следующие:

буквальное значение Python, такое как строка, целое число или значение с плавающей точкой, булево число, время даты, объект Decimal или практически любой другой объект Python, будет принудительно превращено в «буквальное связанное значение». Обычно это означает, что будет создан объект bindparam() с заданным значением, встроенным в конструкцию; полученный объект BindParameter является экземпляром ColumnElement. Значение Python в конечном итоге будет отправлено в DBAPI во время выполнения в качестве параметризованного аргумента методов execute() или executemany(), после того как к значению будут применены преобразователи, специфичные для типа SQLAlchemy (например, те, которые предоставляются любыми связанными объектами TypeEngine).

любое специальное значение объекта, обычно это конструкции уровня ORM, которые имеют аксессор __clause_element__(). Система выражений Core ищет этот метод, когда объект неизвестного типа передается в функцию, которая хочет преобразовать аргумент в выражение ColumnElement и иногда SelectBase. Он используется в ORM для преобразования специфичных для ORM объектов, таких как отображенные классы и отображенные атрибуты, в объекты выражений Core.

Значение Python None обычно интерпретируется как NULL, что в SQLAlchemy Core дает экземпляр null().

ColumnElement предоставляет возможность генерировать новые объекты ColumnElement с помощью выражений Python. Это означает, что операторы Python, такие как ==, != и <, перегружены для имитации операций SQL и позволяют создавать новые объекты ColumnElement, которые составляются из других, более фундаментальных объектов ColumnElement. Например, два объекта ColumnClause могут быть сложены вместе с помощью оператора сложения + для получения BinaryExpression. И ColumnClause, и BinaryExpression являются подклассами ColumnElement:

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

См.также

Column

column()

Members

__eq__(), __le__(), __lt__(), __ne__(), all_(), allows_lambda, anon_key_label, anon_label, any_(), asc(), base_columns, between(), bitwise_and(), bitwise_lshift(), bitwise_not(), bitwise_or(), bitwise_rshift(), bitwise_xor(), bool_op(), cast(), collate(), comparator, compare(), compile(), concat(), contains(), desc(), description, distinct(), endswith(), entity_namespace, expression, foreign_keys, get_children(), icontains(), iendswith(), ilike(), in_(), inherit_cache, is_(), is_clause_element, is_distinct_from(), is_dml, is_not(), is_not_distinct_from(), is_selectable, isnot(), isnot_distinct_from(), istartswith(), key, label(), like(), match(), negation_clause, not_ilike(), not_in(), not_like(), notilike(), notin_(), notlike(), nulls_first(), nulls_last(), nullsfirst(), nullslast(), op(), operate(), params(), primary_key, proxy_set, regexp_match(), regexp_replace(), reverse_operate(), self_group(), shares_lineage(), startswith(), stringify_dialect, supports_execution, timetuple, type, unique_params(), uses_inspection

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

class sqlalchemy.sql.expression.ColumnElement (sqlalchemy.sql.roles.ColumnArgumentOrKeyRole, sqlalchemy.sql.roles.StatementOptionRole, sqlalchemy.sql.roles.WhereHavingRole, sqlalchemy.sql.roles.BinaryElementRole, sqlalchemy.sql.roles.OrderByRole, sqlalchemy.sql.roles.ColumnsClauseRole, sqlalchemy.sql.roles.LimitOffsetRole, sqlalchemy.sql.roles.DMLColumnRole, sqlalchemy.sql.roles.DDLConstraintColumnRole, sqlalchemy.sql.roles.DDLExpressionRole, sqlalchemy.sql.expression.SQLColumnExpression, sqlalchemy.sql.expression.DQLDMLClauseElement)

method sqlalchemy.sql.expression.ColumnElement.__eq__(other: Any) → ColumnOperators¶

наследуется от sqlalchemy.sql.expression.ColumnOperators.__eq__ метода ColumnOperators

Реализуйте оператор ==.

В контексте столбца выдает предложение a = b. Если цель None, выдает a IS NULL.

method sqlalchemy.sql.expression.ColumnElement.__le__(other: Any) → ColumnOperators¶

наследуется от sqlalchemy.sql.expression.ColumnOperators.__le__ метода ColumnOperators

Реализуйте оператор <=.

В контексте столбца производит предложение a <= b.

method sqlalchemy.sql.expression.ColumnElement.__lt__(other: Any) → ColumnOperators¶

наследуется от sqlalchemy.sql.expression.ColumnOperators.__lt__ метода ColumnOperators

Реализуйте оператор <.

В контексте столбца производит предложение a < b.

method sqlalchemy.sql.expression.ColumnElement.__ne__(other: Any) → ColumnOperators¶

наследуется от sqlalchemy.sql.expression.ColumnOperators.__ne__ метода ColumnOperators

Реализуйте оператор !=.

В контексте столбца выдает предложение a != b. Если цель None, выдает a IS NOT NULL.

method sqlalchemy.sql.expression.ColumnElement.all_() → ColumnOperators¶

наследуется от ColumnOperators.all_() метода ColumnOperators

Произведите предложение all_() против родительского объекта.

Примеры см. в документации для all_().

Примечание

не путайте более новый метод ColumnOperators.all_() с его более старым аналогом ARRAY, специфическим методом Comparator.all(), который имеет другой синтаксис вызова и схему использования.

attribute sqlalchemy.sql.expression.ColumnElement.allows_lambda = True¶

attribute sqlalchemy.sql.expression.ColumnElement.anon_key_label¶: Не рекомендуется, начиная с версии 1.4: Атрибут ColumnElement.anon_key_label теперь является приватным, а аксессор public устарел.

attribute sqlalchemy.sql.expression.ColumnElement.anon_label¶: Не рекомендуется, начиная с версии 1.4: Атрибут ColumnElement.anon_label теперь является приватным, а аксессор public устарел.

method sqlalchemy.sql.expression.ColumnElement.any_() → ColumnOperators¶

наследуется от ColumnOperators.any_() метода ColumnOperators

Произведите предложение any_() против родительского объекта.

Примеры см. в документации для any_().

Примечание

не путайте более новый метод ColumnOperators.any_() с его более старым аналогом ARRAY, специфическим методом Comparator.any(), который имеет другой синтаксис вызова и схему использования.

method sqlalchemy.sql.expression.ColumnElement.asc() → ColumnOperators¶: наследуется от ColumnOperators.asc() метода ColumnOperators

Произведите предложение asc() против родительского объекта.

attribute sqlalchemy.sql.expression.ColumnElement.base_columns¶

method sqlalchemy.sql.expression.ColumnElement.between(cleft: Any, cright: Any, symmetric: bool = False) → ColumnOperators¶: наследуется от ColumnOperators.between() метода ColumnOperators

Произведите предложение between() против родительского объекта, задав нижний и верхний диапазон.

method sqlalchemy.sql.expression.ColumnElement.bitwise_and(other: Any) → ColumnOperators¶: наследуется от ColumnOperators.bitwise_and() метода ColumnOperators

Произвести побитовую операцию AND, обычно с помощью оператора &.

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

См.также

Побитовые операторы

method sqlalchemy.sql.expression.ColumnElement.bitwise_lshift(other: Any) → ColumnOperators¶: наследуется от ColumnOperators.bitwise_lshift() метода ColumnOperators

Произвести побитовую операцию LSHIFT, обычно с помощью оператора <<.

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

См.также

Побитовые операторы

method sqlalchemy.sql.expression.ColumnElement.bitwise_not() → ColumnOperators¶: наследуется от ColumnOperators.bitwise_not() метода ColumnOperators

Произвести побитовую операцию NOT, обычно с помощью оператора ~.

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

См.также

Побитовые операторы

method sqlalchemy.sql.expression.ColumnElement.bitwise_or(other: Any) → ColumnOperators¶: наследуется от ColumnOperators.bitwise_or() метода ColumnOperators

Произвести операцию побитового ИЛИ, обычно с помощью оператора |.

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

См.также

Побитовые операторы

method sqlalchemy.sql.expression.ColumnElement.bitwise_rshift(other: Any) → ColumnOperators¶: наследуется от ColumnOperators.bitwise_rshift() метода ColumnOperators

Произвести побитовую операцию RSHIFT, обычно с помощью оператора >>.

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

См.также

Побитовые операторы

method sqlalchemy.sql.expression.ColumnElement.bitwise_xor(other: Any) → ColumnOperators¶: наследуется от ColumnOperators.bitwise_xor() метода ColumnOperators

Произвести побитовую операцию XOR, обычно с помощью оператора ^ или # для PostgreSQL.

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

См.также

Побитовые операторы

method sqlalchemy.sql.expression.ColumnElement.bool_op(opstring: str, precedence: int = 0, python_impl: Optional[Callable[[...], Any]] = None) → Callable[[Any], Operators]¶

наследуется от Operators.bool_op() метода Operators

Возвращает пользовательский булев оператор.

Этот метод является сокращением для вызова Operators.op() и передачи флага Operators.op.is_comparison со значением True. Ключевым преимуществом использования Operators.bool_op() является то, что при использовании конструкций столбцов «булева» природа возвращаемого выражения будет присутствовать для целей PEP 484.

См.также

method sqlalchemy.sql.expression.ColumnElement.cast(type_: _TypeEngineArgument[_OPT]) → Cast[_OPT]¶

Произведите приведение типа, т.е. CAST(<expression> AS <type>).

Это сокращение для функции cast().

См.также

Как отобразить SQL-выражения в виде строк, возможно, с вставкой связанных параметров?

type_coerce()

method sqlalchemy.sql.expression.ColumnElement.collate(collation: str) → ColumnOperators¶: наследуется от ColumnOperators.collate() метода ColumnOperators

Производит предложение collate() против родительского объекта, учитывая строку collation.

См.также

collate()

attribute sqlalchemy.sql.expression.ColumnElement.comparator¶

method sqlalchemy.sql.expression.ColumnElement.compare(other: ClauseElement, **kw: Any) → bool¶

наследуется от ClauseElement.compare() метода ClauseElement

Сравните это ClauseElement с заданным ClauseElement.

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

**kw - это аргументы, потребляемые методами подкласса compare() и могут быть использованы для изменения критериев сравнения (см. ColumnElement).

method sqlalchemy.sql.expression.ColumnElement.compile(bind: Optional[Union[Engine, Connection]] = None, dialect: Optional[Dialect] = None, **kw: Any) → Compiled¶

наследуется от CompilerElement.compile() метода CompilerElement

Составьте это SQL-выражение.

Возвращаемое значение представляет собой объект Compiled. Вызов str() или unicode() на возвращаемом значении даст строковое представление результата. Объект Compiled также может возвращать словарь имен и значений параметров связывания, используя аксессор params.

Параметры:

bind – Параметр Connection или Engine, который может предоставить Dialect для генерации объекта Compiled. Если параметры bind и dialect опущены, используется компилятор SQL по умолчанию.
column_keys – Используется для операторов INSERT и UPDATE, список имен столбцов, которые должны присутствовать в предложении VALUES скомпилированного оператора. Если None, отображаются все столбцы из целевого объекта таблицы.
dialect – Экземпляр Dialect, который может генерировать объект Compiled. Этот аргумент имеет приоритет над аргументом bind.
compile_kwargs – необязательный словарь дополнительных параметров, которые будут передаваться компилятору во всех методах «visit». Это позволяет передавать любой пользовательский флаг, например, в пользовательскую конструкцию компиляции. Он также используется для случая передачи флага literal_binds:: from sqlalchemy.sql import table, column, select t = table(„t“, column(„x“)) s = select(t).where(t.c.x == 5) print(s.compile(compile_kwargs={«literal_binds»: True}))

См.также

method sqlalchemy.sql.expression.ColumnElement.concat(other: Any) → ColumnOperators¶

наследуется от ColumnOperators.concat() метода ColumnOperators

Реализуйте оператор „concat“.

В контексте столбца производит предложение a || b, или использует оператор concat() в MySQL.

method sqlalchemy.sql.expression.ColumnElement.contains(other: Any, **kw: Any) → ColumnOperators¶

наследуется от ColumnOperators.contains() метода ColumnOperators

Реализуйте оператор „contains“.

Вырабатывает выражение LIKE, которое проверяет совпадение с серединой строкового значения:

column LIKE '%' || <other> || '%'

Например:

stmt = select(sometable).\
    where(sometable.c.column.contains("foobar"))

Поскольку оператор использует LIKE, символы подстановки "%" и "_", присутствующие внутри выражения <other>, также будут вести себя как символы подстановки. Для буквальных строковых значений флаг ColumnOperators.contains.autoescape может быть установлен в значение True, чтобы применить экранирование к вхождениям этих символов в строковое значение так, чтобы они совпадали сами по себе, а не как символы подстановки. В качестве альтернативы, параметр ColumnOperators.contains.escape устанавливает данный символ как символ экранирования, что может быть полезно, когда целевое выражение не является литеральной строкой.

Параметры:

other – выражение для сравнения. Обычно это обычное строковое значение, но может быть и произвольным выражением SQL. Символы подстановки LIKE % и _ по умолчанию не экранируются, если только флаг ColumnOperators.contains.autoescape не установлен в True.
autoescape – boolean; при значении True устанавливает символ экранирования в выражении LIKE, затем применяет его ко всем вхождениям "%", "_" и самого символа экранирования в значении сравнения, которое предполагается как литеральная строка, а не как выражение SQL. Выражение типа:: somecolumn.contains(«foo%bar», autoescape=True) будет выглядеть так:: somecolumn LIKE „%“ || :param || „%“ ESCAPE „/“ Со значением :param как "foo/%bar".
escape – символ, который при передаче будет отображаться с ключевым словом ESCAPE, чтобы установить этот символ в качестве управляющего символа. Затем этот символ может быть помещен перед вхождениями % и _, чтобы позволить им действовать как самим себе, а не как символам подстановки. Выражение типа:: somecolumn.contains(«foo/%bar», escape=»^») будет выглядеть так:: somecolumn LIKE „%“ || :param || „%“ ESCAPE „^“ Параметр также может быть объединен с ColumnOperators.contains.autoescape:: somecolumn.contains(«foo%bar^bat», escape=»^», autoescape=True) Где выше, заданный литеральный параметр будет преобразован в "foo^%bar^^bat" перед передачей в базу данных.

См.также

method sqlalchemy.sql.expression.ColumnElement.desc() → ColumnOperators¶: наследуется от ColumnOperators.desc() метода ColumnOperators

Произведите предложение desc() против родительского объекта.

attribute sqlalchemy.sql.expression.ColumnElement.description¶: наследуется от ClauseElement.description атрибута ClauseElement

method sqlalchemy.sql.expression.ColumnElement.distinct() → ColumnOperators¶: наследуется от ColumnOperators.distinct() метода ColumnOperators

Произведите предложение distinct() против родительского объекта.

method sqlalchemy.sql.expression.ColumnElement.endswith(other: Any, escape: Optional[str] = None, autoescape: bool = False) → ColumnOperators¶

наследуется от ColumnOperators.endswith() метода ColumnOperators

Реализуйте оператор „endswith“.

Создает выражение LIKE, которое проверяет совпадение с концом строкового значения:

column LIKE '%' || <other>

Например:

stmt = select(sometable).\
    where(sometable.c.column.endswith("foobar"))

Поскольку оператор использует LIKE, символы подстановки "%" и "_", присутствующие внутри выражения <other>, также будут вести себя как символы подстановки. Для буквальных строковых значений флаг ColumnOperators.endswith.autoescape может быть установлен в значение True, чтобы применить экранирование к вхождениям этих символов в строковое значение так, чтобы они совпадали сами по себе, а не как символы подстановки. В качестве альтернативы, параметр ColumnOperators.endswith.escape устанавливает данный символ как символ экранирования, что может быть полезно, когда целевое выражение не является литеральной строкой.

Параметры:

other – выражение для сравнения. Обычно это обычное строковое значение, но может быть и произвольным выражением SQL. Символы подстановки LIKE % и _ по умолчанию не экранируются, если только флаг ColumnOperators.endswith.autoescape не установлен в True.
autoescape – boolean; когда True, устанавливает символ экранирования в выражении LIKE, затем применяет его ко всем вхождениям "%", "_" и самого символа экранирования в значении сравнения, которое предполагается как литеральная строка, а не как выражение SQL. Выражение типа:: somecolumn.endswith(«foo%bar», autoescape=True) будет выглядеть так:: somecolumn LIKE „%“ || :param ESCAPE „/“ Со значением :param как "foo/%bar".
escape – символ, который при передаче будет отображаться с ключевым словом ESCAPE, чтобы установить этот символ в качестве управляющего символа. Затем этот символ может быть помещен перед вхождениями % и _, чтобы позволить им действовать как самим себе, а не как символам подстановки. Выражение типа:: somecolumn.endswith(«foo/%bar», escape=»^») будет выглядеть так:: somecolumn LIKE „%“ || :param ESCAPE „^“ Параметр также может быть объединен с ColumnOperators.endswith.autoescape:: somecolumn.endswith(«foo%bar^bat», escape=»^», autoescape=True) Где выше, данный литеральный параметр будет преобразован в "foo^%bar^^bat" перед передачей в базу данных.

См.также

attribute sqlalchemy.sql.expression.ColumnElement.entity_namespace¶: наследуется от ClauseElement.entity_namespace атрибута ClauseElement

attribute sqlalchemy.sql.expression.ColumnElement.expression¶

Возвращает выражение столбца.

Часть интерфейса проверки; возвращает self.

attribute sqlalchemy.sql.expression.ColumnElement.foreign_keys: AbstractSet[ForeignKey] = frozenset({})¶

method sqlalchemy.sql.expression.ColumnElement.get_children(*, omit_attrs: Tuple[str, ...] = (), **kw: Any) → Iterable[HasTraverseInternals]¶

наследуется от HasTraverseInternals.get_children() метода HasTraverseInternals

Возвращает непосредственные дочерние HasTraverseInternals элементы данного HasTraverseInternals.

Используется для обхода посещений.

method sqlalchemy.sql.expression.ColumnElement.icontains(other: Any, **kw: Any) → ColumnOperators¶

наследуется от ColumnOperators.icontains() метода ColumnOperators

Реализуйте оператор icontains, например, нечувствительную к регистру версию ColumnOperators.contains().

Создает выражение LIKE, которое проверяет нечувствительное соответствие для середины строкового значения:

lower(column) LIKE '%' || lower(<other>) || '%'

Например:

stmt = select(sometable).\
    where(sometable.c.column.icontains("foobar"))

Поскольку оператор использует LIKE, символы подстановки "%" и "_", присутствующие внутри выражения <other>, также будут вести себя как символы подстановки. Для буквальных строковых значений флаг ColumnOperators.icontains.autoescape может быть установлен в значение True, чтобы применить экранирование к вхождениям этих символов в строковое значение так, чтобы они совпадали сами по себе, а не как символы подстановки. В качестве альтернативы, параметр ColumnOperators.icontains.escape устанавливает данный символ как символ экранирования, что может быть полезно, когда целевое выражение не является литеральной строкой.

Параметры:

other – выражение для сравнения. Обычно это обычное строковое значение, но может быть и произвольным выражением SQL. Символы подстановки LIKE % и _ по умолчанию не экранируются, если только флаг ColumnOperators.icontains.autoescape не установлен в True.
autoescape – boolean; при значении True устанавливает символ экранирования в выражении LIKE, затем применяет его ко всем вхождениям "%", "_" и самого символа экранирования в значении сравнения, которое предполагается как литеральная строка, а не выражение SQL. Выражение типа:: somecolumn.icontains(«foo%bar», autoescape=True) будет выглядеть так:: lower(somecolumn) LIKE „%“ || lower(:param) || „%“ ESCAPE „/“ Со значением :param как "foo/%bar".
escape – символ, который при передаче будет отображаться с ключевым словом ESCAPE, чтобы установить этот символ в качестве управляющего символа. Затем этот символ может быть помещен перед вхождениями % и _, чтобы позволить им действовать как самим себе, а не как символам подстановки. Выражение типа:: somecolumn.icontains(«foo/%bar», escape=»^») будет выглядеть так:: lower(somecolumn) LIKE „%“ || lower(:param) || „%“ ESCAPE „^“ Параметр также может быть объединен с ColumnOperators.contains.autoescape:: somecolumn.icontains(«foo%bar^bat», escape=»^», autoescape=True) Где выше, заданный литеральный параметр будет преобразован в "foo^%bar^^bat" перед передачей в базу данных.

См.также

method sqlalchemy.sql.expression.ColumnElement.iendswith(other: Any, escape: Optional[str] = None, autoescape: bool = False) → ColumnOperators¶

наследуется от ColumnOperators.iendswith() метода ColumnOperators

Реализуйте оператор iendswith, например, нечувствительную к регистру версию ColumnOperators.endswith().

Создает выражение LIKE, которое проверяет нечувствительное соответствие конца строкового значения:

lower(column) LIKE '%' || lower(<other>)

Например:

stmt = select(sometable).\
    where(sometable.c.column.iendswith("foobar"))

Поскольку оператор использует LIKE, символы подстановки "%" и "_", присутствующие внутри выражения <other>, также будут вести себя как символы подстановки. Для буквальных строковых значений флаг ColumnOperators.iendswith.autoescape может быть установлен в значение True, чтобы применить экранирование к вхождениям этих символов в строковое значение так, чтобы они совпадали сами по себе, а не как символы подстановки. В качестве альтернативы, параметр ColumnOperators.iendswith.escape устанавливает данный символ как символ экранирования, что может быть полезно, когда целевое выражение не является литеральной строкой.

Параметры:

other – выражение для сравнения. Обычно это обычное строковое значение, но может быть и произвольным выражением SQL. Символы подстановки LIKE % и _ по умолчанию не экранируются, если только флаг ColumnOperators.iendswith.autoescape не установлен в True.
autoescape – boolean; при значении True устанавливает символ экранирования в выражении LIKE, затем применяет его ко всем вхождениям "%", "_" и самого символа экранирования в значении сравнения, которое предполагается как литеральная строка, а не как выражение SQL. Выражение типа:: somecolumn.iendswith(«foo%bar», autoescape=True) будет выглядеть так:: lower(somecolumn) LIKE „%“ || lower(:param) ESCAPE „/“ Со значением :param как "foo/%bar".
escape – символ, который при передаче будет отображаться с ключевым словом ESCAPE, чтобы установить этот символ в качестве управляющего символа. Затем этот символ может быть помещен перед вхождениями % и _, чтобы позволить им действовать как самим себе, а не как символам подстановки. Выражение типа:: somecolumn.iendswith(«foo/%bar», escape=»^») будет выглядеть так:: lower(somecolumn) LIKE „%“ || lower(:param) ESCAPE „^“ Параметр также может быть объединен с ColumnOperators.iendswith.autoescape:: somecolumn.endswith(«foo%bar^bat», escape=»^», autoescape=True) Где выше, заданный литеральный параметр будет преобразован в "foo^%bar^^bat" перед передачей в базу данных.

См.также

method sqlalchemy.sql.expression.ColumnElement.ilike(other: Any, escape: Optional[str] = None) → ColumnOperators¶

наследуется от ColumnOperators.ilike() метода ColumnOperators

Реализуйте оператор ilike, например, нечувствительный к регистру LIKE.

В контексте столбца выдает выражение либо в форме:

lower(a) LIKE lower(other)

Или на бэкендах, поддерживающих оператор ILIKE:

a ILIKE other

Например:

stmt = select(sometable).\
    where(sometable.c.column.ilike("%foobar%"))

Параметры:

other – сравниваемое выражение
escape – необязательный управляющий символ, отображает ключевое слово ESCAPE, например:: somecolumn.ilike(«foo/%bar», escape=»/»)

См.также

ColumnOperators.is_not()

method sqlalchemy.sql.expression.ColumnElement.in_(other: Any) → ColumnOperators¶

наследуется от ColumnOperators.in_() метода ColumnOperators

Реализуйте оператор in.

В контексте столбца производит предложение column IN <other>.

Заданный параметр other может быть:

Список литеральных значений, например:
```
stmt.where(column.in_([1, 2, 3]))
```
В этой форме вызова список элементов преобразуется в набор связанных параметров той же длины, что и данный список:
```
WHERE COL IN (?, ?, ?)
```
Список кортежей может быть предоставлен, если сравнение производится с tuple_(), содержащим несколько выражений:
```
from sqlalchemy import tuple_
stmt.where(tuple_(col1, col2).in_([(1, 10), (2, 20), (3, 30)]))
```
Пустой список, например:
```
stmt.where(column.in_([]))
```
В этой вызывающей форме выражение выдает выражение «пустой набор». Эти выражения адаптированы для отдельных бэкендов и обычно пытаются получить пустой оператор SELECT в качестве подзапроса. Например, на SQLite это выражение выглядит так:
```
WHERE col IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1)
```
Изменено в версии 1.4: пустые выражения IN теперь во всех случаях используют сгенерированный во время выполнения подзапрос SELECT.
Связанный параметр, например bindparam(), может быть использован, если он включает флаг bindparam.expanding:
```
stmt.where(column.in_(bindparam('value', expanding=True)))
```
В этой форме вызова выражение отображает специальное не-SQL выражение-заполнитель, которое выглядит так:
```
WHERE COL IN ([EXPANDING_value])
```
Это выражение-заполнитель перехватывается во время выполнения оператора и преобразуется в форму переменной номера связанного параметра, показанную ранее. Если бы оператор был выполнен как:
```
connection.execute(stmt, {"value": [1, 2, 3]})
```
Базе данных будет передан связанный параметр для каждого значения:
```
WHERE COL IN (?, ?, ?)
```
Добавлено в версии 1.2: добавлены «расширяющие» связанные параметры

Если передан пустой список, то будет выведено специальное выражение «пустой список», специфичное для используемой базы данных. Для SQLite это будет:
```
WHERE COL IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1)
```
Добавлено в версии 1.3: «Расширяющиеся» связанные параметры теперь поддерживают пустые списки

конструкция select(), которая обычно является коррелированным скаляром select:

stmt.where(
    column.in_(
        select(othertable.c.y).
        where(table.c.x == othertable.c.x)
    )
)

В этой вызывающей форме ColumnOperators.in_() отображается так:

WHERE COL IN (SELECT othertable.y
FROM othertable WHERE othertable.x = table.x)

Параметры:: other – список литералов, конструкция select() или конструкция bindparam(), в которой флаг bindparam.expanding установлен в True.

attribute sqlalchemy.sql.expression.ColumnElement.inherit_cache: Optional[bool] = None¶

наследуется от HasCacheKey.inherit_cache атрибута HasCacheKey

См.также

method sqlalchemy.sql.expression.ColumnElement.is_(other: Any) → ColumnOperators¶

наследуется от ColumnOperators.is_() метода ColumnOperators

Реализуйте оператор IS.

Обычно IS генерируется автоматически при сравнении со значением None, которое разрешается в NULL. Однако, явное использование IS может быть желательным при сравнении с булевыми значениями на некоторых платформах.

См.также

attribute sqlalchemy.sql.expression.ColumnElement.is_clause_element = True¶

method sqlalchemy.sql.expression.ColumnElement.is_distinct_from(other: Any) → ColumnOperators¶

наследуется от ColumnOperators.is_distinct_from() метода ColumnOperators

Реализуйте оператор IS DISTINCT FROM.

Выводит «a IS DISTINCT FROM b» на большинстве платформ; на некоторых, таких как SQLite, может выводить «a IS NOT b».

attribute sqlalchemy.sql.expression.ColumnElement.is_dml = False¶

method sqlalchemy.sql.expression.ColumnElement.is_not(other: Any) → ColumnOperators¶

наследуется от ColumnOperators.is_not() метода ColumnOperators

Реализуйте оператор IS NOT.

Обычно IS NOT генерируется автоматически при сравнении со значением None, которое разрешается в NULL. Однако, явное использование IS NOT может быть желательным при сравнении с булевыми значениями на некоторых платформах.

Изменено в версии 1.4: Оператор is_not() переименован из isnot() в предыдущих выпусках. Предыдущее название остается доступным для обратной совместимости.

См.также

method sqlalchemy.sql.expression.ColumnElement.is_not_distinct_from(other: Any) → ColumnOperators¶

наследуется от ColumnOperators.is_not_distinct_from() метода ColumnOperators

Реализуйте оператор IS NOT DISTINCT FROM.

Выводит «a IS NOT DISTINCT FROM b» на большинстве платформ; на некоторых, таких как SQLite, может выводить «a IS b».

Изменено в версии 1.4: Оператор is_not_distinct_from() переименован из isnot_distinct_from() в предыдущих выпусках. Предыдущее название остается доступным для обратной совместимости.

attribute sqlalchemy.sql.expression.ColumnElement.is_selectable = False¶

method sqlalchemy.sql.expression.ColumnElement.isnot(other: Any) → ColumnOperators¶

наследуется от ColumnOperators.isnot() метода ColumnOperators

Реализуйте оператор IS NOT.

См.также

method sqlalchemy.sql.expression.ColumnElement.isnot_distinct_from(other: Any) → ColumnOperators¶

наследуется от ColumnOperators.isnot_distinct_from() метода ColumnOperators

Реализуйте оператор IS NOT DISTINCT FROM.

Выводит «a IS NOT DISTINCT FROM b» на большинстве платформ; на некоторых, таких как SQLite, может выводить «a IS b».

method sqlalchemy.sql.expression.ColumnElement.istartswith(other: Any, escape: Optional[str] = None, autoescape: bool = False) → ColumnOperators¶

наследуется от ColumnOperators.istartswith() метода ColumnOperators

Реализуйте оператор istartswith, например, нечувствительную к регистру версию ColumnOperators.startswith().

Создает выражение LIKE, которое проверяет нечувствительное совпадение начала строкового значения:

lower(column) LIKE lower(<other>) || '%'

Например:

stmt = select(sometable).\
    where(sometable.c.column.istartswith("foobar"))

Поскольку оператор использует LIKE, символы подстановки "%" и "_", присутствующие внутри выражения <other>, также будут вести себя как символы подстановки. Для буквальных строковых значений флаг ColumnOperators.istartswith.autoescape может быть установлен в значение True, чтобы применить экранирование к вхождениям этих символов в строковое значение так, чтобы они совпадали сами по себе, а не как символы подстановки. В качестве альтернативы, параметр ColumnOperators.istartswith.escape устанавливает данный символ как символ экранирования, что может быть полезно, когда целевое выражение не является литеральной строкой.

Параметры:

other – выражение для сравнения. Обычно это обычное строковое значение, но может быть и произвольным выражением SQL. Символы подстановки LIKE % и _ по умолчанию не экранируются, если только флаг ColumnOperators.istartswith.autoescape не установлен в True.
autoescape – boolean; при значении True устанавливает символ экранирования в выражении LIKE, затем применяет его ко всем вхождениям "%", "_" и самого символа экранирования в значении сравнения, которое предполагается как литеральная строка, а не выражение SQL. Выражение типа:: somecolumn.istartswith(«foo%bar», autoescape=True) будет выглядеть так:: lower(somecolumn) LIKE lower(:param) || „%“ ESCAPE „/“ Со значением :param как "foo/%bar".
escape – символ, который при передаче будет отображаться с ключевым словом ESCAPE, чтобы установить этот символ в качестве управляющего символа. Затем этот символ может быть помещен перед вхождениями % и _, чтобы позволить им действовать как самим себе, а не как символам подстановки. Выражение типа:: somecolumn.istartswith(«foo/%bar», escape=»^») будет выглядеть так:: lower(somecolumn) LIKE lower(:param) || „%“ ESCAPE „^“ Параметр также может быть объединен с ColumnOperators.istartswith.autoescape:: somecolumn.istartswith(«foo%bar^bat», escape=»^», autoescape=True) Где выше, заданный литеральный параметр будет преобразован в "foo^%bar^^bat" перед передачей в базу данных.

См.также

attribute sqlalchemy.sql.expression.ColumnElement.key: Optional[str] = None¶

Ключ», который в некоторых обстоятельствах ссылается на данный объект в пространстве имен Python.

Обычно это относится к «ключу» столбца, присутствующему в коллекции .c selectable, например, sometable.c["somekey"] возвращает Column с .key «somekey».

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

Произведите метку столбца, т.е. <columnname> AS <name>.

Это сокращение для функции label().

Если „name“ равно None, будет сгенерировано анонимное имя метки.

method sqlalchemy.sql.expression.ColumnElement.like(other: Any, escape: Optional[str] = None) → ColumnOperators¶

наследуется от ColumnOperators.like() метода ColumnOperators

Реализуйте оператор like.

В контексте столбца выдает выражение:

a LIKE other

Например:

stmt = select(sometable).\
    where(sometable.c.column.like("%foobar%"))

Параметры:

other – сравниваемое выражение
escape – необязательный управляющий символ, отображает ключевое слово ESCAPE, например:: somecolumn.like(«foo/%bar», escape=»/»)

См.также

method sqlalchemy.sql.expression.ColumnElement.match(other: Any, **kwargs: Any) → ColumnOperators¶

наследуется от ColumnOperators.match() метода ColumnOperators

Реализует специфический для базы данных оператор „match“.

ColumnOperators.match() пытается преобразоваться в MATCH-подобную функцию или оператор, предоставляемый бэкендом. Примеры включают:

PostgreSQL - выдает x @@ plainto_tsquery(y).

Изменено в версии 2.0: plainto_tsquery() теперь используется вместо to_tsquery() для PostgreSQL; для совместимости с другими формами смотрите Полнотекстовый поиск.
MySQL - выдает MATCH (x) AGAINST (y IN BOOLEAN MODE).

См.также

match - специфическая для MySQL конструкция с дополнительными возможностями.
Oracle - выдает CONTAINS(x, y).
другие бэкенды могут предоставлять специальные реализации.
Бэкенды без специальной реализации будут выдавать оператор как «MATCH». Это совместимо, например, с SQLite.

attribute sqlalchemy.sql.expression.ColumnElement.negation_clause: ColumnElement[bool]¶

method sqlalchemy.sql.expression.ColumnElement.not_ilike(other: Any, escape: Optional[str] = None) → ColumnOperators¶

наследуется от ColumnOperators.not_ilike() метода ColumnOperators

реализовать оператор NOT ILIKE.

Это эквивалентно использованию отрицания с ColumnOperators.ilike(), то есть ~x.ilike(y).

Изменено в версии 1.4: Оператор not_ilike() переименован из notilike() в предыдущих выпусках. Предыдущее название остается доступным для обратной совместимости.

См.также

method sqlalchemy.sql.expression.ColumnElement.not_in(other: Any) → ColumnOperators¶

наследуется от ColumnOperators.not_in() метода ColumnOperators

реализовать оператор NOT IN.

Это эквивалентно использованию отрицания с ColumnOperators.in_(), то есть ~x.in_(y).

В случае, если other является пустой последовательностью, компилятор выдает выражение «пусто не в». По умолчанию это выражение «1 = 1», которое во всех случаях выдает true. Для изменения этого поведения можно использовать create_engine.empty_in_strategy.

Изменено в версии 1.4: Оператор not_in() переименован из notin_() в предыдущих выпусках. Предыдущее название остается доступным для обратной совместимости.

Изменено в версии 1.2: Операторы ColumnOperators.in_() и ColumnOperators.not_in() теперь по умолчанию выдают «статическое» выражение для пустой последовательности IN.

См.также

method sqlalchemy.sql.expression.ColumnElement.not_like(other: Any, escape: Optional[str] = None) → ColumnOperators¶

наследуется от ColumnOperators.not_like() метода ColumnOperators

реализовать оператор NOT LIKE.

Это эквивалентно использованию отрицания с ColumnOperators.like(), то есть ~x.like(y).

Изменено в версии 1.4: Оператор not_like() переименован из notlike() в предыдущих выпусках. Предыдущее название остается доступным для обратной совместимости.

См.также

method sqlalchemy.sql.expression.ColumnElement.notilike(other: Any, escape: Optional[str] = None) → ColumnOperators¶

наследуется от ColumnOperators.notilike() метода ColumnOperators

реализовать оператор NOT ILIKE.

Это эквивалентно использованию отрицания с ColumnOperators.ilike(), то есть ~x.ilike(y).

См.также

method sqlalchemy.sql.expression.ColumnElement.notin_(other: Any) → ColumnOperators¶

наследуется от ColumnOperators.notin_() метода ColumnOperators

реализовать оператор NOT IN.

Это эквивалентно использованию отрицания с ColumnOperators.in_(), то есть ~x.in_(y).

См.также

method sqlalchemy.sql.expression.ColumnElement.notlike(other: Any, escape: Optional[str] = None) → ColumnOperators¶

наследуется от ColumnOperators.notlike() метода ColumnOperators

реализовать оператор NOT LIKE.

Это эквивалентно использованию отрицания с ColumnOperators.like(), то есть ~x.like(y).

См.также

method sqlalchemy.sql.expression.ColumnElement.nulls_first() → ColumnOperators¶: наследуется от ColumnOperators.nulls_first() метода ColumnOperators

Произведите предложение nulls_first() против родительского объекта.

Изменено в версии 1.4: Оператор nulls_first() переименован из nullsfirst() в предыдущих выпусках. Предыдущее название остается доступным для обратной совместимости.

method sqlalchemy.sql.expression.ColumnElement.nulls_last() → ColumnOperators¶: наследуется от ColumnOperators.nulls_last() метода ColumnOperators

Произведите предложение nulls_last() против родительского объекта.

Изменено в версии 1.4: Оператор nulls_last() переименован из nullslast() в предыдущих выпусках. Предыдущее название остается доступным для обратной совместимости.

method sqlalchemy.sql.expression.ColumnElement.nullsfirst() → ColumnOperators¶: наследуется от ColumnOperators.nullsfirst() метода ColumnOperators

Произведите предложение nulls_first() против родительского объекта.

Изменено в версии 1.4: Оператор nulls_first() переименован из nullsfirst() в предыдущих выпусках. Предыдущее название остается доступным для обратной совместимости.

method sqlalchemy.sql.expression.ColumnElement.nullslast() → ColumnOperators¶: наследуется от ColumnOperators.nullslast() метода ColumnOperators

Произведите предложение nulls_last() против родительского объекта.

Изменено в версии 1.4: Оператор nulls_last() переименован из nullslast() в предыдущих выпусках. Предыдущее название остается доступным для обратной совместимости.

method sqlalchemy.sql.expression.ColumnElement.op(opstring: str, precedence: int = 0, is_comparison: bool = False, return_type: Optional[Union[Type[TypeEngine[Any]], TypeEngine[Any]]] = None, python_impl: Optional[Callable[..., Any]] = None) → Callable[[Any], Operators]¶

наследуется от Operators.op() метода Operators

Произведите общую операторную функцию.

например:

somecolumn.op("*")(5)

производит:

somecolumn * 5

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

somecolumn.op('&')(0xff)

является побитовым И из значения в somecolumn.

Параметры:

opstring – строка, которая будет выведена в качестве инфиксного оператора между этим элементом и выражением, переданным в генерируемую функцию.
precedence – приоритет, который, как ожидается, будет применяться базой данных к оператору в выражениях SQL. Это целочисленное значение служит подсказкой для компилятора SQL, чтобы понять, когда вокруг конкретной операции следует поставить явную скобку. Меньшее число приводит к тому, что выражение будет заключено в скобки, когда оно применяется к другому оператору с более высоким приоритетом. Значение по умолчанию 0 ниже всех операторов, кроме операторов запятой (,) и AS. Значение 100 будет выше или равно всем операторам, а -100 будет ниже или равно всем операторам. … см. также:: Я использую op() для генерации пользовательского оператора, и мои скобки выходят неправильно - подробное описание того, как SQL-компилятор SQLAlchemy отображает круглые скобки
is_comparison – legacy; если True, оператор будет рассматриваться как оператор «сравнения», то есть оцениваться в булево значение true/false, как ==, > и т.д. Этот флаг предусмотрен для того, чтобы ORM-отношения могли установить, что оператор является оператором сравнения, когда он используется в пользовательском условии объединения. Использование параметра is_comparison заменяется использованием метода Operators.bool_op(); этот более лаконичный оператор устанавливает этот параметр автоматически, а также обеспечивает правильную поддержку типа PEP 484, поскольку возвращаемый объект будет выражать тип данных «boolean», т.е. BinaryExpression[bool].
return_type – класс или объект TypeEngine, который заставит возвращаемый тип выражения, создаваемого этим оператором, быть этого типа. По умолчанию операторы, указывающие Operators.op.is_comparison, преобразуются в Boolean, а те, которые не указывают, будут иметь тот же тип, что и левый операнд.
python_impl – необязательная функция Python, которая может оценить два значения Python таким же образом, как этот оператор работает при запуске на сервере базы данных. Полезно для функций оценки SQL-выражений in-Python, например, для гибридных атрибутов ORM, а также для «оценщика» ORM, используемого для сопоставления объектов в сессии после многорядного обновления или удаления. например:: >>> expr = column(„x“).op(„+“, python_impl=lambda a, b: a + b)(„y“) Оператор для приведенного выше выражения будет также работать для не-SQL левых и правых объектов:: >>> expr.operator(5, 10) 15 … versionadded:: 2.0

См.также

Использование пользовательских операторов в условиях присоединения

method sqlalchemy.sql.expression.ColumnElement.operate(op: OperatorType, *other: Any, **kwargs: Any) → ColumnElement[Any]¶

Оперировать с аргументом.

Это самый низкий уровень работы, по умолчанию поднимает NotImplementedError.

Переопределение этого параметра в подклассе может позволить применять общее поведение ко всем операциям. Например, переопределение ColumnOperators для применения func.lower() к левой и правой стороне:

class MyComparator(ColumnOperators):
    def operate(self, op, other, **kwargs):
        return op(func.lower(self), func.lower(other), **kwargs)

Параметры:

op – Вызов оператора.
*other – «другая» сторона операции. Для большинства операций это будет один скаляр.
**kwargs – модификаторы. Они могут передаваться специальными операторами, такими как ColumnOperators.contains().

method sqlalchemy.sql.expression.ColumnElement.params(_ClauseElement__optionaldict: Optional[Mapping[str, Any]] = None, **kwargs: Any) → Self¶

наследуется от ClauseElement.params() метода ClauseElement

Возвращает копию с замененными элементами bindparam().

Возвращает копию этого ClauseElement с элементами bindparam(), замененными значениями, взятыми из заданного словаря:

>>> clause = column('x') + bindparam('foo')
>>> print(clause.compile().params)
{'foo':None}
>>> print(clause.params({'foo':7}).compile().params)
{'foo':7}

attribute sqlalchemy.sql.expression.ColumnElement.primary_key: bool = False¶

attribute sqlalchemy.sql.expression.ColumnElement.proxy_set: util.generic_fn_descriptor[FrozenSet[Any]]¶

набор всех столбцов, которые мы проксируем

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

method sqlalchemy.sql.expression.ColumnElement.regexp_match(pattern: Any, flags: Optional[str] = None) → ColumnOperators¶

наследуется от ColumnOperators.regexp_match() метода ColumnOperators

Реализует специфический для базы данных оператор „regexp match“.

Например:

stmt = select(table.c.some_column).where(
    table.c.some_column.regexp_match('^(b|c)')
)

ColumnOperators.regexp_match() пытается преобразоваться в REGEXP-подобную функцию или оператор, предоставляемый бэкендом, однако конкретный синтаксис регулярного выражения и доступные флаги не зависят от бэкенда.

Примеры включают:

PostgreSQL - выдает x ~ y или x !~ y при отрицании.
Oracle - выдает REGEXP_LIKE(x, y).
SQLite - использует оператор-заместитель SQLite REGEXP и обращается к встроенной программе Python re.match().
другие бэкенды могут предоставлять специальные реализации.
Бэкенды без специальной реализации будут выдавать оператор как «REGEXP» или «NOT REGEXP». Это совместимо, например, с SQLite и MySQL.

В настоящее время поддержка регулярных выражений реализована для Oracle, PostgreSQL, MySQL и MariaDB. Частичная поддержка доступна для SQLite. Поддержка сторонних диалектов может отличаться.

Параметры:

pattern – Строка шаблона регулярного выражения или предложение столбца.
flags – Любые флаги строк регулярных выражений для применения. Флаги, как правило, зависят от бэкенда. Это может быть строка или предложение столбца. Некоторые бэкенды, например PostgreSQL и MariaDB, могут альтернативно указывать флаги как часть шаблона. При использовании флага игнорирования регистра „i“ в PostgreSQL будет использован оператор соответствия регэкспа ~* или !~*.

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

См.также

ColumnOperators.regexp_replace()

method sqlalchemy.sql.expression.ColumnElement.regexp_replace(pattern: Any, replacement: Any, flags: Optional[str] = None) → ColumnOperators¶

наследуется от ColumnOperators.regexp_replace() метода ColumnOperators

Реализует специфический для базы данных оператор „regexp replace“.

Например:

stmt = select(
    table.c.some_column.regexp_replace(
        'b(..)',
        'XY',
        flags='g'
    )
)

ColumnOperators.regexp_replace() пытается разрешиться в REGEXP_REPLACE-подобную функцию, предоставляемую бэкендом, который обычно выдает функцию REGEXP_REPLACE(). Однако конкретный синтаксис регулярного выражения и доступные флаги не зависят от бэкенда.

Поддержка замены регулярных выражений в настоящее время реализована для Oracle, PostgreSQL, MySQL 8 или выше и MariaDB. Поддержка сторонних диалектов может отличаться.

Параметры:

pattern – Строка шаблона регулярного выражения или предложение столбца.
pattern – Заменяющая строка или предложение столбца.
flags – Любые флаги строк регулярных выражений для применения. Флаги, как правило, зависят от бэкенда. Это может быть строка или предложение столбца. Некоторые бэкенды, например PostgreSQL и MariaDB, могут альтернативно указывать флаги как часть шаблона.

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

См.также

ColumnOperators.regexp_match()

method sqlalchemy.sql.expression.ColumnElement.reverse_operate(op: OperatorType, other: Any, **kwargs: Any) → ColumnElement[Any]¶

Обратное действие над аргументом.

Используется так же, как и operate().

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

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

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

method sqlalchemy.sql.expression.ColumnElement.shares_lineage(othercolumn: ColumnElement[Any]) → bool¶: Возвращает True, если данный ColumnElement имеет общего предка с данным ColumnElement.

method sqlalchemy.sql.expression.ColumnElement.startswith(other: Any, escape: Optional[str] = None, autoescape: bool = False) → ColumnOperators¶

наследуется от ColumnOperators.startswith() метода ColumnOperators

Реализуйте оператор startswith.

Создает выражение LIKE, которое проверяет совпадение с началом строкового значения:

column LIKE <other> || '%'

Например:

stmt = select(sometable).\
    where(sometable.c.column.startswith("foobar"))

Поскольку оператор использует LIKE, символы подстановки "%" и "_", присутствующие внутри выражения <other>, также будут вести себя как символы подстановки. Для буквальных строковых значений флаг ColumnOperators.startswith.autoescape может быть установлен в значение True, чтобы применить экранирование к вхождениям этих символов в строковое значение так, чтобы они совпадали сами по себе, а не как символы подстановки. В качестве альтернативы, параметр ColumnOperators.startswith.escape устанавливает данный символ как символ экранирования, что может быть полезно, когда целевое выражение не является литеральной строкой.

Параметры:

other – выражение для сравнения. Обычно это обычное строковое значение, но может быть и произвольным выражением SQL. Символы подстановки LIKE % и _ по умолчанию не экранируются, если только флаг ColumnOperators.startswith.autoescape не установлен в True.
autoescape – boolean; при True устанавливает символ экранирования в выражении LIKE, затем применяет его ко всем вхождениям "%", "_" и самого символа экранирования в значении сравнения, которое считается литеральной строкой, а не выражением SQL. Выражение типа:: somecolumn.startswith(«foo%bar», autoescape=True) будет выглядеть так:: somecolumn LIKE :param || „%“ ESCAPE „/“ Со значением :param как "foo/%bar".
escape – символ, который при передаче будет отображаться с ключевым словом ESCAPE, чтобы установить этот символ в качестве управляющего символа. Затем этот символ может быть помещен перед вхождениями % и _, чтобы позволить им действовать как самим себе, а не как символам подстановки. Выражение типа:: somecolumn.startswith(«foo/%bar», escape=»^») будет выглядеть так:: somecolumn LIKE :param || „%“ ESCAPE „^“ Параметр также может быть объединен с ColumnOperators.startswith.autoescape:: somecolumn.startswith(«foo%bar^bat», escape=»^», autoescape=True) Где выше, данный литеральный параметр будет преобразован в "foo^%bar^^bat" перед передачей в базу данных.

См.также

attribute sqlalchemy.sql.expression.ColumnElement.stringify_dialect = 'default'¶

attribute sqlalchemy.sql.expression.ColumnElement.supports_execution = False¶

attribute sqlalchemy.sql.expression.ColumnElement.timetuple: Literal[None] = None¶: наследуется от ColumnOperators.timetuple атрибута ColumnOperators

Hack, позволяет сравнивать объекты времени даты на LHS.

attribute sqlalchemy.sql.expression.ColumnElement.type: TypeEngine[_T]¶

method sqlalchemy.sql.expression.ColumnElement.unique_params(_ClauseElement__optionaldict: Optional[Dict[str, Any]] = None, **kwargs: Any) → Self¶

наследуется от ClauseElement.unique_params() метода ClauseElement

Возвращает копию с замененными элементами bindparam().

Та же функциональность, что и ClauseElement.params(), за исключением добавления unique=True к параметрам привязки, чтобы можно было использовать несколько утверждений.

attribute sqlalchemy.sql.expression.ColumnElement.uses_inspection = True¶

sqlalchemy.sql.expression.ColumnExpressionArgument¶

Аргумент общего назначения «выражение столбца».

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

Этот тип используется для выражений типа «колонка», которые обычно представляют собой выражение одной колонки SQL, включая ColumnElement, а также ORM-mapped атрибутов, которые будут иметь метод __clause_element__().

class sqlalchemy.sql.expression.ColumnOperators¶

Определяет булевы, сравнительные и другие операторы для выражений ColumnElement.

По умолчанию все методы обращаются вниз к operate() или reverse_operate(), передавая соответствующую операторную функцию из встроенного модуля Python operator или специфическую для SQLAlchemy операторную функцию из sqlalchemy.expression.operators. Например, функция __eq__:

def __eq__(self, other):
    return self.operate(operators.eq, other)

Где operators.eq по сути является:

def eq(a, b):
    return a == b

Основной блок выражения столбцов ColumnElement переопределяет Operators.operate() и другие для возврата дальнейших конструкций ColumnElement, так что операция ==, описанная выше, заменяется конструкцией clause.

См.также

TypeEngine.comparator_factory

ColumnOperators

PropComparator

Members

__add__(), __and__(), __eq__(), __floordiv__(), __ge__(), __getitem__(), __gt__(), __hash__(), __invert__(), __le__(), __lshift__(), __lt__(), __mod__(), __mul__(), __ne__(), __neg__(), __or__(), __radd__(), __rfloordiv__(), __rmod__(), __rmul__(), __rshift__(), __rsub__(), __rtruediv__(), __sa_operate__(), __sub__(), __truediv__(), all_(), any_(), asc(), between(), bitwise_and(), bitwise_lshift(), bitwise_not(), bitwise_or(), bitwise_rshift(), bitwise_xor(), bool_op(), collate(), concat(), contains(), desc(), distinct(), endswith(), icontains(), iendswith(), ilike(), in_(), is_(), is_distinct_from(), is_not(), is_not_distinct_from(), isnot(), isnot_distinct_from(), istartswith(), like(), match(), not_ilike(), not_in(), not_like(), notilike(), notin_(), notlike(), nulls_first(), nulls_last(), nullsfirst(), nullslast(), op(), operate(), regexp_match(), regexp_replace(), reverse_operate(), startswith(), timetuple

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

класс sqlalchemy.sql.expression.ColumnOperators (sqlalchemy.sql.expression.Operators)

method sqlalchemy.sql.expression.ColumnOperators.__add__(other: Any) → ColumnOperators¶

Реализуйте оператор +.

В контексте столбца выдает предложение a + b, если родительский объект имеет нестроковое родство. Если родительский объект имеет строковую аффинити, вырабатывается оператор конкатенации a || b - см. ColumnOperators.concat().

method sqlalchemy.sql.expression.ColumnOperators.__and__(other: Any) → Operators¶

наследуется от sqlalchemy.sql.expression.Operators.__and__ метода Operators

Реализуйте оператор &.

При использовании с выражениями SQL приводит к операции AND, эквивалентной and_(), то есть:

a & b

эквивалентно:

from sqlalchemy import and_
and_(a, b)

При использовании & следует соблюдать осторожность в отношении старшинства операторов; оператор & имеет наивысшее старшинство. Операнды должны быть заключены в круглые скобки, если они содержат дополнительные подвыражения:

(a == 2) & (b == 4)

method sqlalchemy.sql.expression.ColumnOperators.__eq__(other: Any) → ColumnOperators¶

Реализуйте оператор ==.

В контексте столбца выдает предложение a = b. Если цель None, выдает a IS NULL.

method sqlalchemy.sql.expression.ColumnOperators.__floordiv__(other: Any) → ColumnOperators¶

Реализуйте оператор //.

В контексте столбца выдает предложение a / b, которое аналогично «truediv», но считает тип результата целым.

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

method sqlalchemy.sql.expression.ColumnOperators.__ge__(other: Any) → ColumnOperators¶

Реализуйте оператор >=.

В контексте столбца производит предложение a >= b.

method sqlalchemy.sql.expression.ColumnOperators.__getitem__(index: Any) → ColumnOperators¶

Реализуйте оператор [].

Это может использоваться некоторыми специфическими для баз данных типами, такими как PostgreSQL ARRAY и HSTORE.

method sqlalchemy.sql.expression.ColumnOperators.__gt__(other: Any) → ColumnOperators¶

Реализуйте оператор >.

В контексте столбца производит предложение a > b.

method sqlalchemy.sql.expression.ColumnOperators.__hash__()¶: Return hash(self).

method sqlalchemy.sql.expression.ColumnOperators.__invert__() → Operators¶

наследуется от sqlalchemy.sql.expression.Operators.__invert__ метода Operators

Реализуйте оператор ~.

При использовании с выражениями SQL приводит к операции NOT, эквивалентной not_(), то есть:

~a

эквивалентно:

from sqlalchemy import not_
not_(a)

method sqlalchemy.sql.expression.ColumnOperators.__le__(other: Any) → ColumnOperators¶

Реализуйте оператор <=.

В контексте столбца производит предложение a <= b.

method sqlalchemy.sql.expression.ColumnOperators.__lshift__(other: Any) → ColumnOperators¶

реализовать оператор <<.

Не используется ядром SQLAlchemy, это предусмотрено для пользовательских систем операторов, которые хотят использовать << в качестве точки расширения.

method sqlalchemy.sql.expression.ColumnOperators.__lt__(other: Any) → ColumnOperators¶

Реализуйте оператор <.

В контексте столбца производит предложение a < b.

method sqlalchemy.sql.expression.ColumnOperators.__mod__(other: Any) → ColumnOperators¶

Реализуйте оператор %.

В контексте столбца производит предложение a % b.

method sqlalchemy.sql.expression.ColumnOperators.__mul__(other: Any) → ColumnOperators¶

Реализуйте оператор *.

В контексте столбца производит предложение a * b.

method sqlalchemy.sql.expression.ColumnOperators.__ne__(other: Any) → ColumnOperators¶

Реализуйте оператор !=.

В контексте столбца выдает предложение a != b. Если цель None, выдает a IS NOT NULL.

method sqlalchemy.sql.expression.ColumnOperators.__neg__() → ColumnOperators¶

Реализуйте оператор -.

В контексте столбца производит предложение -a.

method sqlalchemy.sql.expression.ColumnOperators.__or__(other: Any) → Operators¶

наследуется от sqlalchemy.sql.expression.Operators.__or__ метода Operators

Реализуйте оператор |.

При использовании с выражениями SQL получается операция OR, эквивалентная or_(), то есть:

a | b

эквивалентно:

from sqlalchemy import or_
or_(a, b)

При использовании | следует соблюдать осторожность в отношении старшинства операторов; оператор | имеет наивысшее старшинство. Операнды должны быть заключены в круглые скобки, если они содержат дополнительные подвыражения:

(a == 2) | (b == 4)

method sqlalchemy.sql.expression.ColumnOperators.__radd__(other: Any) → ColumnOperators¶

Реализуйте оператор + в обратном направлении.

См. ColumnOperators.__add__().

method sqlalchemy.sql.expression.ColumnOperators.__rfloordiv__(other: Any) → ColumnOperators¶

Реализуйте оператор // в обратном направлении.

См. ColumnOperators.__floordiv__().

method sqlalchemy.sql.expression.ColumnOperators.__rmod__(other: Any) → ColumnOperators¶

Реализуйте оператор % в обратном направлении.

См. ColumnOperators.__mod__().

method sqlalchemy.sql.expression.ColumnOperators.__rmul__(other: Any) → ColumnOperators¶

Реализуйте оператор * в обратном направлении.

См. ColumnOperators.__mul__().

method sqlalchemy.sql.expression.ColumnOperators.__rshift__(other: Any) → ColumnOperators¶

реализовать оператор >>.

Не используется ядром SQLAlchemy, это предусмотрено для пользовательских систем операторов, которые хотят использовать >> в качестве точки расширения.

method sqlalchemy.sql.expression.ColumnOperators.__rsub__(other: Any) → ColumnOperators¶

Реализуйте оператор - в обратном направлении.

См. ColumnOperators.__sub__().

method sqlalchemy.sql.expression.ColumnOperators.__rtruediv__(other: Any) → ColumnOperators¶

Реализуйте оператор / в обратном направлении.

См. ColumnOperators.__truediv__().

method sqlalchemy.sql.expression.ColumnOperators.__sa_operate__(op: OperatorType, *other: Any, **kwargs: Any) → Operators¶

наследуется от sqlalchemy.sql.expression.Operators.__sa_operate__ метода Operators

Оперировать с аргументом.

Это самый низкий уровень работы, по умолчанию поднимает NotImplementedError.

class MyComparator(ColumnOperators):
    def operate(self, op, other, **kwargs):
        return op(func.lower(self), func.lower(other), **kwargs)

Параметры:

op – Вызов оператора.
*other – «другая» сторона операции. Для большинства операций это будет один скаляр.
**kwargs – модификаторы. Они могут передаваться специальными операторами, такими как ColumnOperators.contains().

method sqlalchemy.sql.expression.ColumnOperators.__sub__(other: Any) → ColumnOperators¶

Реализуйте оператор -.

В контексте столбца производит предложение a - b.

method sqlalchemy.sql.expression.ColumnOperators.__truediv__(other: Any) → ColumnOperators¶

Реализуйте оператор /.

В контексте столбца производит предложение a / b и считает тип результата числовым.

Изменено в версии 2.0: Оператор truediv для двух целых чисел теперь считается возвращающим числовое значение. Поведение на конкретных бэкендах может отличаться.

method sqlalchemy.sql.expression.ColumnOperators.all_() → ColumnOperators¶

Произведите предложение all_() против родительского объекта.

Примеры см. в документации для all_().

Примечание

method sqlalchemy.sql.expression.ColumnOperators.any_() → ColumnOperators¶

Произведите предложение any_() против родительского объекта.

Примеры см. в документации для any_().

Примечание

method sqlalchemy.sql.expression.ColumnOperators.asc() → ColumnOperators¶: Произведите предложение asc() против родительского объекта.

method sqlalchemy.sql.expression.ColumnOperators.between(cleft: Any, cright: Any, symmetric: bool = False) → ColumnOperators¶: Произведите предложение between() против родительского объекта, задав нижний и верхний диапазон.

method sqlalchemy.sql.expression.ColumnOperators.bitwise_and(other: Any) → ColumnOperators¶: Произвести побитовую операцию AND, обычно с помощью оператора &.

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

См.также

Побитовые операторы

method sqlalchemy.sql.expression.ColumnOperators.bitwise_lshift(other: Any) → ColumnOperators¶: Произвести побитовую операцию LSHIFT, обычно с помощью оператора <<.

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

См.также

Побитовые операторы

method sqlalchemy.sql.expression.ColumnOperators.bitwise_not() → ColumnOperators¶: Произвести побитовую операцию NOT, обычно с помощью оператора ~.

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

См.также

Побитовые операторы

method sqlalchemy.sql.expression.ColumnOperators.bitwise_or(other: Any) → ColumnOperators¶: Произвести операцию побитового ИЛИ, обычно с помощью оператора |.

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

См.также

Побитовые операторы

method sqlalchemy.sql.expression.ColumnOperators.bitwise_rshift(other: Any) → ColumnOperators¶: Произвести побитовую операцию RSHIFT, обычно с помощью оператора >>.

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

См.также

Побитовые операторы

method sqlalchemy.sql.expression.ColumnOperators.bitwise_xor(other: Any) → ColumnOperators¶: Произвести побитовую операцию XOR, обычно с помощью оператора ^ или # для PostgreSQL.

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

См.также

Побитовые операторы

method sqlalchemy.sql.expression.ColumnOperators.bool_op(opstring: str, precedence: int = 0, python_impl: Optional[Callable[[...], Any]] = None) → Callable[[Any], Operators]¶

наследуется от Operators.bool_op() метода Operators

Возвращает пользовательский булев оператор.

См.также

method sqlalchemy.sql.expression.ColumnOperators.collate(collation: str) → ColumnOperators¶: Производит предложение collate() против родительского объекта, учитывая строку collation.

См.также

collate()

method sqlalchemy.sql.expression.ColumnOperators.concat(other: Any) → ColumnOperators¶

Реализуйте оператор „concat“.

В контексте столбца производит предложение a || b, или использует оператор concat() в MySQL.

method sqlalchemy.sql.expression.ColumnOperators.contains(other: Any, **kw: Any) → ColumnOperators¶

Реализуйте оператор „contains“.

Вырабатывает выражение LIKE, которое проверяет совпадение с серединой строкового значения:

column LIKE '%' || <other> || '%'

Например:

stmt = select(sometable).\
    where(sometable.c.column.contains("foobar"))

Параметры:

other – выражение для сравнения. Обычно это обычное строковое значение, но может быть и произвольным выражением SQL. Символы подстановки LIKE % и _ по умолчанию не экранируются, если только флаг ColumnOperators.contains.autoescape не установлен в True.
autoescape – boolean; при значении True устанавливает символ экранирования в выражении LIKE, затем применяет его ко всем вхождениям "%", "_" и самого символа экранирования в значении сравнения, которое предполагается как литеральная строка, а не как выражение SQL. Выражение типа:: somecolumn.contains(«foo%bar», autoescape=True) будет выглядеть так:: somecolumn LIKE „%“ || :param || „%“ ESCAPE „/“ Со значением :param как "foo/%bar".
escape – символ, который при передаче будет отображаться с ключевым словом ESCAPE, чтобы установить этот символ в качестве управляющего символа. Затем этот символ может быть помещен перед вхождениями % и _, чтобы позволить им действовать как самим себе, а не как символам подстановки. Выражение типа:: somecolumn.contains(«foo/%bar», escape=»^») будет выглядеть так:: somecolumn LIKE „%“ || :param || „%“ ESCAPE „^“ Параметр также может быть объединен с ColumnOperators.contains.autoescape:: somecolumn.contains(«foo%bar^bat», escape=»^», autoescape=True) Где выше, заданный литеральный параметр будет преобразован в "foo^%bar^^bat" перед передачей в базу данных.

См.также

method sqlalchemy.sql.expression.ColumnOperators.desc() → ColumnOperators¶: Произведите предложение desc() против родительского объекта.

method sqlalchemy.sql.expression.ColumnOperators.distinct() → ColumnOperators¶: Произведите предложение distinct() против родительского объекта.

method sqlalchemy.sql.expression.ColumnOperators.endswith(other: Any, escape: Optional[str] = None, autoescape: bool = False) → ColumnOperators¶

Реализуйте оператор „endswith“.

Создает выражение LIKE, которое проверяет совпадение с концом строкового значения:

column LIKE '%' || <other>

Например:

stmt = select(sometable).\
    where(sometable.c.column.endswith("foobar"))

Поскольку оператор использует LIKE, символы подстановки "%" и "_", присутствующие внутри выражения <other>, также будут вести себя как символы подстановки. Для буквальных строковых значений флаг ColumnOperators.endswith.autoescape может быть установлен в значение True, чтобы применить экранирование к вхождениям этих символов в строковое значение так, чтобы они совпадали сами по себе, а не как символы подстановки. В качестве альтернативы, параметр ColumnOperators.endswith.escape устанавливает данный символ как символ экранирования, что может быть полезно, когда целевое выражение не является литеральной строкой.

Параметры:

other – выражение для сравнения. Обычно это обычное строковое значение, но может быть и произвольным выражением SQL. Символы подстановки LIKE % и _ по умолчанию не экранируются, если только флаг ColumnOperators.endswith.autoescape не установлен в True.
autoescape – boolean; когда True, устанавливает символ экранирования в выражении LIKE, затем применяет его ко всем вхождениям "%", "_" и самого символа экранирования в значении сравнения, которое предполагается как литеральная строка, а не как выражение SQL. Выражение типа:: somecolumn.endswith(«foo%bar», autoescape=True) будет выглядеть так:: somecolumn LIKE „%“ || :param ESCAPE „/“ Со значением :param как "foo/%bar".
escape – символ, который при передаче будет отображаться с ключевым словом ESCAPE, чтобы установить этот символ в качестве управляющего символа. Затем этот символ может быть помещен перед вхождениями % и _, чтобы позволить им действовать как самим себе, а не как символам подстановки. Выражение типа:: somecolumn.endswith(«foo/%bar», escape=»^») будет выглядеть так:: somecolumn LIKE „%“ || :param ESCAPE „^“ Параметр также может быть объединен с ColumnOperators.endswith.autoescape:: somecolumn.endswith(«foo%bar^bat», escape=»^», autoescape=True) Где выше, данный литеральный параметр будет преобразован в "foo^%bar^^bat" перед передачей в базу данных.

См.также

method sqlalchemy.sql.expression.ColumnOperators.icontains(other: Any, **kw: Any) → ColumnOperators¶

Реализуйте оператор icontains, например, нечувствительную к регистру версию ColumnOperators.contains().

Создает выражение LIKE, которое проверяет нечувствительное соответствие для середины строкового значения:

lower(column) LIKE '%' || lower(<other>) || '%'

Например:

stmt = select(sometable).\
    where(sometable.c.column.icontains("foobar"))

Поскольку оператор использует LIKE, символы подстановки "%" и "_", присутствующие внутри выражения <other>, также будут вести себя как символы подстановки. Для буквальных строковых значений флаг ColumnOperators.icontains.autoescape может быть установлен в значение True, чтобы применить экранирование к вхождениям этих символов в строковое значение так, чтобы они совпадали сами по себе, а не как символы подстановки. В качестве альтернативы, параметр ColumnOperators.icontains.escape устанавливает данный символ как символ экранирования, что может быть полезно, когда целевое выражение не является литеральной строкой.

Параметры:

other – выражение для сравнения. Обычно это обычное строковое значение, но может быть и произвольным выражением SQL. Символы подстановки LIKE % и _ по умолчанию не экранируются, если только флаг ColumnOperators.icontains.autoescape не установлен в True.
autoescape – boolean; при значении True устанавливает символ экранирования в выражении LIKE, затем применяет его ко всем вхождениям "%", "_" и самого символа экранирования в значении сравнения, которое предполагается как литеральная строка, а не выражение SQL. Выражение типа:: somecolumn.icontains(«foo%bar», autoescape=True) будет выглядеть так:: lower(somecolumn) LIKE „%“ || lower(:param) || „%“ ESCAPE „/“ Со значением :param как "foo/%bar".
escape – символ, который при передаче будет отображаться с ключевым словом ESCAPE, чтобы установить этот символ в качестве управляющего символа. Затем этот символ может быть помещен перед вхождениями % и _, чтобы позволить им действовать как самим себе, а не как символам подстановки. Выражение типа:: somecolumn.icontains(«foo/%bar», escape=»^») будет выглядеть так:: lower(somecolumn) LIKE „%“ || lower(:param) || „%“ ESCAPE „^“ Параметр также может быть объединен с ColumnOperators.contains.autoescape:: somecolumn.icontains(«foo%bar^bat», escape=»^», autoescape=True) Где выше, заданный литеральный параметр будет преобразован в "foo^%bar^^bat" перед передачей в базу данных.

См.также

method sqlalchemy.sql.expression.ColumnOperators.iendswith(other: Any, escape: Optional[str] = None, autoescape: bool = False) → ColumnOperators¶

Реализуйте оператор iendswith, например, нечувствительную к регистру версию ColumnOperators.endswith().

Создает выражение LIKE, которое проверяет нечувствительное соответствие конца строкового значения:

lower(column) LIKE '%' || lower(<other>)

Например:

stmt = select(sometable).\
    where(sometable.c.column.iendswith("foobar"))

Поскольку оператор использует LIKE, символы подстановки "%" и "_", присутствующие внутри выражения <other>, также будут вести себя как символы подстановки. Для буквальных строковых значений флаг ColumnOperators.iendswith.autoescape может быть установлен в значение True, чтобы применить экранирование к вхождениям этих символов в строковое значение так, чтобы они совпадали сами по себе, а не как символы подстановки. В качестве альтернативы, параметр ColumnOperators.iendswith.escape устанавливает данный символ как символ экранирования, что может быть полезно, когда целевое выражение не является литеральной строкой.

Параметры:

other – выражение для сравнения. Обычно это обычное строковое значение, но может быть и произвольным выражением SQL. Символы подстановки LIKE % и _ по умолчанию не экранируются, если только флаг ColumnOperators.iendswith.autoescape не установлен в True.
autoescape – boolean; при значении True устанавливает символ экранирования в выражении LIKE, затем применяет его ко всем вхождениям "%", "_" и самого символа экранирования в значении сравнения, которое предполагается как литеральная строка, а не как выражение SQL. Выражение типа:: somecolumn.iendswith(«foo%bar», autoescape=True) будет выглядеть так:: lower(somecolumn) LIKE „%“ || lower(:param) ESCAPE „/“ Со значением :param как "foo/%bar".
escape – символ, который при передаче будет отображаться с ключевым словом ESCAPE, чтобы установить этот символ в качестве управляющего символа. Затем этот символ может быть помещен перед вхождениями % и _, чтобы позволить им действовать как самим себе, а не как символам подстановки. Выражение типа:: somecolumn.iendswith(«foo/%bar», escape=»^») будет выглядеть так:: lower(somecolumn) LIKE „%“ || lower(:param) ESCAPE „^“ Параметр также может быть объединен с ColumnOperators.iendswith.autoescape:: somecolumn.endswith(«foo%bar^bat», escape=»^», autoescape=True) Где выше, заданный литеральный параметр будет преобразован в "foo^%bar^^bat" перед передачей в базу данных.

См.также

method sqlalchemy.sql.expression.ColumnOperators.ilike(other: Any, escape: Optional[str] = None) → ColumnOperators¶

Реализуйте оператор ilike, например, нечувствительный к регистру LIKE.

В контексте столбца выдает выражение либо в форме:

lower(a) LIKE lower(other)

Или на бэкендах, поддерживающих оператор ILIKE:

a ILIKE other

Например:

stmt = select(sometable).\
    where(sometable.c.column.ilike("%foobar%"))

Параметры:

other – сравниваемое выражение
escape – необязательный управляющий символ, отображает ключевое слово ESCAPE, например:: somecolumn.ilike(«foo/%bar», escape=»/»)

См.также

ColumnOperators.is_not()

method sqlalchemy.sql.expression.ColumnOperators.in_(other: Any) → ColumnOperators¶

Реализуйте оператор in.

В контексте столбца производит предложение column IN <other>.

Заданный параметр other может быть:

Список литеральных значений, например:
```
stmt.where(column.in_([1, 2, 3]))
```
В этой форме вызова список элементов преобразуется в набор связанных параметров той же длины, что и данный список:
```
WHERE COL IN (?, ?, ?)
```
Список кортежей может быть предоставлен, если сравнение производится с tuple_(), содержащим несколько выражений:
```
from sqlalchemy import tuple_
stmt.where(tuple_(col1, col2).in_([(1, 10), (2, 20), (3, 30)]))
```
Пустой список, например:
```
stmt.where(column.in_([]))
```
В этой вызывающей форме выражение выдает выражение «пустой набор». Эти выражения адаптированы для отдельных бэкендов и обычно пытаются получить пустой оператор SELECT в качестве подзапроса. Например, на SQLite это выражение выглядит так:
```
WHERE col IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1)
```
Изменено в версии 1.4: пустые выражения IN теперь во всех случаях используют сгенерированный во время выполнения подзапрос SELECT.
Связанный параметр, например bindparam(), может быть использован, если он включает флаг bindparam.expanding:
```
stmt.where(column.in_(bindparam('value', expanding=True)))
```
В этой форме вызова выражение отображает специальное не-SQL выражение-заполнитель, которое выглядит так:
```
WHERE COL IN ([EXPANDING_value])
```
Это выражение-заполнитель перехватывается во время выполнения оператора и преобразуется в форму переменной номера связанного параметра, показанную ранее. Если бы оператор был выполнен как:
```
connection.execute(stmt, {"value": [1, 2, 3]})
```
Базе данных будет передан связанный параметр для каждого значения:
```
WHERE COL IN (?, ?, ?)
```
Добавлено в версии 1.2: добавлены «расширяющие» связанные параметры

Если передан пустой список, то будет выведено специальное выражение «пустой список», специфичное для используемой базы данных. Для SQLite это будет:
```
WHERE COL IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1)
```
Добавлено в версии 1.3: «Расширяющиеся» связанные параметры теперь поддерживают пустые списки

конструкция select(), которая обычно является коррелированным скаляром select:

stmt.where(
    column.in_(
        select(othertable.c.y).
        where(table.c.x == othertable.c.x)
    )
)

В этой вызывающей форме ColumnOperators.in_() отображается так:

WHERE COL IN (SELECT othertable.y
FROM othertable WHERE othertable.x = table.x)

Параметры:: other – список литералов, конструкция select() или конструкция bindparam(), в которой флаг bindparam.expanding установлен в True.

method sqlalchemy.sql.expression.ColumnOperators.is_(other: Any) → ColumnOperators¶

Реализуйте оператор IS.

См.также

method sqlalchemy.sql.expression.ColumnOperators.is_distinct_from(other: Any) → ColumnOperators¶

Реализуйте оператор IS DISTINCT FROM.

Выводит «a IS DISTINCT FROM b» на большинстве платформ; на некоторых, таких как SQLite, может выводить «a IS NOT b».

method sqlalchemy.sql.expression.ColumnOperators.is_not(other: Any) → ColumnOperators¶

Реализуйте оператор IS NOT.

См.также

method sqlalchemy.sql.expression.ColumnOperators.is_not_distinct_from(other: Any) → ColumnOperators¶

Реализуйте оператор IS NOT DISTINCT FROM.

Выводит «a IS NOT DISTINCT FROM b» на большинстве платформ; на некоторых, таких как SQLite, может выводить «a IS b».

method sqlalchemy.sql.expression.ColumnOperators.isnot(other: Any) → ColumnOperators¶

Реализуйте оператор IS NOT.

См.также

method sqlalchemy.sql.expression.ColumnOperators.isnot_distinct_from(other: Any) → ColumnOperators¶

Реализуйте оператор IS NOT DISTINCT FROM.

Выводит «a IS NOT DISTINCT FROM b» на большинстве платформ; на некоторых, таких как SQLite, может выводить «a IS b».

method sqlalchemy.sql.expression.ColumnOperators.istartswith(other: Any, escape: Optional[str] = None, autoescape: bool = False) → ColumnOperators¶

Реализуйте оператор istartswith, например, нечувствительную к регистру версию ColumnOperators.startswith().

Создает выражение LIKE, которое проверяет нечувствительное совпадение начала строкового значения:

lower(column) LIKE lower(<other>) || '%'

Например:

stmt = select(sometable).\
    where(sometable.c.column.istartswith("foobar"))

Поскольку оператор использует LIKE, символы подстановки "%" и "_", присутствующие внутри выражения <other>, также будут вести себя как символы подстановки. Для буквальных строковых значений флаг ColumnOperators.istartswith.autoescape может быть установлен в значение True, чтобы применить экранирование к вхождениям этих символов в строковое значение так, чтобы они совпадали сами по себе, а не как символы подстановки. В качестве альтернативы, параметр ColumnOperators.istartswith.escape устанавливает данный символ как символ экранирования, что может быть полезно, когда целевое выражение не является литеральной строкой.

Параметры:

other – выражение для сравнения. Обычно это обычное строковое значение, но может быть и произвольным выражением SQL. Символы подстановки LIKE % и _ по умолчанию не экранируются, если только флаг ColumnOperators.istartswith.autoescape не установлен в True.
autoescape – boolean; при значении True устанавливает символ экранирования в выражении LIKE, затем применяет его ко всем вхождениям "%", "_" и самого символа экранирования в значении сравнения, которое предполагается как литеральная строка, а не выражение SQL. Выражение типа:: somecolumn.istartswith(«foo%bar», autoescape=True) будет выглядеть так:: lower(somecolumn) LIKE lower(:param) || „%“ ESCAPE „/“ Со значением :param как "foo/%bar".
escape – символ, который при передаче будет отображаться с ключевым словом ESCAPE, чтобы установить этот символ в качестве управляющего символа. Затем этот символ может быть помещен перед вхождениями % и _, чтобы позволить им действовать как самим себе, а не как символам подстановки. Выражение типа:: somecolumn.istartswith(«foo/%bar», escape=»^») будет выглядеть так:: lower(somecolumn) LIKE lower(:param) || „%“ ESCAPE „^“ Параметр также может быть объединен с ColumnOperators.istartswith.autoescape:: somecolumn.istartswith(«foo%bar^bat», escape=»^», autoescape=True) Где выше, заданный литеральный параметр будет преобразован в "foo^%bar^^bat" перед передачей в базу данных.

См.также

method sqlalchemy.sql.expression.ColumnOperators.like(other: Any, escape: Optional[str] = None) → ColumnOperators¶

Реализуйте оператор like.

В контексте столбца выдает выражение:

a LIKE other

Например:

stmt = select(sometable).\
    where(sometable.c.column.like("%foobar%"))

Параметры:

other – сравниваемое выражение
escape – необязательный управляющий символ, отображает ключевое слово ESCAPE, например:: somecolumn.like(«foo/%bar», escape=»/»)

См.также

method sqlalchemy.sql.expression.ColumnOperators.match(other: Any, **kwargs: Any) → ColumnOperators¶

Реализует специфический для базы данных оператор „match“.

PostgreSQL - выдает x @@ plainto_tsquery(y).

Изменено в версии 2.0: plainto_tsquery() теперь используется вместо to_tsquery() для PostgreSQL; для совместимости с другими формами смотрите Полнотекстовый поиск.
MySQL - выдает MATCH (x) AGAINST (y IN BOOLEAN MODE).

См.также

match - специфическая для MySQL конструкция с дополнительными возможностями.
Oracle - выдает CONTAINS(x, y).
другие бэкенды могут предоставлять специальные реализации.
Бэкенды без специальной реализации будут выдавать оператор как «MATCH». Это совместимо, например, с SQLite.

method sqlalchemy.sql.expression.ColumnOperators.not_ilike(other: Any, escape: Optional[str] = None) → ColumnOperators¶

реализовать оператор NOT ILIKE.

Это эквивалентно использованию отрицания с ColumnOperators.ilike(), то есть ~x.ilike(y).

См.также

method sqlalchemy.sql.expression.ColumnOperators.not_in(other: Any) → ColumnOperators¶

реализовать оператор NOT IN.

Это эквивалентно использованию отрицания с ColumnOperators.in_(), то есть ~x.in_(y).

См.также

method sqlalchemy.sql.expression.ColumnOperators.not_like(other: Any, escape: Optional[str] = None) → ColumnOperators¶

реализовать оператор NOT LIKE.

Это эквивалентно использованию отрицания с ColumnOperators.like(), то есть ~x.like(y).

См.также

method sqlalchemy.sql.expression.ColumnOperators.notilike(other: Any, escape: Optional[str] = None) → ColumnOperators¶

реализовать оператор NOT ILIKE.

Это эквивалентно использованию отрицания с ColumnOperators.ilike(), то есть ~x.ilike(y).

См.также

method sqlalchemy.sql.expression.ColumnOperators.notin_(other: Any) → ColumnOperators¶

реализовать оператор NOT IN.

Это эквивалентно использованию отрицания с ColumnOperators.in_(), то есть ~x.in_(y).

См.также

method sqlalchemy.sql.expression.ColumnOperators.notlike(other: Any, escape: Optional[str] = None) → ColumnOperators¶

реализовать оператор NOT LIKE.

Это эквивалентно использованию отрицания с ColumnOperators.like(), то есть ~x.like(y).

См.также

method sqlalchemy.sql.expression.ColumnOperators.nulls_first() → ColumnOperators¶: Произведите предложение nulls_first() против родительского объекта.

Изменено в версии 1.4: Оператор nulls_first() переименован из nullsfirst() в предыдущих выпусках. Предыдущее название остается доступным для обратной совместимости.

method sqlalchemy.sql.expression.ColumnOperators.nulls_last() → ColumnOperators¶: Произведите предложение nulls_last() против родительского объекта.

Изменено в версии 1.4: Оператор nulls_last() переименован из nullslast() в предыдущих выпусках. Предыдущее название остается доступным для обратной совместимости.

method sqlalchemy.sql.expression.ColumnOperators.nullsfirst() → ColumnOperators¶: Произведите предложение nulls_first() против родительского объекта.

Изменено в версии 1.4: Оператор nulls_first() переименован из nullsfirst() в предыдущих выпусках. Предыдущее название остается доступным для обратной совместимости.

method sqlalchemy.sql.expression.ColumnOperators.nullslast() → ColumnOperators¶: Произведите предложение nulls_last() против родительского объекта.

Изменено в версии 1.4: Оператор nulls_last() переименован из nullslast() в предыдущих выпусках. Предыдущее название остается доступным для обратной совместимости.

method sqlalchemy.sql.expression.ColumnOperators.op(opstring: str, precedence: int = 0, is_comparison: bool = False, return_type: Optional[Union[Type[TypeEngine[Any]], TypeEngine[Any]]] = None, python_impl: Optional[Callable[..., Any]] = None) → Callable[[Any], Operators]¶

наследуется от Operators.op() метода Operators

Произведите общую операторную функцию.

например:

somecolumn.op("*")(5)

производит:

somecolumn * 5

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

somecolumn.op('&')(0xff)

является побитовым И из значения в somecolumn.

Параметры:

opstring – строка, которая будет выведена в качестве инфиксного оператора между этим элементом и выражением, переданным в генерируемую функцию.
precedence – приоритет, который, как ожидается, будет применяться базой данных к оператору в выражениях SQL. Это целочисленное значение служит подсказкой для компилятора SQL, чтобы понять, когда вокруг конкретной операции следует поставить явную скобку. Меньшее число приводит к тому, что выражение будет заключено в скобки, когда оно применяется к другому оператору с более высоким приоритетом. Значение по умолчанию 0 ниже всех операторов, кроме операторов запятой (,) и AS. Значение 100 будет выше или равно всем операторам, а -100 будет ниже или равно всем операторам. … см. также:: Я использую op() для генерации пользовательского оператора, и мои скобки выходят неправильно - подробное описание того, как SQL-компилятор SQLAlchemy отображает круглые скобки
is_comparison – legacy; если True, оператор будет рассматриваться как оператор «сравнения», то есть оцениваться в булево значение true/false, как ==, > и т.д. Этот флаг предусмотрен для того, чтобы ORM-отношения могли установить, что оператор является оператором сравнения, когда он используется в пользовательском условии объединения. Использование параметра is_comparison заменяется использованием метода Operators.bool_op(); этот более лаконичный оператор устанавливает этот параметр автоматически, а также обеспечивает правильную поддержку типа PEP 484, поскольку возвращаемый объект будет выражать тип данных «boolean», т.е. BinaryExpression[bool].
return_type – класс или объект TypeEngine, который заставит возвращаемый тип выражения, создаваемого этим оператором, быть этого типа. По умолчанию операторы, указывающие Operators.op.is_comparison, преобразуются в Boolean, а те, которые не указывают, будут иметь тот же тип, что и левый операнд.
python_impl – необязательная функция Python, которая может оценить два значения Python таким же образом, как этот оператор работает при запуске на сервере базы данных. Полезно для функций оценки SQL-выражений in-Python, например, для гибридных атрибутов ORM, а также для «оценщика» ORM, используемого для сопоставления объектов в сессии после многорядного обновления или удаления. например:: >>> expr = column(„x“).op(„+“, python_impl=lambda a, b: a + b)(„y“) Оператор для приведенного выше выражения будет также работать для не-SQL левых и правых объектов:: >>> expr.operator(5, 10) 15 … versionadded:: 2.0

См.также

Использование пользовательских операторов в условиях присоединения

method sqlalchemy.sql.expression.ColumnOperators.operate(op: OperatorType, *other: Any, **kwargs: Any) → Operators¶

наследуется от Operators.operate() метода Operators

Оперировать с аргументом.

Это самый низкий уровень работы, по умолчанию поднимает NotImplementedError.

class MyComparator(ColumnOperators):
    def operate(self, op, other, **kwargs):
        return op(func.lower(self), func.lower(other), **kwargs)

Параметры:

op – Вызов оператора.
*other – «другая» сторона операции. Для большинства операций это будет один скаляр.
**kwargs – модификаторы. Они могут передаваться специальными операторами, такими как ColumnOperators.contains().

method sqlalchemy.sql.expression.ColumnOperators.regexp_match(pattern: Any, flags: Optional[str] = None) → ColumnOperators¶

Реализует специфический для базы данных оператор „regexp match“.

Например:

stmt = select(table.c.some_column).where(
    table.c.some_column.regexp_match('^(b|c)')
)

Примеры включают:

PostgreSQL - выдает x ~ y или x !~ y при отрицании.
Oracle - выдает REGEXP_LIKE(x, y).
SQLite - использует оператор-заместитель SQLite REGEXP и обращается к встроенной программе Python re.match().
другие бэкенды могут предоставлять специальные реализации.
Бэкенды без специальной реализации будут выдавать оператор как «REGEXP» или «NOT REGEXP». Это совместимо, например, с SQLite и MySQL.

Параметры:

pattern – Строка шаблона регулярного выражения или предложение столбца.
flags – Любые флаги строк регулярных выражений для применения. Флаги, как правило, зависят от бэкенда. Это может быть строка или предложение столбца. Некоторые бэкенды, например PostgreSQL и MariaDB, могут альтернативно указывать флаги как часть шаблона. При использовании флага игнорирования регистра „i“ в PostgreSQL будет использован оператор соответствия регэкспа ~* или !~*.

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

См.также

ColumnOperators.regexp_replace()

method sqlalchemy.sql.expression.ColumnOperators.regexp_replace(pattern: Any, replacement: Any, flags: Optional[str] = None) → ColumnOperators¶

Реализует специфический для базы данных оператор „regexp replace“.

Например:

stmt = select(
    table.c.some_column.regexp_replace(
        'b(..)',
        'XY',
        flags='g'
    )
)

Параметры:

pattern – Строка шаблона регулярного выражения или предложение столбца.
pattern – Заменяющая строка или предложение столбца.
flags – Любые флаги строк регулярных выражений для применения. Флаги, как правило, зависят от бэкенда. Это может быть строка или предложение столбца. Некоторые бэкенды, например PostgreSQL и MariaDB, могут альтернативно указывать флаги как часть шаблона.

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

См.также

ColumnOperators.regexp_match()

method sqlalchemy.sql.expression.ColumnOperators.reverse_operate(op: OperatorType, other: Any, **kwargs: Any) → Operators¶

наследуется от Operators.reverse_operate() метода Operators

Обратное действие над аргументом.

Используется так же, как и operate().

method sqlalchemy.sql.expression.ColumnOperators.startswith(other: Any, escape: Optional[str] = None, autoescape: bool = False) → ColumnOperators¶

Реализуйте оператор startswith.

Создает выражение LIKE, которое проверяет совпадение с началом строкового значения:

column LIKE <other> || '%'

Например:

stmt = select(sometable).\
    where(sometable.c.column.startswith("foobar"))

Поскольку оператор использует LIKE, символы подстановки "%" и "_", присутствующие внутри выражения <other>, также будут вести себя как символы подстановки. Для буквальных строковых значений флаг ColumnOperators.startswith.autoescape может быть установлен в значение True, чтобы применить экранирование к вхождениям этих символов в строковое значение так, чтобы они совпадали сами по себе, а не как символы подстановки. В качестве альтернативы, параметр ColumnOperators.startswith.escape устанавливает данный символ как символ экранирования, что может быть полезно, когда целевое выражение не является литеральной строкой.

Параметры:

other – выражение для сравнения. Обычно это обычное строковое значение, но может быть и произвольным выражением SQL. Символы подстановки LIKE % и _ по умолчанию не экранируются, если только флаг ColumnOperators.startswith.autoescape не установлен в True.
autoescape – boolean; при True устанавливает символ экранирования в выражении LIKE, затем применяет его ко всем вхождениям "%", "_" и самого символа экранирования в значении сравнения, которое считается литеральной строкой, а не выражением SQL. Выражение типа:: somecolumn.startswith(«foo%bar», autoescape=True) будет выглядеть так:: somecolumn LIKE :param || „%“ ESCAPE „/“ Со значением :param как "foo/%bar".
escape – символ, который при передаче будет отображаться с ключевым словом ESCAPE, чтобы установить этот символ в качестве управляющего символа. Затем этот символ может быть помещен перед вхождениями % и _, чтобы позволить им действовать как самим себе, а не как символам подстановки. Выражение типа:: somecolumn.startswith(«foo/%bar», escape=»^») будет выглядеть так:: somecolumn LIKE :param || „%“ ESCAPE „^“ Параметр также может быть объединен с ColumnOperators.startswith.autoescape:: somecolumn.startswith(«foo%bar^bat», escape=»^», autoescape=True) Где выше, данный литеральный параметр будет преобразован в "foo^%bar^^bat" перед передачей в базу данных.

См.также

FunctionElement.filter()

attribute sqlalchemy.sql.expression.ColumnOperators.timetuple: Literal[None] = None¶: Hack, позволяет сравнивать объекты времени даты на LHS.

class sqlalchemy.sql.expression.Extract¶: Представьте предложение SQL EXTRACT, extract(field FROM expr).

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

класс sqlalchemy.sql.expression.Extract (sqlalchemy.sql.expression.ColumnElement)

class sqlalchemy.sql.expression.False_¶

Представьте ключевое слово false или его эквивалент в операторе SQL.

Доступ к False_ как к константе осуществляется через функцию false().

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

class sqlalchemy.sql.expression.False_ (sqlalchemy.sql.expression.SingletonConstant, sqlalchemy.sql.roles.ConstExprRole, sqlalchemy.sql.expression.ColumnElement)

class sqlalchemy.sql.expression.FunctionFilter¶

Представьте предложение функции FILTER.

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

Вызов FunctionFilter осуществляется через FunctionElement.filter():

func.count(1).filter(True)

См.также

Members

filter(), over(), self_group()

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

класс sqlalchemy.sql.expression.FunctionFilter (sqlalchemy.sql.expression.ColumnElement)

method sqlalchemy.sql.expression.FunctionFilter.filter(*criterion)¶

Создайте дополнительный ФИЛЬТР против функции.

Этот метод добавляет дополнительные критерии к исходным критериям, установленным с помощью FunctionElement.filter().

Несколько критериев объединяются во время SQL-рендеринга с помощью AND.

method sqlalchemy.sql.expression.FunctionFilter.over(partition_by: Optional[Union[Iterable[_ColumnExpressionArgument[Any]], _ColumnExpressionArgument[Any]]] = None, order_by: Optional[Union[Iterable[_ColumnExpressionArgument[Any]], _ColumnExpressionArgument[Any]]] = None, range_: Optional[typing_Tuple[Optional[int], Optional[int]]] = None, rows: Optional[typing_Tuple[Optional[int], Optional[int]]] = None) → Over[_T]¶

Создайте предложение OVER для этой отфильтрованной функции.

Выражение:

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

является сокращением для:

from sqlalchemy import over, funcfilter
over(funcfilter(func.rank(), MyClass.y > 5), order_by='x')

Полное описание см. в разделе over().

method sqlalchemy.sql.expression.FunctionFilter.self_group(against=None)¶

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

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

class sqlalchemy.sql.expression.Label¶

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

Представляет собой метку, которая обычно применяется к любому элементу уровня столбца с помощью ключевого слова sql AS.

Members

foreign_keys, primary_key, self_group()

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

класс sqlalchemy.sql.expression.Label (sqlalchemy.sql.roles.LabeledColumnExprRole, sqlalchemy.sql.expression.NamedColumn)

attribute sqlalchemy.sql.expression.Label.foreign_keys: AbstractSet[ForeignKey]¶

attribute sqlalchemy.sql.expression.Label.primary_key: bool¶

method sqlalchemy.sql.expression.Label.self_group(against=None)¶

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

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

class sqlalchemy.sql.expression.Null¶

Представьте ключевое слово NULL в операторе SQL.

Доступ к Null как к константе осуществляется через функцию null().

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

class sqlalchemy.sql.expression.Null (sqlalchemy.sql.expression.SingletonConstant, sqlalchemy.sql.roles.ConstExprRole, sqlalchemy.sql.expression.ColumnElement)

class sqlalchemy.sql.expression.Operators¶

База операторов сравнения и логических операторов.

Реализует базовые методы Operators.operate() и Operators.reverse_operate(), а также Operators.__and__(), Operators.__or__(), Operators.__invert__().

Members

__and__(), __invert__(), __or__(), __sa_operate__(), bool_op(), op(), operate(), reverse_operate()

Обычно используется через свой наиболее распространенный подкласс ColumnOperators.

method sqlalchemy.sql.expression.Operators.__and__(other: Any) → Operators¶

Реализуйте оператор &.

При использовании с выражениями SQL приводит к операции AND, эквивалентной and_(), то есть:

a & b

эквивалентно:

from sqlalchemy import and_
and_(a, b)

(a == 2) & (b == 4)

method sqlalchemy.sql.expression.Operators.__invert__() → Operators¶

Реализуйте оператор ~.

При использовании с выражениями SQL приводит к операции NOT, эквивалентной not_(), то есть:

~a

эквивалентно:

from sqlalchemy import not_
not_(a)

method sqlalchemy.sql.expression.Operators.__or__(other: Any) → Operators¶

Реализуйте оператор |.

При использовании с выражениями SQL получается операция OR, эквивалентная or_(), то есть:

a | b

эквивалентно:

from sqlalchemy import or_
or_(a, b)

(a == 2) | (b == 4)

method sqlalchemy.sql.expression.Operators.__sa_operate__(op: OperatorType, *other: Any, **kwargs: Any) → Operators¶

Оперировать с аргументом.

Это самый низкий уровень работы, по умолчанию поднимает NotImplementedError.

class MyComparator(ColumnOperators):
    def operate(self, op, other, **kwargs):
        return op(func.lower(self), func.lower(other), **kwargs)

Параметры:

op – Вызов оператора.
*other – «другая» сторона операции. Для большинства операций это будет один скаляр.
**kwargs – модификаторы. Они могут передаваться специальными операторами, такими как ColumnOperators.contains().

method sqlalchemy.sql.expression.Operators.bool_op(opstring: str, precedence: int = 0, python_impl: Optional[Callable[[...], Any]] = None) → Callable[[Any], Operators]¶

Возвращает пользовательский булев оператор.

См.также

method sqlalchemy.sql.expression.Operators.op(opstring: str, precedence: int = 0, is_comparison: bool = False, return_type: Optional[Union[Type[TypeEngine[Any]], TypeEngine[Any]]] = None, python_impl: Optional[Callable[..., Any]] = None) → Callable[[Any], Operators]¶

Произведите общую операторную функцию.

например:

somecolumn.op("*")(5)

производит:

somecolumn * 5

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

somecolumn.op('&')(0xff)

является побитовым И из значения в somecolumn.

Параметры:

opstring – строка, которая будет выведена в качестве инфиксного оператора между этим элементом и выражением, переданным в генерируемую функцию.
precedence – приоритет, который, как ожидается, будет применяться базой данных к оператору в выражениях SQL. Это целочисленное значение служит подсказкой для компилятора SQL, чтобы понять, когда вокруг конкретной операции следует поставить явную скобку. Меньшее число приводит к тому, что выражение будет заключено в скобки, когда оно применяется к другому оператору с более высоким приоритетом. Значение по умолчанию 0 ниже всех операторов, кроме операторов запятой (,) и AS. Значение 100 будет выше или равно всем операторам, а -100 будет ниже или равно всем операторам. … см. также:: Я использую op() для генерации пользовательского оператора, и мои скобки выходят неправильно - подробное описание того, как SQL-компилятор SQLAlchemy отображает круглые скобки
is_comparison – legacy; если True, оператор будет рассматриваться как оператор «сравнения», то есть оцениваться в булево значение true/false, как ==, > и т.д. Этот флаг предусмотрен для того, чтобы ORM-отношения могли установить, что оператор является оператором сравнения, когда он используется в пользовательском условии объединения. Использование параметра is_comparison заменяется использованием метода Operators.bool_op(); этот более лаконичный оператор устанавливает этот параметр автоматически, а также обеспечивает правильную поддержку типа PEP 484, поскольку возвращаемый объект будет выражать тип данных «boolean», т.е. BinaryExpression[bool].
return_type – класс или объект TypeEngine, который заставит возвращаемый тип выражения, создаваемого этим оператором, быть этого типа. По умолчанию операторы, указывающие Operators.op.is_comparison, преобразуются в Boolean, а те, которые не указывают, будут иметь тот же тип, что и левый операнд.
python_impl – необязательная функция Python, которая может оценить два значения Python таким же образом, как этот оператор работает при запуске на сервере базы данных. Полезно для функций оценки SQL-выражений in-Python, например, для гибридных атрибутов ORM, а также для «оценщика» ORM, используемого для сопоставления объектов в сессии после многорядного обновления или удаления. например:: >>> expr = column(„x“).op(„+“, python_impl=lambda a, b: a + b)(„y“) Оператор для приведенного выше выражения будет также работать для не-SQL левых и правых объектов:: >>> expr.operator(5, 10) 15 … versionadded:: 2.0

См.также

Использование пользовательских операторов в условиях присоединения

method sqlalchemy.sql.expression.Operators.operate(op: OperatorType, *other: Any, **kwargs: Any) → Operators¶

Оперировать с аргументом.

Это самый низкий уровень работы, по умолчанию поднимает NotImplementedError.

class MyComparator(ColumnOperators):
    def operate(self, op, other, **kwargs):
        return op(func.lower(self), func.lower(other), **kwargs)

Параметры:

op – Вызов оператора.
*other – «другая» сторона операции. Для большинства операций это будет один скаляр.
**kwargs – модификаторы. Они могут передаваться специальными операторами, такими как ColumnOperators.contains().

method sqlalchemy.sql.expression.Operators.reverse_operate(op: OperatorType, other: Any, **kwargs: Any) → Operators¶

Обратное действие над аргументом.

Используется так же, как и operate().

class sqlalchemy.sql.expression.Over¶

Представьте пункт OVER.

Это специальный оператор против так называемой «оконной» функции, а также любой агрегатной функции, которая выдает результаты относительно самого набора результатов. Большинство современных бэкендов SQL теперь поддерживают оконные функции.

Members

element

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

класс sqlalchemy.sql.expression.Over (sqlalchemy.sql.expression.ColumnElement)

attribute sqlalchemy.sql.expression.Over.element: ColumnElement[_T]¶: Базовый объект выражения, на который ссылается данный объект Over.

class sqlalchemy.sql.expression.SQLColumnExpression¶

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

SQLColumnExpression является основой ColumnElement, а также входит в основы элементов ORM, таких как InstrumentedAttribute, и может использоваться в типизации PEP 484 для указания аргументов или возвращаемых значений, которые должны вести себя как столбцовые выражения.

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

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

class sqlalchemy.sql.expression.SQLColumnExpression (sqlalchemy.sql.expression.SQLCoreOperations, sqlalchemy.sql.roles.ExpressionElementRole, sqlalchemy.util.langhelpers.TypingOnly)

class sqlalchemy.sql.expression.TextClause¶

Представляет собой литеральный фрагмент текста SQL.

Например:

from sqlalchemy import text

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

Конструкция TextClause создается с помощью функции text(); полную документацию по этой функции см. в этой статье.

См.также

text()

Members

bindparams(), columns(), self_group()

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

class sqlalchemy.sql.expression.TextClause (sqlalchemy.sql.roles.DDLConstraintColumnRole, sqlalchemy.sql.roles.DDLExpressionRole, sqlalchemy.sql.roles.StatementOptionRole, sqlalchemy.sql.roles.WhereHavingRole, sqlalchemy.sql.roles.OrderByRole, sqlalchemy.sql.roles.FromClauseRole, sqlalchemy.sql.roles.SelectStatementRole, sqlalchemy.sql.roles.InElementRole, sqlalchemy.sql.expression.Generative, sqlalchemy.sql.expression.Executable, sqlalchemy.sql.expression.DQLDMLClauseElement, sqlalchemy.sql.roles.BinaryElementRole, sqlalchemy.inspection.Inspectable)

method sqlalchemy.sql.expression.TextClause.bindparams(*binds: BindParameter[Any], **names_to_values: Any) → Self¶

Устанавливает значения и/или типы связанных параметров внутри данной конструкции TextClause.

Дана текстовая конструкция, например:

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

метод TextClause.bindparams() можно использовать для установки начального значения :name и :timestamp, используя простые аргументы ключевых слов:

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

Там, где указано выше, будут созданы новые объекты BindParameter с именами name и timestamp, и значениями jack и datetime.datetime(2012, 10, 8, 15, 12, 5), соответственно. Типы будут выведены из заданных значений, в данном случае String и DateTime.

Когда требуется конкретное поведение типизации, можно использовать позиционный аргумент *binds, в котором непосредственно указываются конструкции bindparam(). Эти конструкции должны включать как минимум аргумент key, затем необязательное значение и тип:

from sqlalchemy import bindparam
stmt = stmt.bindparams(
                bindparam('name', value='jack', type_=String),
                bindparam('timestamp', type_=DateTime)
            )

Выше мы указали тип DateTime для привязки timestamp, и тип String для привязки name. В случае с name мы также задали значение по умолчанию "jack".

Дополнительные связанные параметры могут быть заданы во время выполнения оператора, например:

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

Метод TextClause.bindparams() можно вызывать многократно, при этом он будет повторно использовать существующие объекты BindParameter для добавления новой информации. Например, мы можем вызвать TextClause.bindparams() сначала с информацией о типе, а второй раз с информацией о значении, и они будут объединены:

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

Метод TextClause.bindparams() также поддерживает концепцию уникальных связанных параметров. Это параметры, которые «уникализируются» по имени во время компиляции оператора, так что несколько конструкций text() могут быть объединены вместе без конфликта имен. Чтобы использовать эту возможность, укажите флаг BindParameter.unique на каждом объекте bindparam():

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

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

Вышеприведенное утверждение будет выглядеть так:

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

Добавлено в версии 1.3.11: Добавлена поддержка флага BindParameter.unique для работы с конструкциями text().

method sqlalchemy.sql.expression.TextClause.columns(*cols: _ColumnExpressionArgument[Any], **types: TypeEngine[Any]) → TextualSelect¶

Превратите этот объект TextClause в объект TextualSelect, который выполняет ту же роль, что и оператор SELECT.

TextualSelect является частью иерархии SelectBase и может быть встроен в другой оператор с помощью метода TextualSelect.subquery() для создания объекта Subquery, из которого затем может быть произведен ВЫБОР.

Эта функция, по сути, устраняет разрыв между полностью текстовым оператором SELECT и понятием «выбираемый» в языке выражений SQL:

from sqlalchemy.sql import column, text

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

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

Выше мы позиционно передаем серию элементов column() методу TextClause.columns(). Эти элементы column() теперь становятся элементами первого класса в коллекции столбцов TextualSelect.selected_columns, которые затем становятся частью коллекции Subquery.c после вызова метода TextualSelect.subquery().

Выражения столбцов, которые мы передаем в TextClause.columns(), также могут быть типизированы; когда мы это делаем, эти объекты TypeEngine становятся эффективным возвращаемым типом столбца, так что системы обработки набора результатов SQLAlchemy могут быть использованы для возвращаемых значений. Это часто необходимо для таких типов, как дата или булевы типы, а также для обработки юникода в некоторых конфигурациях диалекта:

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

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

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

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

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

Позиционная форма TextClause.columns() также предоставляет уникальную возможность позиционного нацеливания на столбец, что особенно полезно при использовании ORM со сложными текстовыми запросами. Если мы укажем столбцы из нашей модели в TextClause.columns(), набор результатов будет соответствовать этим столбцам позиционно, то есть имя или происхождение столбца в текстовом SQL не имеет значения:

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

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

Метод TextClause.columns() обеспечивает прямой путь к вызову FromClause.subquery(), а также SelectBase.cte() против текстового оператора SELECT:

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

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

Параметры:

*cols – Серия ColumnElement объектов, обычно Column объектов из Table или атрибутов column-mapped уровня ORM, представляющих набор колонок, из которых будет ВЫБИРАТЬСЯ данная текстовая строка.
**types – Отображение строковых имен на объекты типа TypeEngine, указывающие типы данных, которые следует использовать для имен, выбираемых из текстовой строки. Предпочтительнее использовать аргумент *cols, так как он также указывает на позиционное упорядочивание.

method sqlalchemy.sql.expression.TextClause.self_group(against=None)¶

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

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

class sqlalchemy.sql.expression.TryCast¶

Представляет собой выражение TRY_CAST.

Подробности об использовании TryCast приведены в try_cast().

См.также

try_cast()

Members

inherit_cache

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

класс sqlalchemy.sql.expression.TryCast (sqlalchemy.sql.expression.Cast)

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

См.также

class sqlalchemy.sql.expression.Tuple¶

Представляет собой кортеж SQL.

Members

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

класс sqlalchemy.sql.expression.Tuple (sqlalchemy.sql.expression.ClauseList, sqlalchemy.sql.expression.ColumnElement)

method sqlalchemy.sql.expression.Tuple.self_group(against=None)¶

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

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

class sqlalchemy.sql.expression.WithinGroup¶

Представьте предложение WITHIN GROUP (ORDER BY).

Это специальный оператор против так называемых функций «упорядоченного агрегата множеств» и «гипотетического агрегата множеств», включая percentile_cont(), rank(), dense_rank() и т.д.

Он поддерживается только некоторыми базами данных, такими как PostgreSQL, Oracle и MS SQL Server.

Конструкция WithinGroup извлекает свой тип из метода FunctionElement.within_group_type(). Если при этом возвращается None, то используется .type функции.

Members

over()

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

класс sqlalchemy.sql.expression.WithinGroup (sqlalchemy.sql.expression.ColumnElement)

method sqlalchemy.sql.expression.WithinGroup.over(partition_by=None, order_by=None, range_=None, rows=None)¶

Произведите предложение OVER против этой конструкции WithinGroup.

Эта функция имеет ту же сигнатуру, что и функция FunctionElement.over().

class sqlalchemy.sql.elements.WrapsColumnExpression¶: Миксин, определяющий ColumnElement как обертку со специальным поведением метки для выражения, которое уже имеет имя.

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

См.также

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

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

класс sqlalchemy.sql.expression.WrapsColumnExpression (sqlalchemy.sql.expression.ColumnElement)

class sqlalchemy.sql.expression.True_¶

Представьте ключевое слово true или его эквивалент в операторе SQL.

Доступ к True_ как к константе осуществляется через функцию true().

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

class sqlalchemy.sql.expression.True_ (sqlalchemy.sql.expression.SingletonConstant, sqlalchemy.sql.roles.ConstExprRole, sqlalchemy.sql.expression.ColumnElement)

class sqlalchemy.sql.expression.TypeCoerce¶

Представляет собой обертку для приведения типов со стороны Python.

TypeCoerce поставляет функцию type_coerce(); подробности использования см. в этой функции.

См.также

type_coerce()

Members

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

класс sqlalchemy.sql.expression.TypeCoerce (sqlalchemy.sql.expression.WrapsColumnExpression)

method sqlalchemy.sql.expression.TypeCoerce.self_group(against=None)¶

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

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

class sqlalchemy.sql.expression.UnaryExpression¶

Определите «унарное» выражение.

Унарное выражение состоит из одного столбцового выражения и оператора. Оператор может быть расположен слева (где он называется «оператор») или справа (где он называется «модификатор») от столбцового выражения.

UnaryExpression является основой для нескольких унарных операторов, включая те, которые используются в desc(), asc(), distinct(), nulls_first() и nulls_last().

Members