Описание баз данных с помощью метаданных¶

Доступ к таблицам и столбцам¶

Объект MetaData содержит все конструкции схемы, которые мы с ним связали. Он поддерживает несколько методов доступа к этим табличным объектам, например, аксессор sorted_tables, который возвращает список каждого объекта Table в порядке зависимости от внешнего ключа (то есть, перед каждой таблицей указываются все таблицы, на которые она ссылается):

>>> for t in metadata_obj.sorted_tables:
...     print(t.name)
user
user_preference
invoice
invoice_item

В большинстве случаев отдельные объекты Table объявляются явно, и к этим объектам обычно обращаются напрямую как к переменным на уровне модуля в приложении. Как только объект Table определен, он имеет полный набор аксессоров, которые позволяют проверить его свойства. Учитывая следующее определение Table:

employees = Table(
    "employees",
    metadata_obj,
    Column("employee_id", Integer, primary_key=True),
    Column("employee_name", String(60), nullable=False),
    Column("employee_dept", Integer, ForeignKey("departments.department_id")),
)

Обратите внимание на объект ForeignKey, используемый в этой таблице - эта конструкция определяет ссылку на удаленную таблицу и полностью описана в Определение внешних ключей. Методы доступа к информации об этой таблице включают:

# access the column "employee_id":
employees.columns.employee_id

# or just
employees.c.employee_id

# via string
employees.c["employee_id"]

# a tuple of columns may be returned using multiple strings
# (new in 2.0)
emp_id, name, type = employees.c["employee_id", "name", "type"]

# iterate through all columns
for c in employees.c:
    print(c)

# get the table's primary key columns
for primary_key in employees.primary_key:
    print(primary_key)

# get the table's foreign key objects:
for fkey in employees.foreign_keys:
    print(fkey)

# access the table's MetaData:
employees.metadata

# access a column's name, type, nullable, primary key, foreign key
employees.c.employee_id.name
employees.c.employee_id.type
employees.c.employee_id.nullable
employees.c.employee_id.primary_key
employees.c.employee_dept.foreign_keys

# get the "key" of a column, which defaults to its name, but can
# be any user-defined string:
employees.c.employee_name.key

# access a column's table:
employees.c.employee_id.table is employees

# get the table related by a foreign key
list(employees.c.employee_dept.foreign_keys)[0].column.table

Создание и удаление таблиц базы данных¶

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

Обычным способом создания CREATE является использование create_all() на объекте MetaData. Этот метод выдает запросы, которые сначала проверяют существование каждой отдельной таблицы и, если она не найдена, выдают утверждения CREATE:

engine = create_engine("sqlite:///:memory:")

metadata_obj = MetaData()

user = Table(
    "user",
    metadata_obj,
    Column("user_id", Integer, primary_key=True),
    Column("user_name", String(16), nullable=False),
    Column("email_address", String(60), key="email"),
    Column("nickname", String(50), nullable=False),
)

user_prefs = Table(
    "user_prefs",
    metadata_obj,
    Column("pref_id", Integer, primary_key=True),
    Column("user_id", Integer, ForeignKey("user.user_id"), nullable=False),
    Column("pref_name", String(40), nullable=False),
    Column("pref_value", String(100)),
)

metadata_obj.create_all(engine)
{execsql}PRAGMA table_info(user){}
CREATE TABLE user(
        user_id INTEGER NOT NULL PRIMARY KEY,
        user_name VARCHAR(16) NOT NULL,
        email_address VARCHAR(60),
        nickname VARCHAR(50) NOT NULL
)
PRAGMA table_info(user_prefs){}
CREATE TABLE user_prefs(
        pref_id INTEGER NOT NULL PRIMARY KEY,
        user_id INTEGER NOT NULL REFERENCES user(user_id),
        pref_name VARCHAR(40) NOT NULL,
        pref_value VARCHAR(100)
)

create_all() создает ограничения внешнего ключа между таблицами обычно в строке определения самой таблицы, и по этой причине он также генерирует таблицы в порядке их зависимости. Существуют опции, позволяющие изменить это поведение так, чтобы вместо него использовалось ALTER TABLE.

Отбрасывание всех таблиц аналогично достигается с помощью метода drop_all(). Этот метод действует прямо противоположно методу create_all() - сначала проверяется наличие каждой таблицы, и таблицы удаляются в обратном порядке зависимости.

Создание и удаление отдельных таблиц может быть выполнено с помощью методов create() и drop() из Table. Эти методы по умолчанию выдают CREATE или DROP независимо от наличия таблицы:

engine = create_engine("sqlite:///:memory:")

metadata_obj = MetaData()

employees = Table(
    "employees",
    metadata_obj,
    Column("employee_id", Integer, primary_key=True),
    Column("employee_name", String(60), nullable=False, key="name"),
    Column("employee_dept", Integer, ForeignKey("departments.department_id")),
)
employees.create(engine)
{execsql}CREATE TABLE employees(
    employee_id SERIAL NOT NULL PRIMARY KEY,
    employee_name VARCHAR(60) NOT NULL,
    employee_dept INTEGER REFERENCES departments(department_id)
)
{}

drop() метод:

employees.drop(engine)
{execsql}DROP TABLE employees
{}

