自定义 DDL

在前面的章节中，我们讨论了各种模式构造，包括 Table、ForeignKeyConstraint、CheckConstraint 和 Sequence。 在整个过程中，我们依赖于 create() 和 create_all() 方法，它们属于 Table 和 MetaData，以便为所有构造发出数据定义语言 (DDL)。 当发出时，会调用预定的操作顺序，并且会无条件地创建 DDL 以创建每个表，包括与其关联的所有约束和其他对象。 对于需要特定于数据库的 DDL 的更复杂场景，SQLAlchemy 提供了两种技术，可以根据任何条件添加任何 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)
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)
users.drop(engine)
SELECT conname FROM pg_constraint WHERE conname='cst_user_name_length'
ALTER TABLE users DROP CONSTRAINT cst_user_name_length
DROP TABLE users

使用内置的 DDLElement 类

sqlalchemy.schema 包包含提供 DDL 表达式的 SQL 表达式构造，所有这些表达式都从公共基类 ExecutableDDLElement 扩展而来。 例如，要生成 CREATE TABLE 语句，可以使用 CreateTable 构造

from sqlalchemy.schema import CreateTable

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

上面，CreateTable 构造的工作方式与任何其他表达式构造（例如 select()、table.insert() 等）类似。 SQLAlchemy 的所有面向 DDL 的构造都是 ExecutableDDLElement 基类的子类； 这是与 CREATE 和 DROP 以及 ALTER 相对应的所有对象的基础，不仅在 SQLAlchemy 中，而且在 Alembic Migrations 中也是如此。 可用构造的完整参考在 DDL 表达式构造 API 中。

用户定义的 DDL 构造也可以创建为 ExecutableDDLElement 本身的子类。 自定义 SQL 构造和编译扩展 中的文档有几个示例。

控制约束和索引的 DDL 生成

2.0 版本新增。

虽然前面提到的 ExecutableDDLElement.execute_if() 方法对于需要有条件调用的自定义 DDL 类很有用，但通常还需要与特定 Table 相关的元素（即约束和索引）也服从“条件”规则，例如包含特定于特定后端（如 PostgreSQL 或 SQL Server）的功能的索引。 对于此用例，Constraint.ddl_if() 和 Index.ddl_if() 方法可以用于诸如 CheckConstraint、UniqueConstraint 和 Index 之类的构造，接受与 ExecutableDDLElement.execute_if() 方法相同的参数，以便控制是否会根据其父 Table 对象发出它们的 DDL。 这些方法可以在创建 Table 的定义时内联使用（或者类似地，在使用 ORM 声明性映射中的 __table_args__ 集合时），例如

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")，这表明这些元素将仅在 PostgreSQL 方言上包含在 CREATE TABLE 序列中。 例如，如果我们针对 SQLite 方言运行 meta.create_all()，则不会包含任何构造

>>> from sqlalchemy import create_engine
>>> sqlite_engine = create_engine("sqlite+pysqlite://", echo=True)
>>> meta.create_all(sqlite_engine)
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 数据库运行相同的命令，我们将看到 CHECK 约束的内联 DDL 以及为索引发出的单独的 CREATE 语句

>>> from sqlalchemy import create_engine
>>> postgresql_engine = create_engine(
...     "postgresql+psycopg2://scott:tiger@localhost/test", echo=True
... )
>>> meta.create_all(postgresql_engine)
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() 的行为一样），而且可以在 CreateTable 对象的 SQL 编译阶段内查询，该对象负责在 CREATE TABLE 语句中内联呈现 CHECK (num > 5) DDL。 因此，ddl_if.callable_() 参数接收的事件挂钩具有更丰富的参数集，包括存在的 dialect 关键字参数，以及通过 compiler 关键字参数传递的 DDLCompiler 实例，用于序列的“内联呈现”部分。 当事件在 DDLCompiler 序列中触发时，bind 参数不存在，因此希望检查数据库版本信息的现代事件挂钩最好使用给定的 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),
)

另请参阅

Constraint.ddl_if()

Index.ddl_if()

