Настройка DDL¶

Пользовательский DDL¶

Пользовательские DDL-фразы легче всего получить с помощью конструкции DDL. Эта конструкция работает как все остальные элементы DDL, за исключением того, что она принимает строку, которая является текстом, который должен быть выдан:

event.listen(
    metadata,
    "after_create",
    DDL(
        "ALTER TABLE users ADD CONSTRAINT "
        "cst_user_name_length "
        " CHECK (length(user_name) >= 8)"
    ),
)

Более полным методом создания библиотек DDL-конструкций является использование пользовательской компиляции - подробности см. в Пользовательские SQL-конструкции и расширение компиляции.

Управление последовательностями DDL¶

Конструкция DDL, представленная ранее, также имеет возможность быть вызванной условно на основе проверки базы данных. Эта возможность доступна с помощью метода ExecutableDDLElement.execute_if(). Например, если бы мы хотели создать триггер, но только на бэкенде PostgreSQL, мы могли бы вызвать его следующим образом:

mytable = Table(
    "mytable",
    metadata,
    Column("id", Integer, primary_key=True),
    Column("data", String(50)),
)

func = DDL(
    "CREATE FUNCTION my_func() "
    "RETURNS TRIGGER AS $$ "
    "BEGIN "
    "NEW.data := 'ins'; "
    "RETURN NEW; "
    "END; $$ LANGUAGE PLPGSQL"
)

trigger = DDL(
    "CREATE TRIGGER dt_ins BEFORE INSERT ON mytable "
    "FOR EACH ROW EXECUTE PROCEDURE my_func();"
)

event.listen(mytable, "after_create", func.execute_if(dialect="postgresql"))

event.listen(mytable, "after_create", trigger.execute_if(dialect="postgresql"))

Ключевое слово ExecutableDDLElement.execute_if.dialect также принимает кортеж имен строковых диалектов:

event.listen(
    mytable, "after_create", trigger.execute_if(dialect=("postgresql", "mysql"))
)
event.listen(
    mytable, "before_drop", trigger.execute_if(dialect=("postgresql", "mysql"))
)

Метод ExecutableDDLElement.execute_if() также может работать с вызываемой функцией, которая будет получать используемое соединение с базой данных. В примере ниже мы используем этот метод для условного создания ограничения CHECK, сначала просматривая каталоги PostgreSQL на предмет его существования:

def should_create(ddl, target, connection, **kw):
    row = connection.execute(
        "select conname from pg_constraint where conname='%s'" % ddl.element.name
    ).scalar()
    return not bool(row)


def should_drop(ddl, target, connection, **kw):
    return not should_create(ddl, target, connection, **kw)


event.listen(
    users,
    "after_create",
    DDL(
        "ALTER TABLE users ADD CONSTRAINT "
        "cst_user_name_length CHECK (length(user_name) >= 8)"
    ).execute_if(callable_=should_create),
)
event.listen(
    users,
    "before_drop",
    DDL("ALTER TABLE users DROP CONSTRAINT cst_user_name_length").execute_if(
        callable_=should_drop
    ),
)

users.create(engine)
{execsql}CREATE TABLE users (
    user_id SERIAL NOT NULL,
    user_name VARCHAR(40) NOT NULL,
    PRIMARY KEY (user_id)
)

SELECT conname FROM pg_constraint WHERE conname='cst_user_name_length'
ALTER TABLE users ADD CONSTRAINT cst_user_name_length  CHECK (length(user_name) >= 8)
{stop}

users.drop(engine)
{execsql}SELECT conname FROM pg_constraint WHERE conname='cst_user_name_length'
ALTER TABLE users DROP CONSTRAINT cst_user_name_length
DROP TABLE users{stop}

Использование встроенных классов DDLElement¶

Пакет sqlalchemy.schema содержит конструкции SQL-выражений, которые предоставляют DDL-выражения, все они расширяются от общей базы ExecutableDDLElement. Например, для создания выражения CREATE TABLE можно использовать конструкцию CreateTable:

from sqlalchemy.schema import CreateTable

with engine.connect() as conn:
    conn.execute(CreateTable(mytable))
{execsql}CREATE TABLE mytable (
    col1 INTEGER,
    col2 INTEGER,
    col3 INTEGER,
    col4 INTEGER,
    col5 INTEGER,
    col6 INTEGER
){stop}