Чтобы включить логику «сначала проверить, существует ли таблица», добавьте аргумент checkfirst=True к create() или drop():

employees.create(engine, checkfirst=True)
employees.drop(engine, checkfirst=False)

Изменение объектов базы данных с помощью миграции¶

В то время как SQLAlchemy непосредственно поддерживает создание операторов CREATE и DROP для схемных конструкций, возможность изменения этих конструкций, обычно с помощью оператора ALTER, а также других конструкций, специфичных для базы данных, находится вне сферы применения SQLAlchemy. Хотя достаточно легко создавать операторы ALTER и подобные им вручную, например, передавая конструкцию text() в Connection.execute() или используя конструкцию DDL, общепринятой практикой является автоматизация обслуживания схем баз данных по отношению к коду приложений с помощью инструментов миграции схем.

Проект SQLAlchemy предлагает для этой цели инструмент миграции Alembic. Alembic имеет высоконастраиваемую среду и минималистичную схему использования, поддерживает такие возможности, как транзакционный DDL, автоматическое создание «кандидатов» на миграцию, «автономный» режим, в котором создаются SQL-скрипты, и поддержку разрешения ветвлений.

Alembic заменяет проект SQLAlchemy-Migrate, который является оригинальным инструментом миграции для SQLAlchemy и теперь считается наследием.

Указание имени схемы¶

Большинство баз данных поддерживают концепцию нескольких «схем» - пространств имен, которые ссылаются на альтернативные наборы таблиц и других конструкций. Геометрия «схемы» на стороне сервера принимает множество форм, включая имена «схем» под областью действия конкретной базы данных (например, схемы PostgreSQL), именованные базы данных-родственники (например, доступ MySQL / MariaDB к другим базам данных на том же сервере), а также другие концепции, такие как таблицы, принадлежащие другим именам пользователей (Oracle, SQL Server) или даже имена, которые ссылаются на альтернативные файлы базы данных (SQLite ATTACH) или удаленные серверы (Oracle DBLINK с синонимами).

Все вышеперечисленные подходы (в основном) объединяет то, что существует способ обращения к этому альтернативному набору таблиц с помощью строкового имени. SQLAlchemy называет это имя имя схемы. В SQLAlchemy это не что иное, как строковое имя, которое ассоциируется с объектом Table, а затем преобразуется в SQL-запросы в соответствии с целевой базой данных таким образом, что таблица упоминается в своей удаленной «схеме», каким бы механизмом она ни была в целевой базе данных.

Имя «схемы» может быть связано непосредственно с Table с помощью аргумента Table.schema; при использовании ORM с конфигурацией declarative table параметр передается с помощью словаря параметров __table_args__.

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

Самый простой пример - аргумент Table.schema использует объект Core Table следующим образом:

metadata_obj = MetaData()

financial_info = Table(
    "financial_info",
    metadata_obj,
    Column("id", Integer, primary_key=True),
    Column("value", String(100), nullable=False),
    schema="remote_banks",
)

SQL, который отображается с использованием этого Table, например, оператор SELECT ниже, будет явно квалифицировать имя таблицы financial_info с именем схемы remote_banks:

>>> print(select(financial_info))
{printsql}SELECT remote_banks.financial_info.id, remote_banks.financial_info.value
FROM remote_banks.financial_info

Когда объект Table объявляется с явным именем схемы, он хранится во внутреннем пространстве имен MetaData, используя комбинацию имени схемы и таблицы. Мы можем просмотреть его в коллекции MetaData.tables путем поиска по ключу 'remote_banks.financial_info':

>>> metadata_obj.tables["remote_banks.financial_info"]
Table('financial_info', MetaData(),
Column('id', Integer(), table=<financial_info>, primary_key=True, nullable=False),
Column('value', String(length=100), table=<financial_info>, nullable=False),
schema='remote_banks')

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

customer = Table(
    "customer",
    metadata_obj,
    Column("id", Integer, primary_key=True),
    Column("financial_info_id", ForeignKey("remote_banks.financial_info.id")),
    schema="remote_banks",
)

Аргумент Table.schema может также использоваться в некоторых диалектах для указания пути к конкретной таблице с несколькими маркерами (например, точечными). Это особенно важно для таких баз данных, как Microsoft SQL Server, где часто встречаются точечные маркеры «база данных/владелец». Токены могут быть сразу помещены непосредственно в имя, например:

schema = "dbo.scott"

metadata_obj = MetaData(schema="remote_banks")

financial_info = Table(
    "financial_info",
    metadata_obj,
    Column("id", Integer, primary_key=True),
    Column("value", String(100), nullable=False),
)

metadata_obj.tables["remote_banks.financial_info"]

# either will work:

refers_to_financial_info = Table(
    "refers_to_financial_info",
    metadata_obj,
    Column("id", Integer, primary_key=True),
    Column("fiid", ForeignKey("financial_info.id")),
)


# or

refers_to_financial_info = Table(
    "refers_to_financial_info",
    metadata_obj,
    Column("id", Integer, primary_key=True),
    Column("fiid", ForeignKey("remote_banks.financial_info.id")),
)

from sqlalchemy import BLANK_SCHEMA

metadata_obj = MetaData(schema="remote_banks")