DDL 表达式构造 API

对象名称	描述
_CreateDropBase	表示 CREATE 和 DROP 或等效项的 DDL 构造的基类。
AddConstraint	表示 ALTER TABLE ADD CONSTRAINT 语句。
BaseDDLElement	DDL 构造的根，包括那些在“创建表”和其他过程中的子元素。
CreateColumn	通过 CreateTable 构造，表示在 CREATE TABLE 语句中呈现的 Column。
CreateIndex	表示 CREATE INDEX 语句。
CreateSchema	表示 CREATE SCHEMA 语句。
CreateSequence	表示 CREATE SEQUENCE 语句。
CreateTable	表示 CREATE TABLE 语句。
DDL	文字 DDL 语句。
DropConstraint	表示 ALTER TABLE DROP CONSTRAINT 语句。
DropIndex	表示 DROP INDEX 语句。
DropSchema	表示 DROP SCHEMA 语句。
DropSequence	表示 DROP SEQUENCE 语句。
DropTable	表示 DROP TABLE 语句。
ExecutableDDLElement	独立可执行 DDL 表达式构造的基类。
sort_tables(tables[, skip_fn, extra_dependencies])	根据依赖关系对 Table 对象的集合进行排序。
sort_tables_and_constraints(tables[, filter_fn, extra_dependencies, _warn_for_cycles])	对 Table / ForeignKeyConstraint 对象的集合进行排序。

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

根据依赖关系对 Table 对象的集合进行排序。

这是一个依赖关系排序，它将发出 Table 对象，以便它们跟随其依赖的 Table 对象。 表根据 ForeignKeyConstraint 对象的存在以及 Table.add_is_dependent_on() 添加的显式依赖关系而相互依赖。

警告

sort_tables() 函数本身无法自动解决表之间的依赖关系循环，这些循环通常是由相互依赖的外键约束引起的。 当检测到这些循环时，这些表的外键将从排序中省略。 当发生这种情况时，会发出警告，这将在未来的版本中引发异常。 不属于循环的表仍将按依赖顺序返回。

要解决这些循环，可以将 ForeignKeyConstraint.use_alter 参数应用于那些创建循环的约束。 或者，当检测到循环时，sort_tables_and_constraints() 函数将自动返回单独集合中的外键约束，以便可以将它们单独应用于模式。

在 1.3.17 版本中更改：- 当 sort_tables() 由于循环依赖关系而无法执行正确的排序时，会发出警告。 这将在未来的版本中成为异常。 此外，排序将继续按依赖顺序返回未参与循环的其他表，这在以前的版本中并非如此。

参数:

• 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 版本新增。

类签名

class sqlalchemy.schema.BaseDDLElement (sqlalchemy.sql.expression.ClauseElement)

class sqlalchemy.schema.ExecutableDDLElement

独立可执行 DDL 表达式构造的基类。

此类是通用 DDL 类以及各种 create/drop 子句构造（如 CreateTable、DropTable、AddConstraint 等）的基类。

在 2.0 版本中更改：ExecutableDDLElement 从 DDLElement 重命名，后者仍然存在以实现向后兼容性。

ExecutableDDLElement 与 事件 中介绍的 SQLAlchemy 事件紧密集成。 它的一个实例本身就是一个事件接收可调用对象

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

另请参阅

DDL

DDLEvents

事件

控制 DDL 序列

成员

__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 的副本，其中将包含给定的目标。

这实际上是将给定的项目应用于返回的 ExecutableDDLElement 对象的 .target 属性。 然后，事件处理程序和编译例程可以使用此目标，以便提供诸如根据特定 Table 对 DDL 字符串进行标记化之类的服务。

当 ExecutableDDLElement 对象被建立为 DDLEvents.before_create() 或 DDLEvents.after_create() 事件的事件处理程序，并且该事件随后针对给定目标（例如 Constraint 或 Table）发生时，该目标是使用此方法通过 ExecutableDDLElement 对象的副本建立的，然后继续执行 ExecutableDDLElement.execute() 方法，以便调用实际的 DDL 指令。

参数:

target – 将成为 DDL 操作主题的 SchemaItem。

返回:

此 ExecutableDDLElement 的副本，其 .target 属性被赋值为给定的 SchemaItem。

另请参阅

DDL - 在处理 DDL 字符串时，针对“target”使用分词。

method sqlalchemy.schema.ExecutableDDLElement.execute_if(dialect: str | None = None, callable_: DDLIfCallable | None = None, state: Any | None = 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 对象。如果显式执行 DDL，则可能为 None。

  bind:

  用于 DDL 执行的 Connection。如果此构造是在表中内联创建的，则可能为 None，在这种情况下，将存在 compiler。

  tables:

  可选关键字参数 - 在 MetaData.create_all() 或 drop_all() 方法调用中要创建/删除的 Table 对象列表。

  dialect:

  关键字参数，但始终存在 - 操作中涉及的 Dialect。

  compiler:

  关键字参数。对于引擎级别 DDL 调用，将为 None，但如果此 DDL 元素是在表中内联创建的，则将引用 DDLCompiler。

  state:

  可选关键字参数 - 将是传递给此函数的 state 参数。

  checkfirst:

  关键字参数，如果在调用 create()、create_all()、drop()、drop_all() 期间设置了“checkfirst”标志，则为 True。

  如果可调用对象返回 True 值，则将执行 DDL 语句。

• state – 将作为 state 关键字参数传递给 callable_ 的任何值。

另请参阅

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)

在对 Table 事件进行操作时，以下 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 的“context”（如果存在）将与上面注释的标准替换相结合。context 中存在的键将覆盖标准替换。

成员

__init__()

类签名

class sqlalchemy.schema.DDL (sqlalchemy.schema.ExecutableDDLElement)

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

创建 DDL 语句。

参数:

• statement –

  要执行的字符串或 Unicode 字符串。语句将使用 Python 的字符串格式化运算符和固定的字符串替换集以及可选的 DDL.context 参数提供的其他替换进行处理。

  语句中的字面 ‘%’ 必须转义为 ‘%%’。

  SQL 绑定参数在 DDL 语句中不可用。

• context – 可选字典，默认为 None。这些值可用于 DDL 语句中的字符串替换。

另请参阅

DDLEvents

事件

class sqlalchemy.schema._CreateDropBase

表示 CREATE 和 DROP 或等效项的 DDL 构造的基类。

_CreateDropBase 的共同主题是单个 element 属性，该属性引用要创建或删除的元素。

类签名

class sqlalchemy.schema._CreateDropBase (sqlalchemy.schema.ExecutableDDLElement)

class sqlalchemy.schema.CreateTable

表示 CREATE TABLE 语句。

成员

__init__()

类签名

class sqlalchemy.schema.CreateTable (sqlalchemy.schema._CreateBase)

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

创建 CreateTable 构造。

参数:

• element – 作为 CREATE 主题的 Table

• on – 请参阅 DDL 中“on”的描述。

• 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 语句。

成员

__init__()

类签名

class sqlalchemy.schema.DropTable (sqlalchemy.schema._DropBase)

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

创建 DropTable 构造。

参数:

• element – 作为 DROP 主题的 Table。

• on – 请参阅 DDL 中“on”的描述。

• if_exists –

  如果为 True，则 IF EXISTS 运算符将应用于构造。

  1.4.0b2 版本新增。

class sqlalchemy.schema.CreateColumn

通过 CreateTable 构造，表示在 CREATE TABLE 语句中呈现的 Column。

提供此功能是为了在使用 自定义 SQL 构造和编译扩展 中记录的编译器扩展来扩展 CreateColumn 时，支持在生成 CREATE TABLE 语句中的自定义列 DDL。

典型的集成是检查传入的 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 的编译规则来完成的。这本质上是如何产生与在 Column 上使用 system=True 参数相同的效果，该参数将列标记为隐式存在的“系统”列。

例如，假设我们希望生成一个 Table，该表跳过针对 PostgreSQL 后端渲染 PostgreSQL xmin 列，但在其他后端上渲染它，以预期触发规则。条件编译规则可以仅在 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 后端。

