自定义 DDL¶

在前面的部分中，我们讨论了各种模式结构，包括 Table、ForeignKeyConstraint、CheckConstraint 和 Sequence。一直以来，我们依赖 Table 和 MetaData 的 create() 和 create_all() 方法来发出所有结构的数据定义语言 (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 目录中查看它是否存在

defshould_create(ddl,target,connection,**kw):row=connection.execute("select conname from pg_constraint where conname='%s'"%ddl.element.name).scalar()returnnotbool(row)defshould_drop(ddl,target,connection,**kw):returnnotshould_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 结构

fromsqlalchemy.schemaimportCreateTablewithengine.connect()asconn: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() 方法相同的参数，以便控制其 DDL 是否会与其父 Table 对象一起发出。这些方法可以在创建 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()，则这两个结构体都不会被包含在内。

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

>>> fromsqlalchemyimportcreate_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¶ – 可选的 callable，它将传递一个 ForeignKeyConstraint 对象；如果它返回 True，则此约束将不被视为依赖关系。注意，这与 sort_tables_and_constraints() 中的相同参数不同，后者改为传递拥有 ForeignKeyConstraint 对象。
extra_dependencies¶ – 一系列包含两个表的元组，它们也将被视为相互依赖。

另请参阅

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 类的基础，以及各种创建/删除子句构造，例如 CreateTable、DropTable、AddConstraint 等。

在版本 2.0 中变更: ExecutableDDLElement 从 DDLElement 重命名，后者仍然存在以保持向后兼容。

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

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

另请参阅

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

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

当 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: 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 关键字参数传递给可调用对象的 value。

另请参阅

SchemaItem.ddl_if()

DDLEvents

Events

class sqlalchemy.schema.DDL¶

文字 DDL 语句。

指定由数据库执行的文字 SQL DDL。DDL 对象充当 DDL 事件监听器，并且可以使用 Table 或 MetaData 对象作为目标，订阅 DDLEvents 中列出的那些事件。基本模板支持允许单个 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 的“上下文”（如果有）将与上面提到的标准替换相结合。上下文中存在的键将覆盖标准替换。

Members

__init__()

类签名

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

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

创建一个 DDL 语句。

参数:

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

语句中的文字“%”必须转义为“%%”。

DDL 语句中不提供 SQL 绑定参数。
context¶ – 可选字典，默认为 None。这些值将可用于在 DDL 语句上进行字符串替换。

另请参阅

DDLEvents

Events

class sqlalchemy.schema._CreateDropBase¶

表示 CREATE 和 DROP 或等效操作的 DDL 结构体的基类。

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

类签名

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

class sqlalchemy.schema.CreateTable¶

表示 CREATE TABLE 语句。

Members

__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¶ – 一个 Table，它是 CREATE 的对象
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 语句。

Members

__init__()

类签名

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

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

创建 DropTable 结构。

参数:

element¶ – 一个 Table，它是 DROP 的对象。
on¶ – 请参阅 DDL 中 “on” 的描述。
if_exists¶ –
如果为 True，将对该结构应用 IF EXISTS 操作符。

版本 1.4.0b2 中的新增功能。

class sqlalchemy.schema.CreateColumn¶

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

这用于在生成 CREATE TABLE 语句时支持自定义列 DDL，方法是使用自定义 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。这实质上与在 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 语句。

Members

__init__()

类签名

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

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

创建一个 Createindex 结构。

参数:

element¶ – 一个 Index，它是 CREATE 的对象。
if_not_exists¶ –
如果为 True，将对该结构应用 IF NOT EXISTS 操作符。

版本 1.4.0b2 中的新增功能。

class sqlalchemy.schema.DropIndex¶

表示 DROP INDEX 语句。

Members

__init__()

类签名

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

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

创建一个 DropIndex 结构。

参数:

element¶ – 一个 Index，它是 DROP 的对象。
if_exists¶ –
如果为 True，将对该结构应用 IF EXISTS 操作符。

版本 1.4.0b2 中的新增功能。

class sqlalchemy.schema.AddConstraint¶: 表示 ALTER TABLE ADD CONSTRAINT 语句。

类签名

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

class sqlalchemy.schema.DropConstraint¶: 表示 ALTER TABLE DROP CONSTRAINT 语句。

类签名

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

class sqlalchemy.schema.CreateSchema¶

表示 CREATE SCHEMA 语句。

这里的参数是模式的字符串名称。

Members

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

这里的参数是模式的字符串名称。

Members

__init__()

类签名

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

method sqlalchemy.schema.DropSchema.__init__(name: str, cascade: bool = False, if_exists: bool = False)¶: 创建一个新的 DropSchema 结构。

SQLAlchemy 2.0 文档

SQLAlchemy 2.0 文档

SQLAlchemy Core

项目版本

自定义 DDL¶

自定义 DDL¶

控制 DDL 序列¶

使用内置的 DDLElement 类¶

控制 DDL 生成的约束和索引¶

DDL 表达式结构体 API¶