financial_info = Table(
    "financial_info",
    metadata_obj,
    Column("id", Integer, primary_key=True),
    Column("value", String(100), nullable=False),
    schema=BLANK_SCHEMA,  # will not use "remote_banks"
)

from sqlalchemy import event
from sqlalchemy import create_engine

engine = create_engine("oracle+cx_oracle://scott:tiger@tsn_name")


@event.listens_for(engine, "connect", insert=True)
def set_current_schema(dbapi_connection, connection_record):
    cursor_obj = dbapi_connection.cursor()
    cursor_obj.execute("ALTER SESSION SET CURRENT_SCHEMA=%s" % schema_name)
    cursor_obj.close()

Параметры, специфичные для бэкенда¶

Table поддерживает опции, специфичные для конкретной базы данных. Например, MySQL имеет различные типы бэкенда таблиц, включая «MyISAM» и «InnoDB». Это можно выразить с помощью Table, используя mysql_engine:

addresses = Table(
    "engine_email_addresses",
    metadata_obj,
    Column("address_id", Integer, primary_key=True),
    Column("remote_user_id", Integer, ForeignKey(users.c.user_id)),
    Column("email_address", String(20)),
    mysql_engine="InnoDB",
)

Другие бэкенды также могут поддерживать опции на уровне таблиц - они будут описаны в отдельных разделах документации для каждого диалекта.

Колонка, таблица, API метаданных¶

attribute sqlalchemy.schema.sqlalchemy.schema.sqlalchemy.schema.BLANK_SCHEMA

Относится к SchemaConst.BLANK_SCHEMA.

attribute sqlalchemy.schema.sqlalchemy.schema.sqlalchemy.schema.RETAIN_SCHEMA

Относится к SchemaConst.RETAIN_SCHEMA

class sqlalchemy.schema.Column¶

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

Members

__eq__(), __init__(), __le__(), __lt__(), __ne__(), all_(), anon_key_label, anon_label, any_(), argument_for(), asc(), between(), bitwise_and(), bitwise_lshift(), bitwise_not(), bitwise_or(), bitwise_rshift(), bitwise_xor(), bool_op(), cast(), collate(), compare(), compile(), concat(), contains(), copy(), desc(), dialect_kwargs, dialect_options, distinct(), endswith(), expression, foreign_keys, get_children(), icontains(), iendswith(), ilike(), in_(), index, info, inherit_cache, is_(), is_distinct_from(), is_not(), is_not_distinct_from(), isnot(), isnot_distinct_from(), istartswith(), key, kwargs, label(), like(), match(), not_ilike(), not_in(), not_like(), notilike(), notin_(), notlike(), nulls_first(), nulls_last(), nullsfirst(), nullslast(), op(), operate(), params(), proxy_set, references(), regexp_match(), regexp_replace(), reverse_operate(), self_group(), shares_lineage(), startswith(), timetuple, unique, unique_params()

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

class sqlalchemy.schema.Column (sqlalchemy.sql.base.DialectKWArgs, sqlalchemy.schema.SchemaItem, sqlalchemy.sql.expression.ColumnClause)

method sqlalchemy.schema.Column.__eq__(other: Any) → ColumnOperators¶

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

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

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

method sqlalchemy.schema.Column.__init__(_Column__name_pos: Optional[Union[str, _TypeEngineArgument[_T], SchemaEventTarget]] = None, _Column__type_pos: Optional[Union[_TypeEngineArgument[_T], SchemaEventTarget]] = None, *args: SchemaEventTarget, name: Optional[str] = None, type_: Optional[_TypeEngineArgument[_T]] = None, autoincrement: _AutoIncrementType = 'auto', default: Optional[Any] = None, doc: Optional[str] = None, key: Optional[str] = None, index: Optional[bool] = None, unique: Optional[bool] = None, info: Optional[_InfoType] = None, nullable: Optional[Union[bool, Literal[SchemaConst.NULL_UNSPECIFIED]]] = SchemaConst.NULL_UNSPECIFIED, onupdate: Optional[Any] = None, primary_key: bool = False, server_default: Optional[_ServerDefaultArgument] = None, server_onupdate: Optional[FetchedValue] = None, quote: Optional[bool] = None, system: bool = False, comment: Optional[str] = None, insert_sentinel: bool = False, _omit_from_statements: bool = False, _proxies: Optional[Any] = None, **dialect_kwargs: Any)¶

Создайте новый объект Column.

Параметры:

• name – Имя столбца, представленное в базе данных. Этот аргумент может быть первым позиционным аргументом или указываться через ключевое слово. Имена, не содержащие символов верхнего регистра, рассматриваются как имена, нечувствительные к регистру, и не берутся в кавычки, если они не являются зарезервированным словом. Имена с любым количеством символов верхнего регистра будут заключены в кавычки и отправлены точно. Обратите внимание, что такое поведение применимо даже к базам данных, которые стандартизируют имена, написанные в верхнем регистре, как нечувствительные к регистру, например, Oracle. Поле имени может быть опущено во время конструирования и применено позже, в любое время до того, как колонка будет связана с Table. Это сделано для поддержки удобного использования в расширении declarative.