Выше, конструкция CreateTable работает как любая другая конструкция выражения (такая как select(), table.insert() и т.д.). Все конструкции SQLAlchemy, ориентированные на DDL, являются подклассами базового класса ExecutableDDLElement; это основа всех объектов, соответствующих CREATE и DROP, а также ALTER, не только в SQLAlchemy, но и в Alembic Migrations. Полный справочник доступных конструкций находится в API Конструкции выражений DDL.

Определяемые пользователем конструкции DDL также могут быть созданы как подклассы самого ExecutableDDLElement. В документации к Пользовательские SQL-конструкции и расширение компиляции есть несколько примеров этого.

Управление генерацией ограничений и индексов в DDL¶

Хотя ранее упомянутый метод ExecutableDDLElement.execute_if() полезен для пользовательских классов DDL, которые должны вызываться условно, также часто возникает необходимость в том, чтобы элементы, которые обычно связаны с определенным Table, а именно ограничения и индексы, также подчинялись «условным» правилам, например, индекс, включающий функции, характерные для определенного бэкенда, такого как PostgreSQL или SQL Server. Для этого случая методы Constraint.ddl_if() и Index.ddl_if() могут быть использованы против таких конструкций, как CheckConstraint, UniqueConstraint и Index, принимая те же аргументы, что и метод ExecutableDDLElement.execute_if(), чтобы контролировать, будет ли их DDL выдаваться в терминах их родительского объекта Table. Эти методы можно использовать в строке при создании определения для Table (или аналогично, при использовании коллекции __table_args__ в декларативном отображении ORM), например:

from sqlalchemy import CheckConstraint, Index
from sqlalchemy import MetaData, Table, Column
from sqlalchemy import Integer, String

meta = MetaData()

my_table = Table(
    "my_table",
    meta,
    Column("id", Integer, primary_key=True),
    Column("num", Integer),
    Column("data", String),
    Index("my_pg_index", "data").ddl_if(dialect="postgresql"),
    CheckConstraint("num > 5").ddl_if(dialect="postgresql"),
)

В приведенном выше примере конструкция Table относится и к конструкции Index, и к конструкции CheckConstraint, обе они указывают на .ddl_if(dialect="postgresql"), что говорит о том, что эти элементы будут включены в последовательность CREATE TABLE только в диалекте PostgreSQL. Если мы выполним meta.create_all(), например, на диалекте SQLite, ни одна из конструкций не будет включена:

>>> from sqlalchemy import create_engine
>>> sqlite_engine = create_engine("sqlite+pysqlite://", echo=True)
>>> meta.create_all(sqlite_engine)
{execsql}BEGIN (implicit)
PRAGMA main.table_info("my_table")
[raw sql] ()
PRAGMA temp.table_info("my_table")
[raw sql] ()

CREATE TABLE my_table (
    id INTEGER NOT NULL,
    num INTEGER,
    data VARCHAR,
    PRIMARY KEY (id)
)

Однако если мы выполним те же команды в базе данных PostgreSQL, мы увидим встроенный DDL для ограничения CHECK, а также отдельный оператор CREATE для индекса:

>>> from sqlalchemy import create_engine
>>> postgresql_engine = create_engine(
...     "postgresql+psycopg2://scott:tiger@localhost/test", echo=True
... )
>>> meta.create_all(postgresql_engine)
{execsql}BEGIN (implicit)
select relname from pg_class c join pg_namespace n on n.oid=c.relnamespace where pg_catalog.pg_table_is_visible(c.oid) and relname=%(name)s
[generated in 0.00009s] {'name': 'my_table'}

CREATE TABLE my_table (
    id SERIAL NOT NULL,
    num INTEGER,
    data VARCHAR,
    PRIMARY KEY (id),
    CHECK (num > 5)
)
[no key 0.00007s] {}
CREATE INDEX my_pg_index ON my_table (data)
[no key 0.00013s] {}
COMMIT

Методы Constraint.ddl_if() и Index.ddl_if() создают крючок событий, который может быть использован не только во время выполнения DDL, как это происходит с ExecutableDDLElement.execute_if(), но и на этапе компиляции SQL объекта CreateTable, который отвечает за отображение CHECK (num > 5) DDL в строке оператора CREATE TABLE. Как таковой, крючок события, получаемый параметром ddl_if.callable_(), имеет более богатый набор аргументов, включая переданный аргумент ключевого слова dialect, а также экземпляр DDLCompiler через аргумент ключевого слова compiler для части последовательности «inline rendering». Аргумент bind нет, когда событие запускается внутри последовательности DDLCompiler, поэтому современному крючку событий, желающему проверить информацию о версиях базы данных, лучше всего использовать данный объект Dialect, например, для проверки версионности PostgreSQL:

def only_pg_14(ddl_element, target, bind, dialect, **kw):
    return dialect.name == "postgresql" and dialect.server_version_info >= (14,)


my_table = Table(
    "my_table",
    meta,
    Column("id", Integer, primary_key=True),
    Column("num", Integer),
    Column("data", String),
    Index("my_pg_index", "data").ddl_if(callable_=only_pg_14),
)

API Конструкции выражений DDL¶

function sqlalchemy.schema.sort_tables(tables: Iterable[TableClause], skip_fn: Optional[Callable[[ForeignKeyConstraint], bool]] = None, extra_dependencies: Optional[typing_Sequence[Tuple[TableClause, TableClause]]] = None) → List[Table]¶

Сортировка коллекции объектов Table на основе зависимости.

Это упорядоченная по зависимостям сортировка, которая будет выдавать объекты Table таким образом, что они будут следовать за своими зависимыми объектами Table. Таблицы зависят друг от друга на основании наличия объектов ForeignKeyConstraint, а также явных зависимостей, добавленных Table.add_is_dependent_on().

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

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

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

Изменено в версии 1.3.17: - a warning is emitted when sort_tables() cannot perform a proper sort due to cyclical dependencies. This will be an exception in a future release. Additionally, the sort will continue to return other tables not involved in the cycle in dependency order which was not the case previously.

Параметры:

• tables – последовательность объектов Table.

• skip_fn – необязательный вызываемый параметр, которому будет передан объект ForeignKeyConstraint; если он возвращает True, то данное ограничение не будет считаться зависимостью. Обратите внимание, что это отличается от того же параметра в sort_tables_and_constraints(), которому вместо этого передается принадлежащий объект ForeignKeyConstraint.

• extra_dependencies – последовательность из 2-кортежей таблиц, которые также будут считаться зависимыми друг от друга.

См.также

sort_tables_and_constraints()

MetaData.sorted_tables - использует эту функцию для сортировки

function sqlalchemy.schema.sort_tables_and_constraints(tables, filter_fn=None, extra_dependencies=None, _warn_for_cycles=False)¶

Сортировка коллекции объектов Table / ForeignKeyConstraint.

Это упорядоченная по зависимостям сортировка, которая выдает кортежи (Table, [ForeignKeyConstraint, ...]) таким образом, что каждый Table следует за своими зависимыми Table объектами. Оставшиеся объекты ForeignKeyConstraint, которые являются отдельными из-за правил зависимости, не удовлетворяемых сортировкой, выдаются после этого как (None, [ForeignKeyConstraint ...]).

Таблицы зависят друг от друга на основании наличия объектов ForeignKeyConstraint, явных зависимостей, добавленных Table.add_is_dependent_on(), а также зависимостей, указанных здесь с помощью параметров sort_tables_and_constraints.skip_fn и/или sort_tables_and_constraints.extra_dependencies.

Параметры:

• tables – последовательность объектов Table.

• filter_fn – необязательный вызываемый элемент, которому передается объект ForeignKeyConstraint, и возвращает значение, основанное на том, должно ли это ограничение быть определенно включено или исключено как встроенное ограничение, или ни то, ни другое. Если возвращается False, то ограничение будет определенно включено как зависимость, которая не может быть подвергнута ALTER; если True, то оно только будет включено как результат ALTER в конце. Возврат None означает, что ограничение включается в результат на основе таблицы, если оно не обнаружено как часть цикла зависимостей.

• extra_dependencies – последовательность из 2-кортежей таблиц, которые также будут считаться зависимыми друг от друга.

См.также

sort_tables()

class sqlalchemy.schema.BaseDDLElement¶

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

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

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

класс sqlalchemy.schema.BaseDDLElement (sqlalchemy.sql.expression.ClauseElement)

class sqlalchemy.schema.ExecutableDDLElement¶

Базовый класс для автономных исполняемых конструкций выражений DDL.

Этот класс является базой для класса общего назначения DDL, а также для различных конструкций создания/удаления клаузул, таких как CreateTable, DropTable, AddConstraint и т.д.