类签名

class sqlalchemy.schema.CreateColumn (sqlalchemy.schema.BaseDDLElement)

class sqlalchemy.schema.CreateSequence

表示 CREATE SEQUENCE 语句。

类签名

class sqlalchemy.schema.CreateSequence (sqlalchemy.schema._CreateBase)

class sqlalchemy.schema.DropSequence

表示 DROP SEQUENCE 语句。

类签名

class sqlalchemy.schema.DropSequence (sqlalchemy.schema._DropBase)

class sqlalchemy.schema.CreateIndex

表示 CREATE INDEX 语句。

成员

__init__()

类签名

class sqlalchemy.schema.CreateIndex (sqlalchemy.schema._CreateBase)

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

创建 Createindex 构造。

参数:

• element – 作为 CREATE 主题的 Index。

• if_not_exists –

  如果为 True，则 IF NOT EXISTS 运算符将应用于构造。

  1.4.0b2 版本新增。

class sqlalchemy.schema.DropIndex

表示 DROP INDEX 语句。

成员

__init__()

类签名

class sqlalchemy.schema.DropIndex (sqlalchemy.schema._DropBase)

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

创建 DropIndex 构造。

参数:

• element – 作为 DROP 主题的 Index。

• if_exists –

  如果为 True，则 IF EXISTS 运算符将应用于构造。

  1.4.0b2 版本新增。

class sqlalchemy.schema.AddConstraint

表示 ALTER TABLE ADD CONSTRAINT 语句。

成员

__init__()

类签名

class sqlalchemy.schema.AddConstraint (sqlalchemy.schema._CreateBase)

method sqlalchemy.schema.AddConstraint.__init__(element: Constraint, *, isolate_from_table: bool = True)

构造一个新的 AddConstraint 构造。

参数:

• element – Constraint 对象

• isolate_from_table –

  可选布尔值，默认为 True。具有使传入约束与关联到 Table 时包含在 CREATE TABLE 序列中的效果隔离的效果。

  2.0.39 版本新增: - 添加了 AddConstraint.isolate_from_table，默认为 True。以前，此参数的行为在所有情况下都隐式打开。

class sqlalchemy.schema.DropConstraint

表示 ALTER TABLE DROP CONSTRAINT 语句。

成员

__init__()

类签名

class sqlalchemy.schema.DropConstraint (sqlalchemy.schema._DropBase)

method sqlalchemy.schema.DropConstraint.__init__(element: Constraint, *, cascade: bool = False, if_exists: bool = False, isolate_from_table: bool = True, **kw: Any)

构造一个新的 DropConstraint 构造。

参数:

• element – Constraint 对象

• cascade – 可选布尔值，指示如果可用，则应呈现后端特定的“CASCADE CONSTRAINT”指令

• if_exists – 可选布尔值，指示如果可用，则应呈现后端特定的“IF EXISTS”指令

• isolate_from_table –

  可选布尔值，默认为 True。具有使传入约束与关联到 Table 时包含在 CREATE TABLE 序列中的效果隔离的效果。

  2.0.39 版本新增: - 添加了 DropConstraint.isolate_from_table，默认为 True。以前，此参数的行为在所有情况下都隐式打开。

class sqlalchemy.schema.CreateSchema

表示 CREATE SCHEMA 语句。

此处的参数是模式的字符串名称。

成员

__init__()

类签名

class sqlalchemy.schema.CreateSchema (sqlalchemy.schema._CreateBase)

method sqlalchemy.schema.CreateSchema.__init__(name: str, if_not_exists: bool = False)

构造一个新的 CreateSchema 构造。

class sqlalchemy.schema.DropSchema

表示 DROP SCHEMA 语句。

此处的参数是模式的字符串名称。

成员

__init__()

类签名

class sqlalchemy.schema.DropSchema (sqlalchemy.schema._DropBase)

method sqlalchemy.schema.DropSchema.__init__(name: str, cascade: bool = False, if_exists: bool = False)

构造一个新的 DropSchema 构造。