• type_ – Тип столбца, указываемый с помощью экземпляра, который является подклассом TypeEngine. Если для типа не требуются аргументы, можно передать и класс типа, например:: # использовать тип с аргументами Column(„data“, String(50)) # использовать без аргументов Column(„level“, Integer) Аргумент type может быть вторым позиционным аргументом или задан ключевым словом. Если type является None или опущен, то сначала по умолчанию будет использоваться специальный тип NullType. Если и когда этот Column будет сделан для ссылки на другой столбец с помощью ForeignKey и/или ForeignKeyConstraint, тип удаленного столбца будет скопирован и в этот столбец, в тот момент, когда внешний ключ будет разрешен относительно этого удаленного объекта Column.

• *args – Дополнительные позиционные аргументы включают различные производные конструкции SchemaItem, которые будут применены к столбцу в качестве опций. К ним относятся экземпляры Constraint, ForeignKey, ColumnDefault, Sequence, Computed, Identity. В некоторых случаях доступен эквивалентный аргумент ключевого слова, например server_default, default и unique.

• autoincrement – Устанавливает семантику «автоинкремента» для целочисленного столбца первичного ключа без зависимостей от внешнего ключа (более конкретное определение см. далее в этой документации). Это может повлиять на DDL, который будет выдаваться для этого столбца во время создания таблицы, а также на то, как столбец будет учитываться при компиляции и выполнении операторов INSERT. Значением по умолчанию является строка "auto", которая указывает, что одностолбцовый (т.е. некомпозитный) первичный ключ типа INTEGER, не имеющий других конструкций по умолчанию на стороне клиента или сервера, должен автоматически получать семантику автоматического инкремента. Другие значения включают True (заставляет этот столбец иметь семантику автоинкремента и для composite primary key), False (этот столбец никогда не должен иметь семантику автоинкремента) и строку "ignore_fk" (специальный случай для столбцов внешнего ключа, см. ниже). Термин «семантика автоинкремента» относится как к типу DDL, который будет создан для столбца в операторе CREATE TABLE, когда будут вызваны такие методы, как MetaData.create_all() и Table.create(), так и к тому, как столбец будет рассматриваться при компиляции и передаче в базу данных оператора INSERT: * DDL рендеринг (т.е. MetaData.create_all(), Table.create()): При использовании параметра Column, который не имеет другой генерирующей конструкции по умолчанию, связанной с ним (например, конструкции Sequence или Identity), параметр подразумевает, что ключевые слова, специфичные для базы данных, такие как PostgreSQL SERIAL, MySQL AUTO_INCREMENT или IDENTITY на SQL Server, также должны быть отрисованы. Не каждый бэкенд базы данных имеет «подразумеваемый» генератор по умолчанию; например, бэкенд Oracle всегда нуждается в явной конструкции, такой как Identity, которая должна быть включена с Column для того, чтобы DDL, визуализированный для включения автогенерирующих конструкций, также был произведен в базе данных. * Семантика INSERT (т.е. когда конструкция insert() компилируется в строку SQL и затем выполняется в базе данных с помощью Connection.execute() или эквивалента): Известно, что однострочный оператор INSERT будет автоматически создавать новое целочисленное значение первичного ключа для этого столбца, которое будет доступно после вызова оператора через атрибут CursorResult.inserted_primary_key на объекте Result. Это также относится к использованию ORM, когда ORM-сопоставленные объекты сохраняются в базе данных, указывая, что новый целочисленный первичный ключ будет доступен, чтобы стать частью identity key для этого объекта. Это поведение происходит независимо от того, какие DDL-конструкции связаны с Column и не зависит от поведения «DDL Rendering», рассмотренного в предыдущей заметке выше. Параметр может быть установлен в True, чтобы указать, что столбец, который является частью составного (т.е. многостолбцового) первичного ключа, должен иметь семантику автоинкремента, хотя обратите внимание, что только один столбец в первичном ключе может иметь такую настройку. Он также может быть установлен в True, чтобы False указать ForeignKey семантику 'ignore_fk' автоинкремента Identity для Identity столбца, Column.autoincrement у которого AUTOINCREMENT настроено Поведение автоинкрементов в SQLite значение Identity по умолчанию Sequence на стороне insert() клиента Insert.inline() или cursor.lastrowid() на стороне https://www.python.org/dev/peps/pep-0249/#lastrowid сервера, Table однако Table.implicit_returning это Sequence не так Sequence Table Table.implicit_returning SELECT scope_identity() insert() .

• default – Скаляр, Python callable или ColumnElement выражение, представляющее значение по умолчанию для этого столбца, которое будет вызвано при вставке, если этот столбец не указан в предложении VALUES вставки. Это сокращение от использования ColumnDefault в качестве позиционного аргумента; более подробно о структуре аргумента см. в этом классе. В отличие от аргумента Column.server_default, который создает генератор по умолчанию на стороне базы данных. … см. также:: Колонки INSERT/UPDATE по умолчанию

• doc – необязательная строка, которая может быть использована ORM или аналогичными средствами для документирования атрибутов на стороне Python. Этот атрибут не отображает комментарии SQL; для этого используйте параметр Column.comment.

• key – Необязательный строковый идентификатор, который будет идентифицировать данный объект Column на Table. Если указан ключ, то это единственный идентификатор, ссылающийся на Column в приложении, включая отображение атрибутов ORM; поле name используется только при визуализации SQL.