Изменено в версии 2.0: ExecutableDDLElement переименован из DDLElement, который все еще существует для обратной совместимости.

ExecutableDDLElement тесно интегрируется с событиями SQLAlchemy, представленными в События. Экземпляр одного из них сам является событием с возможностью вызова:

event.listen(
    users,
    'after_create',
    AddConstraint(constraint).execute_if(dialect='postgresql')
)

См.также

DDL

DDLEvents

События

Управление последовательностями DDL

Members

__call__(), against(), execute_if()

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

class sqlalchemy.schema.ExecutableDDLElement (sqlalchemy.sql.roles.DDLRole, sqlalchemy.sql.expression.Executable, sqlalchemy.schema.BaseDDLElement)

method sqlalchemy.schema.ExecutableDDLElement.__call__(target, bind, **kw)¶

Выполните DDL в качестве слушателя ddl_listener.

method sqlalchemy.schema.ExecutableDDLElement.against(target: SchemaItem) → Self¶

Возвращает копию данного ExecutableDDLElement, которая будет включать заданную цель.

По сути, это применяет заданный элемент к атрибуту .target возвращаемого объекта ExecutableDDLElement. Эта цель затем используется обработчиками событий и процедурами компиляции для предоставления таких услуг, как токенизация строки DDL в терминах конкретного Table.

Когда объект ExecutableDDLElement создается как обработчик событий DDLEvents.before_create() или DDLEvents.after_create(), и событие происходит для определенной цели, такой как Constraint или Table, эта цель создается с копией объекта ExecutableDDLElement с помощью этого метода, который затем переходит к методу ExecutableDDLElement.execute() для вызова фактической инструкции DDL.

Параметры:

target – SchemaItem, который будет объектом операции DDL.

Результат:

копия данного ExecutableDDLElement с атрибутом .target, присвоенным данному SchemaItem.

См.также

DDL - использует токенизацию против «цели» при обработке строки DDL.

method sqlalchemy.schema.ExecutableDDLElement.execute_if(dialect: Optional[str] = None, callable_: Optional[DDLIfCallable] = None, state: Optional[Any] = None) → Self¶

Возвращает вызываемый объект, который будет выполнять этот ExecutableDDLElement условно в обработчике события.

Используется для создания обертки для прослушивания событий:

event.listen(
            metadata,
            'before_create',
            DDL("my_ddl").execute_if(dialect='postgresql')
        )

Параметры:

• dialect – Может быть строкой или кортежем строк. Если строка, то она будет сравниваться с именем исполняющего диалекта базы данных:: DDL(„something“).execute_if(dialect=“postgresql“) Если кортеж, задается несколько имен диалектов:: DDL(„something“).execute_if(dialect=(„postgresql“, „mysql“))

• callable_ – Вызываемый элемент, который будет вызван с тремя позиционными аргументами, а также необязательными аргументами в виде ключевых слов: :ddl: Этот элемент DDL. :target: Объект Table или MetaData, который является целью этого события. Может быть None, если DDL выполняется явно. :bind: Конструкция Connection, используемая для выполнения DDL. Может быть None, если эта конструкция создается inline внутри таблицы, в этом случае compiler будет присутствовать. :tables: Необязательный аргумент с ключевым словом - список объектов Table, которые должны быть созданы/удалены в рамках вызова метода MetaData.create_all() или drop_all(). :dialect: аргумент с ключевым словом, но всегда присутствует - Dialect, участвующий в операции. :compiler: аргумент с ключевым словом. Будет None для вызова DDL на уровне движка, но будет ссылаться на DDLCompiler, если этот DDL-элемент создается inline в таблице. :state: Необязательный аргумент с ключевым словом - будет аргументом state, переданным этой функции. :checkfirst: Аргумент с ключевым словом, будет True, если во время вызова create(), create_all(), drop(), drop_all() был установлен флаг „checkfirst“. Если вызываемая переменная возвращает значение True, DDL-оператор будет выполнен.

• state – любое значение, которое будет передано вызываемой_ в качестве аргумента ключевого слова state.

См.также

SchemaItem.ddl_if()

DDLEvents

События

class sqlalchemy.schema.DDL¶

Буквальный оператор DDL.

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

Примеры:

from sqlalchemy import event, DDL

tbl = Table('users', metadata, Column('uid', Integer))
event.listen(tbl, 'before_create', DDL('DROP TRIGGER users_trigger'))