• index – Когда True, указывает, что для этого Column будет автоматически сгенерирована конструкция Index, что приведет к появлению оператора «CREATE INDEX» для Table при вызове операции создания DDL. Использование этого флага эквивалентно явному использованию конструкции Index на уровне самой конструкции Table:: Table( «some_table», metadata, Column(«x», Integer), Index(«ix_some_table_x», «x») ) Чтобы добавить флаг Index.unique к Index, установите одновременно флаги Column.unique и Column.index в True, что приведет к появлению инструкции DDL «CREATE UNIQUE INDEX» вместо «CREATE INDEX». Имя индекса генерируется с помощью флага default naming convention, который для конструкции Index имеет вид ix_<tablename>_<columnname>. Поскольку этот флаг предназначен только для удобства в общем случае добавления одностолбцового индекса с конфигурацией по умолчанию в определение таблицы, явное использование конструкции Index должно быть предпочтительным для большинства случаев использования, включая составные индексы, охватывающие более одного столбца, индексы с SQL-выражениями или упорядочиванием, опции конфигурации индекса, специфичные для бэкенда, и индексы, использующие определенное имя. … Примечание:: атрибут Column.index на Column не указывает, индексирован этот столбец или нет, только если этот флаг был явно установлен здесь. Чтобы просмотреть индексы столбца, просмотрите коллекцию Table.indexes или используйте Inspector.get_indexes(). … см. также:: Индексы Настройка соглашений об именовании ограничений Column.unique

• info – Необязательный словарь данных, который будет заполнен в атрибут SchemaItem.info этого объекта.

• nullable – Если установлено значение False, то при генерации DDL для столбца будет добавлена фраза «NOT NULL». Когда установлено True, обычно ничего не генерируется (в SQL это значение по умолчанию равно «NULL»), за исключением некоторых очень специфических граничных случаев, специфичных для бэкенда, когда «NULL» может генерироваться явно. По умолчанию True, если только Column.primary_key не является также True или столбец не указывает Identity, в этом случае по умолчанию используется False. Этот параметр используется только при выпуске операторов CREATE TABLE. … примечание:: Когда столбец указывает Identity, этот параметр вообще игнорируется компилятором DDL. База данных PostgreSQL позволяет использовать нулевой столбец идентификации, явно задав этому параметру значение True.

• onupdate – Скаляр, Python callable или ClauseElement, представляющий значение по умолчанию, которое будет применяться к столбцу в операторах UPDATE, и которое будет вызвано при обновлении, если этот столбец не присутствует в предложении SET обновления. Это сокращение от использования ColumnDefault в качестве позиционного аргумента с for_update=True. … см. также:: Колонки INSERT/UPDATE по умолчанию - полное обсуждение onupdate

• primary_key – Если True, помечает этот столбец как столбец первичного ключа. Этот флаг может быть установлен для нескольких столбцов, чтобы указать составные первичные ключи. В качестве альтернативы первичный ключ Table может быть указан через явный объект PrimaryKeyConstraint.

• server_default – Экземпляр FetchedValue, строка, Unicode или конструкция text(), представляющая значение DDL DEFAULT для столбца. Строковые типы будут передаваться как есть, окруженные одинарными кавычками:: Column(„x“, Text, server_default=»val») x TEXT DEFAULT „val“ Выражение text() будет отображено как есть, без кавычек:: Column(„y“, DateTime, server_default=text(„NOW()“)) y DATETIME DEFAULT NOW() Строки и text() будут преобразованы в объект DefaultClause при инициализации. Этот параметр также может принимать сложные комбинации контекстно допустимых выражений или конструкций SQLAlchemy:: from sqlalchemy import create_engine from sqlalchemy import Table, Column, MetaData, ARRAY, Text from sqlalchemy.dialects. postgresql import array engine = create_engine( „postgresql+psycopg2://scott:tiger@localhost/mydatabase“ ) metadata_obj = MetaData() tbl = Table( «foo», metadata_obj, Column(«bar», ARRAY(Text), server_default=array([«biz», «bang», «bash»]) ) ) metadata_obj.create_all(engine) В результате таблица будет создана с помощью следующего SQL:: CREATE TABLE foo ( bar TEXT[] DEFAULT ARRAY[„biz“, „bang“, „bash“] ) Используйте FetchedValue, чтобы указать, что уже существующий столбец будет генерировать значение по умолчанию на стороне базы данных, которое будет доступно SQLAlchemy для пост-выборки после вставки. Эта конструкция не определяет DDL, и реализация остается на усмотрение базы данных, например, через триггер. … см. также:: Выражения по умолчанию DDL-Explicit, вызываемые сервером - полное обсуждение параметров по умолчанию на стороне сервера

• server_onupdate – Экземпляр FetchedValue, представляющий функцию генерации по умолчанию на стороне базы данных, например, триггер. Это указывает SQLAlchemy, что новое сгенерированное значение будет доступно после обновления. Эта конструкция фактически не реализует какую-либо функцию генерации в базе данных, которая должна быть указана отдельно. … предупреждение:: Эта директива не в настоящее время производит предложение MySQL «ON UPDATE CURRENT_TIMESTAMP()». Смотрите Рендеринг ON UPDATE CURRENT TIMESTAMP для MySQL / MariaDB’s explicit_defaults_for_timestamp для получения информации о том, как производить это предложение. … см. также:: Маркировка неявно генерируемых значений, временных меток и триггерных столбцов

• quote – Включить или выключить принудительное цитирование имени этой колонки, соответствующее True или False. Если оставить значение по умолчанию None, то идентификатор колонки будет заключен в кавычки в соответствии с тем, является ли имя чувствительным к регистру (идентификаторы, содержащие хотя бы один символ верхнего регистра, рассматриваются как чувствительные к регистру), или если это зарезервированное слово. Этот флаг нужен только для принудительного цитирования зарезервированного слова, которое не известно диалекту SQLAlchemy.

• unique – Когда True, а параметр Column.index оставлен в значении по умолчанию False, это означает, что для данного Column будет автоматически сгенерирована конструкция UniqueConstraint, которая приведет к включению условия «UNIQUE CONSTRAINT», ссылающегося на этот столбец, в оператор CREATE TABLE, когда будет вызвана операция DDL create для объекта Table. Когда этот флаг установлен True, а параметр Column.index одновременно установлен в True, то вместо этого генерируется конструкция Index, которая включает параметр Index.unique, установленный в True. Дополнительные подробности см. в документации для Column.index. Использование этого флага эквивалентно явному использованию конструкции UniqueConstraint на уровне самой конструкции Table:: Table(«some_table», metadata, Column(«x», Integer), UniqueConstraint(«x») ) Параметр UniqueConstraint.name объекта уникального ограничения оставлен в значении по умолчанию None; в отсутствие naming convention для вложенного MetaData, конструкция UNIQUE CONSTRAINT будет выдана как безымянная, что обычно вызывает соглашение об именовании, специфичное для базы данных. Поскольку этот флаг предназначен только для удобства в распространенном случае добавления уникального ограничения в один столбец, сконфигурированного по умолчанию, в определение таблицы, явное использование конструкции UniqueConstraint должно быть предпочтительным для большинства случаев использования, включая составные ограничения, охватывающие более одного столбца, опции конфигурации индекса, специфичные для бэкенда, и ограничения, использующие конкретное имя. … Примечание:: атрибут Column.unique на Column не указывает, имеет ли этот столбец уникальное ограничение или нет, только если этот флаг был явно установлен здесь. Для просмотра индексов и уникальных ограничений, которые могут включать этот столбец, просмотрите коллекции Table.indexes и/или Table.constraints или используйте Inspector.get_indexes() и/или Inspector.get_unique_constraints() … seealso:: Ограничение UNIQUE Настройка соглашений об именовании ограничений Column.index

• system – Когда True, указывает, что это «системный» столбец, то есть столбец, который автоматически предоставляется базой данных, и не должен включаться в список столбцов для оператора CREATE TABLE. Для более сложных сценариев, когда столбцы должны условно отображаться по-разному на разных бэкендах, рассмотрим пользовательские правила компиляции для CreateColumn.

• comment – Необязательная строка, которая будет отображать SQL-комментарий при создании таблицы. … versionadded:: 1.2 Добавлен параметр Column.comment к Column.

• insert_sentinel – Помечает эту Column как insert sentinel, используемую для оптимизации работы функции insertmanyvalues для таблиц, которые иначе не имеют соответствующих конфигураций первичного ключа. … версия добавлена:: 2.0.10 .. seealso:: insert_sentinel() - универсальный помощник для объявления направляющих столбцов Поведение «Вставка многих значений» для операторов INSERT Настройка столбцов часовых.

method sqlalchemy.schema.Column.__le__(other: Any) → ColumnOperators¶

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

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

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

method sqlalchemy.schema.Column.__lt__(other: Any) → ColumnOperators¶

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

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

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

method sqlalchemy.schema.Column.__ne__(other: Any) → ColumnOperators¶

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

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

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

method sqlalchemy.schema.Column.all_() → ColumnOperators¶

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

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

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

Примечание

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

attribute sqlalchemy.schema.Column.anon_key_label¶

наследуется от ColumnElement.anon_key_label атрибута ColumnElement

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

attribute sqlalchemy.schema.Column.anon_label¶

наследуется от ColumnElement.anon_label атрибута ColumnElement

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

method sqlalchemy.schema.Column.any_() → ColumnOperators¶

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

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

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

Примечание

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

classmethod sqlalchemy.schema.Column.argument_for(dialect_name, argument_name, default)¶

наследуется от DialectKWArgs.argument_for() метода DialectKWArgs

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

Например:

Index.argument_for("mydialect", "length", None)

some_index = Index('a', 'b', mydialect_length=5)

Метод DialectKWArgs.argument_for() является способом добавления дополнительных аргументов в словарь DefaultDialect.construct_arguments. Этот словарь содержит список имен аргументов, принимаемых различными конструкциями уровня схемы от имени диалекта.

Новые диалекты, как правило, должны определять этот словарь сразу как член данных класса диалекта. Случаи добавления имен аргументов ad-hoc обычно используются для кода конечного пользователя, который также использует пользовательскую схему компиляции, потребляющую дополнительные аргументы.

Параметры:

• dialect_name – имя диалекта. Диалект должен быть локализуемым, в противном случае выдается сообщение NoSuchModuleError. Диалект также должен включать существующую коллекцию DefaultDialect.construct_arguments, указывающую на то, что он участвует в системе проверки ключевых слов-аргументов и умолчаний, иначе будет выдано ArgumentError. Если диалект не включает эту коллекцию, то любой аргумент ключевого слова может быть указан от имени уже этого диалекта. Все диалекты, упакованные в SQLAlchemy, включают эту коллекцию, однако для диалектов сторонних производителей поддержка может отличаться.

• argument_name – имя параметра.

• default – значение параметра по умолчанию.

method sqlalchemy.schema.Column.asc() → ColumnOperators¶

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

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

method sqlalchemy.schema.Column.between(cleft: Any, cright: Any, symmetric: bool = False) → ColumnOperators¶

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

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

method sqlalchemy.schema.Column.bitwise_and(other: Any) → ColumnOperators¶

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

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

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

См.также

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

method sqlalchemy.schema.Column.bitwise_lshift(other: Any) → ColumnOperators¶

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

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

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

См.также

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

method sqlalchemy.schema.Column.bitwise_not() → ColumnOperators¶

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

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

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

См.также

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

method sqlalchemy.schema.Column.bitwise_or(other: Any) → ColumnOperators¶

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

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

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

См.также

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

method sqlalchemy.schema.Column.bitwise_rshift(other: Any) → ColumnOperators¶

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

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

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

См.также

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

method sqlalchemy.schema.Column.bitwise_xor(other: Any) → ColumnOperators¶

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

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

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

См.также

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

method sqlalchemy.schema.Column.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.

См.также

Operators.op()

method sqlalchemy.schema.Column.cast(type_: _TypeEngineArgument[_OPT]) → Cast[_OPT]¶

наследуется от ColumnElement.cast() метода ColumnElement

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

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

См.также

Приведение данных и принуждение к типу

cast()

type_coerce()

method sqlalchemy.schema.Column.collate(collation: str) → ColumnOperators¶

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

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

См.также

collate()

method sqlalchemy.schema.Column.compare(other: ClauseElement, **kw: Any) → bool¶

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

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

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

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

method sqlalchemy.schema.Column.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}))