spow = DDL('ALTER TABLE %(table)s SET secretpowers TRUE')
event.listen(tbl, 'after_create', spow.execute_if(dialect='somedb'))

drop_spow = DDL('ALTER TABLE users SET secretpowers FALSE')
connection.execute(drop_spow)

При работе с событиями таблицы доступны следующие замены строк statement:

%(table)s  - the Table name, with any required quoting applied
%(schema)s - the schema name, with any required quoting applied
%(fullname)s - the Table name including schema, quoted if needed

«Контекст» DDL, если таковой имеется, будет комбинироваться со стандартными подстановками, указанными выше. Ключи, присутствующие в контексте, отменяют стандартные замены.

Members

__init__()

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

класс sqlalchemy.schema.DDL (sqlalchemy.schema.ExecutableDDLElement)

method sqlalchemy.schema.DDL.__init__(statement, context=None)¶

Создайте оператор DDL.

Параметры:

• statement – Строка или строка юникода для выполнения. Высказывания будут обработаны с помощью оператора форматирования строк Python с использованием фиксированного набора строковых подстановок, а также дополнительных подстановок, предоставляемых необязательным параметром DDL.context. Буква «%» в операторе должна быть экранирована как «%%». Параметры связывания SQL недоступны в операторах DDL.

• context – Необязательный словарь, по умолчанию None. Эти значения будут доступны для использования в строковых подстановках в операторе DDL.

См.также

DDLEvents

События

class sqlalchemy.schema._CreateDropBase¶

Базовый класс для DDL-конструкций, представляющих CREATE и DROP или их эквиваленты.

Общей темой _CreateDropBase является единственный атрибут element, который ссылается на элемент, который должен быть создан или сброшен.

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

класс sqlalchemy.schema._CreateDropBase (sqlalchemy.schema.ExecutableDDLElement)

class sqlalchemy.schema.CreateTable¶

Представьте оператор CREATE TABLE.

Members

__init__()

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

класс sqlalchemy.schema.CreateTable (sqlalchemy.schema._CreateBase)

method sqlalchemy.schema.CreateTable.__init__(element: Table, include_foreign_key_constraints: Optional[typing_Sequence[ForeignKeyConstraint]] = None, if_not_exists: bool = False)¶

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

Параметры:

• element – Table, который является объектом CREATE

• on – См. описание для „on“ в DDL.

• include_foreign_key_constraints – необязательная последовательность объектов ForeignKeyConstraint, которые будут включены в конструкцию CREATE; если опущена, включаются все ограничения внешнего ключа, для которых не указано use_alter=True.

• if_not_exists – если True, то к конструкции будет применен оператор IF NOT EXISTS. … версия добавлена:: 1.4.0b2

class sqlalchemy.schema.DropTable¶

Представьте оператор DROP TABLE.

Members

__init__()

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

класс sqlalchemy.schema.DropTable (sqlalchemy.schema._DropBase)

method sqlalchemy.schema.DropTable.__init__(element: Table, if_exists: bool = False)¶

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

Параметры:

• element – a Table, который является объектом DROP.

• on – См. описание для „on“ в DDL.

• if_exists – если True, к конструкции будет применен оператор IF EXISTS. … версия добавлена:: 1.4.0b2

class sqlalchemy.schema.CreateColumn¶

Представьте Column как отображается в операторе CREATE TABLE с помощью конструкции CreateTable.

Это предусмотрено для поддержки пользовательских столбцов DDL при генерации операторов CREATE TABLE, используя расширение компилятора, документированное в Пользовательские SQL-конструкции и расширение компиляции для расширения CreateColumn.

Типичная интеграция заключается в изучении входящего объекта Column и перенаправлении компиляции при обнаружении определенного флага или условия:

from sqlalchemy import schema
from sqlalchemy.ext.compiler import compiles

@compiles(schema.CreateColumn)
def compile(element, compiler, **kw):
    column = element.element

    if "special" not in column.info:
        return compiler.visit_create_column(element, **kw)

    text = "%s SPECIAL DIRECTIVE %s" % (
            column.name,
            compiler.type_compiler.process(column.type)
        )
    default = compiler.get_column_default_string(column)
    if default is not None:
        text += " DEFAULT " + default

    if not column.nullable:
        text += " NOT NULL"

    if column.constraints:
        text += " ".join(
                    compiler.process(const)
                    for const in column.constraints)
    return text

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