См.также

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

method sqlalchemy.schema.Column.concat(other: Any) → ColumnOperators¶

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

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

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

method sqlalchemy.schema.Column.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" перед передачей в базу данных.

См.также

ColumnOperators.startswith()

ColumnOperators.endswith()

ColumnOperators.like()

method sqlalchemy.schema.Column.copy(**kw: Any) → Column[Any]¶

Не рекомендуется, начиная с версии 1.4: Метод Column.copy() является устаревшим и будет удален в одном из будущих выпусков.

method sqlalchemy.schema.Column.desc() → ColumnOperators¶

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

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

attribute sqlalchemy.schema.Column.dialect_kwargs¶

наследуется от DialectKWArgs.dialect_kwargs атрибута DialectKWArgs

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

Аргументы представлены здесь в их оригинальном формате <dialect>_<kwarg>. Включены только те аргументы, которые действительно были переданы; в отличие от коллекции DialectKWArgs.dialect_options, которая содержит все опции, известные этому диалекту, включая значения по умолчанию.

Коллекция также доступна для записи; ключи принимаются в форме <dialect>_<kwarg>, где значение будет собрано в список опций.

См.также

DialectKWArgs.dialect_options - форма вложенного словаря

attribute sqlalchemy.schema.Column.dialect_options¶

наследуется от DialectKWArgs.dialect_options атрибута DialectKWArgs

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

Это двухуровневый вложенный реестр, ключами которого являются <dialect_name> и <argument_name>. Например, аргумент postgresql_where можно найти как:

arg = my_object.dialect_options['postgresql']['where']

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

См.также

DialectKWArgs.dialect_kwargs - плоская словарная форма

method sqlalchemy.schema.Column.distinct() → ColumnOperators¶

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

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

method sqlalchemy.schema.Column.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" перед передачей в базу данных.

См.также

ColumnOperators.startswith()

ColumnOperators.contains()

ColumnOperators.like()

attribute sqlalchemy.schema.Column.expression¶

наследуется от ColumnElement.expression атрибута ColumnElement

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

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

attribute sqlalchemy.schema.Column.foreign_keys: Set[ForeignKey] = frozenset({})¶

наследуется от ColumnElement.foreign_keys атрибута ColumnElement

Коллекция всех объектов маркеров ForeignKey, связанных с данным Column.

Каждый объект является членом ForeignKeyConstraint.

См.также

Table.foreign_keys

method sqlalchemy.schema.Column.get_children(*, column_tables=False, **kw)¶

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

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

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

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

method sqlalchemy.schema.Column.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" перед передачей в базу данных.

См.также

ColumnOperators.contains()

method sqlalchemy.schema.Column.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" перед передачей в базу данных.

См.также

ColumnOperators.endswith()

method sqlalchemy.schema.Column.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.like()

method sqlalchemy.schema.Column.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.schema.Column.index: Optional[bool]¶

Значение параметра Column.index.

Не указывает, действительно ли этот Column проиндексирован или нет; используйте Table.indexes.

См.также

Table.indexes

attribute sqlalchemy.schema.Column.info¶

наследуется от SchemaItem.info атрибута SchemaItem

Информационный словарь, связанный с объектом, позволяющий связать пользовательские данные с этим SchemaItem.

Словарь автоматически создается при первом обращении к нему. Он также может быть указан в конструкторе некоторых объектов, таких как Table и Column.

attribute sqlalchemy.schema.Column.inherit_cache: Optional[bool] = True¶

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

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

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

См.также

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

method sqlalchemy.schema.Column.is_(other: Any) → ColumnOperators¶

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

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

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

См.также

ColumnOperators.is_not()

method sqlalchemy.schema.Column.is_distinct_from(other: Any) → ColumnOperators¶

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

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

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

method sqlalchemy.schema.Column.is_not(other: Any) → ColumnOperators¶

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

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

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

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

См.также

ColumnOperators.is_()

method sqlalchemy.schema.Column.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() в предыдущих выпусках. Предыдущее название остается доступным для обратной совместимости.

method sqlalchemy.schema.Column.isnot(other: Any) → ColumnOperators¶

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

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

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

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

См.также

ColumnOperators.is_()

method sqlalchemy.schema.Column.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».

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

method sqlalchemy.schema.Column.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" перед передачей в базу данных.

См.также

ColumnOperators.startswith()

attribute sqlalchemy.schema.Column.key: str = None¶

наследуется от ColumnElement.key атрибута ColumnElement

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

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

attribute sqlalchemy.schema.Column.kwargs¶

наследуется от DialectKWArgs.kwargs атрибута DialectKWArgs

Синоним для DialectKWArgs.dialect_kwargs.

method sqlalchemy.schema.Column.label(name: Optional[str]) → Label[_T]¶

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

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

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

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

method sqlalchemy.schema.Column.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=»/»)

См.также

ColumnOperators.ilike()

method sqlalchemy.schema.Column.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.

method sqlalchemy.schema.Column.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() в предыдущих выпусках. Предыдущее название остается доступным для обратной совместимости.

См.также

ColumnOperators.ilike()

method sqlalchemy.schema.Column.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.

См.также

ColumnOperators.in_()

method sqlalchemy.schema.Column.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() в предыдущих выпусках. Предыдущее название остается доступным для обратной совместимости.

См.также

ColumnOperators.like()

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

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

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

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

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

См.также

ColumnOperators.ilike()

method sqlalchemy.schema.Column.notin_(other: Any) → ColumnOperators¶

наследуется от ColumnOperators.notin_() метода 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.

См.также

ColumnOperators.in_()

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

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

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

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

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

См.также

ColumnOperators.like()

method sqlalchemy.schema.Column.nulls_first() → ColumnOperators¶

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

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

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

method sqlalchemy.schema.Column.nulls_last() → ColumnOperators¶

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

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

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

method sqlalchemy.schema.Column.nullsfirst() → ColumnOperators¶

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

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

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

method sqlalchemy.schema.Column.nullslast() → ColumnOperators¶

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

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

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

method sqlalchemy.schema.Column.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

См.также

Operators.bool_op()

Переопределение и создание новых операторов

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

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

наследуется от ColumnElement.operate() метода ColumnElement

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

Это самый низкий уровень работы, по умолчанию поднимает 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.schema.Column.params(*optionaldict, **kwargs)¶

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

Возвращает копию с замененными элементами 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.schema.Column.proxy_set: util.generic_fn_descriptor[FrozenSet[Any]]¶

наследуется от ColumnElement.proxy_set атрибута ColumnElement

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

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

method sqlalchemy.schema.Column.references(column: Column[Any]) → bool¶

Возвращает True, если этот Column ссылается на данный столбец через внешний ключ.

method sqlalchemy.schema.Column.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.schema.Column.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(..)',
        'X
Y',
        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.schema.Column.reverse_operate(op: OperatorType, other: Any, **kwargs: Any) → ColumnElement[Any]¶

наследуется от ColumnElement.reverse_operate() метода ColumnElement

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

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

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

наследуется от ColumnElement.self_group() метода ColumnElement

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

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

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

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

method sqlalchemy.schema.Column.shares_lineage(othercolumn: ColumnElement[Any]) → bool¶

наследуется от ColumnElement.shares_lineage() метода ColumnElement

Возвращает True, если данный ColumnElement имеет общего предка с данным ColumnElement.

method sqlalchemy.schema.Column.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" перед передачей в базу данных.

См.также

ColumnOperators.endswith()

ColumnOperators.contains()

ColumnOperators.like()

attribute sqlalchemy.schema.Column.timetuple: Literal[None] = None¶

наследуется от ColumnOperators.timetuple атрибута ColumnOperators

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

attribute sqlalchemy.schema.Column.unique: Optional[bool]¶

Значение параметра Column.unique.

Не указывает, действительно ли данный Column подвержен уникальному ограничению или нет; используйте Table.indexes и Table.constraints.

См.также

Table.indexes

Table.constraints.

method sqlalchemy.schema.Column.unique_params(*optionaldict, **kwargs)¶

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

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

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