from sqlalchemy import Table, Metadata, Column, Integer, String
from sqlalchemy import schema

metadata = MetaData()

table = Table('mytable', MetaData(),
        Column('x', Integer, info={"special":True}, primary_key=True),
        Column('y', String(50)),
        Column('z', String(20), info={"special":True})
    )

metadata.create_all(conn)

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

CREATE TABLE mytable (
        x SPECIAL DIRECTIVE INTEGER NOT NULL,
        y VARCHAR(50),
        z SPECIAL DIRECTIVE VARCHAR(20),
    PRIMARY KEY (x)
)

Конструкцию CreateColumn можно также использовать для пропуска определенных столбцов при создании CREATE TABLE. Это достигается путем создания правила компиляции, которое условно возвращает None. По сути, таким образом достигается тот же эффект, что и при использовании аргумента system=True в Column, который помечает столбец как неявно присутствующий «системный» столбец.

Например, предположим, мы хотим создать Table, который пропускает отображение столбца PostgreSQL xmin на бэкенде PostgreSQL, но на других бэкендах отображает его, в ожидании срабатывающего правила. Условное правило компиляции может пропустить это имя только на PostgreSQL:

from sqlalchemy.schema import CreateColumn

@compiles(CreateColumn, "postgresql")
def skip_xmin(element, compiler, **kw):
    if element.element.name == 'xmin':
        return None
    else:
        return compiler.visit_create_column(element, **kw)


my_table = Table('mytable', metadata,
            Column('id', Integer, primary_key=True),
            Column('xmin', Integer)
        )

Выше, конструкция CreateTable будет генерировать CREATE TABLE, которая включает только колонку id в строке; колонка xmin будет опущена, но только для бэкенда PostgreSQL.

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

класс sqlalchemy.schema.CreateColumn (sqlalchemy.schema.BaseDDLElement)

class sqlalchemy.schema.CreateSequence¶

Представьте оператор CREATE SEQUENCE.

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

класс sqlalchemy.schema.CreateSequence (sqlalchemy.schema._CreateBase)

class sqlalchemy.schema.DropSequence¶

Представьте оператор DROP SEQUENCE.

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

класс sqlalchemy.schema.DropSequence (sqlalchemy.schema._DropBase)

class sqlalchemy.schema.CreateIndex¶

Представьте оператор CREATE INDEX.

Members

__init__()

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

класс sqlalchemy.schema.CreateIndex (sqlalchemy.schema._CreateBase)

method sqlalchemy.schema.CreateIndex.__init__(element, if_not_exists=False)¶

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

Параметры:

• element – a Index, который является объектом CREATE.

• if_not_exists – если True, то к конструкции будет применен оператор IF NOT EXISTS. … версия добавлена:: 1.4.0b2

class sqlalchemy.schema.DropIndex¶

Представьте оператор DROP INDEX.

Members

__init__()

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

класс sqlalchemy.schema.DropIndex (sqlalchemy.schema._DropBase)

method sqlalchemy.schema.DropIndex.__init__(element, if_exists=False)¶

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

Параметры:

• element – a Index, который является объектом DROP.

• if_exists – если True, к конструкции будет применен оператор IF EXISTS. … версия добавлена:: 1.4.0b2

class sqlalchemy.schema.AddConstraint¶

Представьте оператор ALTER TABLE ADD CONSTRAINT.

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

класс sqlalchemy.schema.AddConstraint (sqlalchemy.schema._CreateBase)

class sqlalchemy.schema.DropConstraint¶

Представьте оператор ALTER TABLE DROP CONSTRAINT.

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

класс sqlalchemy.schema.DropConstraint (sqlalchemy.schema._DropBase)

class sqlalchemy.schema.CreateSchema¶

Представьте оператор CREATE SCHEMA.

Аргументом здесь является строковое имя схемы.

Members

__init__()

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

класс sqlalchemy.schema.CreateSchema (sqlalchemy.schema._CreateBase)

method sqlalchemy.schema.CreateSchema.__init__(name, if_not_exists=False)¶

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

class sqlalchemy.schema.DropSchema¶

Представьте оператор DROP SCHEMA.

Аргументом здесь является строковое имя схемы.

Members

__init__()

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

класс sqlalchemy.schema.DropSchema (sqlalchemy.schema._DropBase)

method sqlalchemy.schema.DropSchema.__init__(name, cascade=False, if_exists=False)¶

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