定义约束和索引¶

本节将讨论 SQL 约束和索引。在 SQLAlchemy 中，键类包括 ForeignKeyConstraint 和 Index。

定义外键¶

SQL 中的外键是一种表级构造，它约束该表中的一个或多个列，以仅允许存在于不同列集中的值，通常但并不总是位于不同的表中。我们将受约束的列称为外键列，称它们被约束到引用列的列。引用的列几乎总是定义其拥有的 table 的主键，尽管也有例外。外键是将彼此有关系的成对的行连接在一起的“关节”，SQLAlchemy 在其作的几乎每个领域都非常重视这个概念。

在 SQLAlchemy 和 DDL 中，外键约束可以定义为 table 子句中的附加属性，或者对于单列外键，可以选择在单个列的定义中指定它们。单列外键更常见，在列级别是通过构造 ForeignKey 对象作为 Column 对象的参数来指定的：

user_preference = Table(
    "user_preference",
    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)),
)

在上面，我们定义了一个新的表user_preference，其中每行都必须包含 user_id 列中的值，该值也存在于 user 中 table 的 user_id 列。

ForeignKey 的参数通常是 <tablename>.<columnname> 形式的字符串，或者对于远程架构中的表或 <schemaname>.<tablename>.<columnname> 形式的“所有者”。它也可能是一个实际的 Column 对象，正如我们稍后将看到的那样，可以从现有的 Table 中访问 object 的 C 集合：

ForeignKey(user.c.user_id)

使用字符串的优点是 user 并且仅在首次需要时解析 user_preference，因此 table 对象可以轻松地分布在多个模块中，并按任意顺序定义。

外键也可以在表级别定义，使用 ForeignKeyConstraint 对象。此对象可以描述单列或多列外键。多列外键称为复合外键，它几乎总是引用具有复合主键的表。下面我们定义了一个具有复合主键的表 invoice：

invoice = Table(
    "invoice",
    metadata_obj,
    Column("invoice_id", Integer, primary_key=True),
    Column("ref_num", Integer, primary_key=True),
    Column("description", String(60), nullable=False),
)

然后invoice_item一个带有复合外键引用的表 发票：

invoice_item = Table(
    "invoice_item",
    metadata_obj,
    Column("item_id", Integer, primary_key=True),
    Column("item_name", String(60), nullable=False),
    Column("invoice_id", Integer, nullable=False),
    Column("ref_num", Integer, nullable=False),
    ForeignKeyConstraint(
        ["invoice_id", "ref_num"], ["invoice.invoice_id", "invoice.ref_num"]
    ),
)

请务必注意， ForeignKeyConstraint 是定义复合外键。虽然我们也可以将个人 ForeignKey 对象 invoice_item.invoice_id 和 invoice_item.ref_num 列，SQLAlchemy 不会意识到这两个值应该配对在一起 - 它将是两个单独的外键约束，而不是引用两列的单个复合外键。

通过 ALTER 创建/删除外键约束¶

我们在教程和其他地方看到的涉及 DDL 外键的行为表明，约束通常在 CREATE TABLE 语句中“内联”呈现，例如：

CREATE TABLE addresses (
    id INTEGER NOT NULL,
    user_id INTEGER,
    email_address VARCHAR NOT NULL,
    PRIMARY KEY (id),
    CONSTRAINT user_id_fk FOREIGN KEY(user_id) REFERENCES users (id)
)

CONSTRAINT .. FOREIGN KEY 指令用于创建约束在 CREATE TABLE 定义中以 “内联” 方式。这 默认情况下，MetaData.create_all（） 和 MetaData.drop_all（） 方法使用所有 Table 对象的拓扑排序来执行此作 involved 的 Involved 中，以便按其外部的顺序创建和删除表 key 依赖项（此排序也可以通过 MetaData.sorted_tables 访问器）。

当“依赖循环”中涉及两个或多个外键约束时，这种方法不起作用，其中一组表相互依赖，假设后端强制执行外键（SQLite、MySQL/MyISAM 除外）总是如此。因此，这些方法将在这样一个循环中将约束分解为单独的 ALTER 语句，在除不支持大多数形式的 ALTER 的 SQLite 之外的所有后端上。给定一个架构，如下所示：

node = Table(
    "node",
    metadata_obj,
    Column("node_id", Integer, primary_key=True),
    Column("primary_element", Integer, ForeignKey("element.element_id")),
)

element = Table(
    "element",
    metadata_obj,
    Column("element_id", Integer, primary_key=True),
    Column("parent_node_id", Integer),
    ForeignKeyConstraint(
        ["parent_node_id"], ["node.node_id"], name="fk_element_parent_node_id"
    ),
)

当我们在后端（例如 PostgreSQL 后端）上调用 MetaData.create_all（） 时，这两个表之间的循环被解析，并且约束是单独创建的：

>>> withengine.connect()asconn:...     metadata_obj.create_all(conn, checkfirst=False)CREATE TABLE element (
    element_id SERIAL NOT NULL,
    parent_node_id INTEGER,
    PRIMARY KEY (element_id)
)

CREATE TABLE node (
    node_id SERIAL NOT NULL,
    primary_element INTEGER,
    PRIMARY KEY (node_id)
)

ALTER TABLE element ADD CONSTRAINT fk_element_parent_node_id
    FOREIGN KEY(parent_node_id) REFERENCES node (node_id)
ALTER TABLE node ADD FOREIGN KEY(primary_element)
    REFERENCES element (element_id)

为了为这些表发出 DROP，相同的逻辑适用，但请注意，在 SQL 中，要发出 DROP CONSTRAINT 要求约束具有名称。在上面的 'node' 表的情况下，我们没有命名这个 constraint;因此，系统将尝试仅对那些命名为：

>>> withengine.connect()asconn:...     metadata_obj.drop_all(conn, checkfirst=False)ALTER TABLE element DROP CONSTRAINT fk_element_parent_node_id
DROP TABLE node
DROP TABLE element

在无法解决 cycle 的情况下，例如，如果我们没有在此处将 name 应用于任一 constraint，我们将收到以下错误：

sqlalchemy.exc.CircularDependencyError: Can't sort tables for DROP;
an unresolvable foreign key dependency exists between tables:
element, node.  Please ensure that the ForeignKey and ForeignKeyConstraint
objects involved in the cycle have names so that they can be dropped
using DROP CONSTRAINT.

这个错误只适用于 DROP 情况，因为我们可以在 CREATE 情况下发出 “ADD CONSTRAINT” 而不带名称;数据库通常会自动分配一个。

和 ForeignKeyConstraint.use_alter ForeignKey.use_alter 关键字参数可用于手动解析依赖关系循环。我们只能将此标志添加到 'element' 表中，如下所示：

element = Table(
    "element",
    metadata_obj,
    Column("element_id", Integer, primary_key=True),
    Column("parent_node_id", Integer),
    ForeignKeyConstraint(
        ["parent_node_id"],
        ["node.node_id"],
        use_alter=True,
        name="fk_element_parent_node_id",
    ),
)

在我们的 CREATE DDL 中，我们将只看到这个约束的 ALTER 语句，而不是另一个约束的 ALTER 语句：

>>> withengine.connect()asconn:...     metadata_obj.create_all(conn, checkfirst=False)CREATE TABLE element (
    element_id SERIAL NOT NULL,
    parent_node_id INTEGER,
    PRIMARY KEY (element_id)
)

CREATE TABLE node (
    node_id SERIAL NOT NULL,
    primary_element INTEGER,
    PRIMARY KEY (node_id),
    FOREIGN KEY(primary_element) REFERENCES element (element_id)
)

ALTER TABLE element ADD CONSTRAINT fk_element_parent_node_id
FOREIGN KEY(parent_node_id) REFERENCES node (node_id)

ForeignKeyConstraint.use_alter 和 ForeignKey.use_alter，当与 drop作结合使用时，将需要命名约束，否则将生成如下错误：

sqlalchemy.exc.CompileError: Can't emit DROP CONSTRAINT for constraint
ForeignKeyConstraint(...); it has no name

另请参阅

配置约束命名约定

sort_tables_and_constraints（）

更新时和删除时¶

大多数数据库都支持外键值的级联，即当 parent row 更新时，新值将放置在子行中，或者当父行被删除，所有相应的子行都设置为 null 或 deleted。在数据定义语言中，这些是使用 “ON UPDATE CASCADE“、”ON DELETE CASCADE“和”ON DELETE SET NULL“，对应于外键约束。“ON UPDATE” 或 “ON DELETE” 后面的短语也可能允许特定于正在使用的数据库的其他短语。这 ForeignKey 和 ForeignKeyConstraint 对象支持通过 onupdate 和 ondelete 关键字参数生成此子句。该值是将在适当的 “ON UPDATE” 或 “ON DELETE” 短语之后输出的任何字符串：

child = Table(
    "child",
    metadata_obj,
    Column(
        "id",
        Integer,
        ForeignKey("parent.id", onupdate="CASCADE", ondelete="CASCADE"),
        primary_key=True,
    ),
)

composite = Table(
    "composite",
    metadata_obj,
    Column("id", Integer, primary_key=True),
    Column("rev_id", Integer),
    Column("note_id", Integer),
    ForeignKeyConstraint(
        ["rev_id", "note_id"],
        ["revisions.id", "revisions.note_id"],
        onupdate="CASCADE",
        ondelete="SET NULL",
    ),
)

请注意，这些子句在与 MySQL 一起使用时需要 InnoDB 表。其他数据库也可能不支持它们。

另请参阅

有关将 ON DELETE CASCADE 与 ORM relationship（） 构造集成的背景，请参阅以下部分：

将外键 ON DELETE 级联与 ORM 关系一起使用

对多对多关系使用外键 ON DELETE

UNIQUE 约束¶

可以使用 unique 关键字。显式命名唯一约束和/或具有多个列的约束是通过 UniqueConstraint 表级构造。

from sqlalchemy import UniqueConstraint

metadata_obj = MetaData()
mytable = Table(
    "mytable",
    metadata_obj,
    # per-column anonymous unique constraint
    Column("col1", Integer, unique=True),
    Column("col2", Integer),
    Column("col3", Integer),
    # explicit/composite unique constraint.  'name' is optional.
    UniqueConstraint("col2", "col3", name="uix_1"),
)

CHECK 约束¶

检查约束可以是命名的，也可以是未命名的，并且可以使用 CheckConstraint 构造在 Column 或 Table 级别创建。检查约束的文本直接传递到数据库，因此存在有限的 “数据库独立” 行为。列级检查约束通常只应引用它们所在的列，而表级约束可以引用表中的任何列。

请注意，某些数据库并不主动支持检查约束，例如旧版本的 MySQL（8.0.16 之前）。

fromsqlalchemyimportCheckConstraintmetadata_obj=MetaData()mytable=Table("mytable",metadata_obj,# per-column CHECK constraintColumn("col1",Integer,CheckConstraint("col1>5")),Column("col2",Integer),Column("col3",Integer),# table level CHECK constraint.  'name' is optional.CheckConstraint("col2 > col3 + 5",name="check1"),)mytable.create(engine)CREATE TABLE mytable (
    col1 INTEGER  CHECK (col1>5),
    col2 INTEGER,
    col3 INTEGER,
    CONSTRAINT check1  CHECK (col2 > col3 + 5)
)

PRIMARY KEY 约束¶

任何 Table 对象的主键约束都是隐式存在的，基于标有 Column.primary_key 标志。PrimaryKeyConstraint object 提供对此约束的显式访问，其中包括选项直接配置：

from sqlalchemy import PrimaryKeyConstraint

my_table = Table(
    "mytable",
    metadata_obj,
    Column("id", Integer),
    Column("version_id", Integer),
    Column("data", String(50)),
    PrimaryKeyConstraint("id", "version_id", name="mytable_pk"),
)

另请参阅

PrimaryKeyConstraint - 详细的 API 文档。

使用声明式 ORM 扩展时设置 Constraints¶

Table 是 SQLAlchemy Core 结构，它允许定义表元数据，除其他外，SQLAlchemy ORM 可以将其用作映射类的目标。声明式 extension 允许自动创建 Table 对象，因为 table 的内容主要作为 Column 对象的映射。

应用表级约束对象，例如 ForeignKeyConstraint 对于使用 Declare 定义的表，请使用 __table_args__ 属性，如 Table Configuration 中所述。

配置 Constraint 命名约定¶

关系数据库通常为所有约束和索引分配显式名称。在使用 CREATE TABLE 创建表的常见情况下其中 CHECK、UNIQUE 和 PRIMARY KEY 约束等约束是生成后，数据库通常有一个系统 in place，则会自动为这些约束指定名称，如果名称未另行指定。更改现有数据库表时在数据库中使用诸如 ALTER TABLE 之类的命令，此命令通常需要为新约束指定显式名称，并且能够指定要删除或修改的现有约束的名称。

可以使用 Constraint.name 参数显式命名约束，对于索引，可以使用 Index.name 参数命名。但是，在约束的情况下，此参数是可选的。还有使用 Column.unique 和 Column.index 的用例参数创建 UniqueConstraint 和 Index 对象，而无需指定显式名称。

更改现有表和约束的使用案例可以通过 Alembic 等架构迁移工具进行处理。但是，Alembic 和 SQLAlchemy 当前都没有为未指定名称的约束对象创建名称，这会导致能够更改现有约束意味着必须对关系数据库使用的命名系统进行逆向工程以自动分配名称，或者必须注意确保所有约束都已命名。

与必须为所有 Constraint 分配显式名称相反和 Index 对象，可以使用事件构建自动命名方案。这种方法的优点是，约束将获得一致的命名方案，而无需在整个代码中使用显式名称参数，并且约定也适用于 Column.unique 生成的那些约束和索引和 Column.index 参数。从 SQLAlchemy 0.9.2 开始，这个包含基于事件的方法，并且可以使用参数 MetaData.naming_convention。

为 MetaData Collection 配置命名约定¶

MetaData.naming_convention 是指接受 Index 类或单个 Constraint 类作为键，接受 Python 字符串模板作为值的字典。它还接受一系列字符串代码作为替代键，“fk”、“pk”、 “ix”， “ck”， “uq” 用于外键、主键、索引、 check 和 unique constraint 分别进行验证。此 dictionary 的 Dict 或 Index 与 this 相关联时没有给定现有名称的 MetaData 对象（包括可以进一步修饰现有名称的一种例外情况）。

适合基本情况的示例命名约定如下：

convention = {
    "ix": "ix_%(column_0_label)s",
    "uq": "uq_%(table_name)s_%(column_0_name)s",
    "ck": "ck_%(table_name)s_%(constraint_name)s",
    "fk": "fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s",
    "pk": "pk_%(table_name)s",
}

metadata_obj = MetaData(naming_convention=convention)

上述约定将为目标 MetaData 集合中的所有约束建立名称。例如，我们可以观察在创建 unnamed 时生成的 name UniqueConstraint 的 UniqueConstraint 中：

>>> user_table = Table(
...     "user",
...     metadata_obj,
...     Column("id", Integer, primary_key=True),
...     Column("name", String(30), nullable=False),
...     UniqueConstraint("name"),
... )
>>> list(user_table.constraints)[1].name
'uq_user_name'

即使我们只使用 Column.unique 旗：

>>> user_table = Table(
...     "user",
...     metadata_obj,
...     Column("id", Integer, primary_key=True),
...     Column("name", String(30), nullable=False, unique=True),
... )
>>> list(user_table.constraints)[1].name
'uq_user_name'

命名约定方法的一个关键优点是名称是在 Python 构造时建立的，而不是在 DDL 发出时建立的。这在使用 Alembic 的 --autogenerate 功能时产生的效果是，当生成新的迁移脚本时，命名约定将是明确的：

def upgrade():
    op.create_unique_constraint("uq_user_name", "user", ["name"])

上面的 “uq_user_name” 字符串是从 UniqueConstraint 复制的对象，该对象 --autogenerate 位于我们的元数据中。

可用的令牌包括 %（table_name）、%（referred_table_name）s、 %（column_0_name）s， %（column_0_label）s， %（column_0_key）s， %（referred_column_0_name） 和 %（constraint_name） 以及每种的多列版本，包括 %（column_0N_name）s、 %（column_0_N_name）、%（referred_column_0_N_name）s，它们渲染所有列名之间用下划线分隔，或者不带下划线。的文档 MetaData.naming_convention 对这些约定中的每一个都有更多的详细信息。

默认命名约定¶

MetaData.naming_convention 的默认值处理为 Index 分配名称的长期 SQLAlchemy 行为对象：

>>> from sqlalchemy.sql.schema import DEFAULT_NAMING_CONVENTION
>>> DEFAULT_NAMING_CONVENTION
immutabledict({'ix': 'ix_%(column_0_label)s'})

长名称的截断¶

当生成的名称（尤其是使用多列标记的名称）对于目标数据库的标识符长度限制来说太长时（例如，PostgreSQL 限制为 63 个字符），将使用基于长名称的 md5 哈希的 4 个字符后缀确定性地截断该名称。例如，下面的命名约定将根据正在使用的列名生成非常长的名称：

metadata_obj = MetaData(
    naming_convention={"uq": "uq_%(table_name)s_%(column_0_N_name)s"}
)

long_names = Table(
    "long_names",
    metadata_obj,
    Column("information_channel_code", Integer, key="a"),
    Column("billing_convention_name", Integer, key="b"),
    Column("product_identifier", Integer, key="c"),
    UniqueConstraint("a", "b", "c"),
)

在 PostgreSQL 方言中，长度超过 63 个字符的名称将被截断，如以下示例所示：

CREATE TABLE long_names (
    information_channel_code INTEGER,
    billing_convention_name INTEGER,
    product_identifier INTEGER,
    CONSTRAINT uq_long_names_information_channel_code_billing_conventi_a79e
    UNIQUE (information_channel_code, billing_convention_name, product_identifier)
)

上述后缀 a79e 基于长名称的 md5 哈希值，每次都会生成相同的值，以便为给定架构生成一致的名称。

为命名约定创建自定义令牌¶

还可以通过在 naming_convention 字典中指定其他 token 和 callable 来添加新 token。例如，如果我们想要使用 GUID 方案命名外键约束，我们可以按如下方式执行此作：

import uuid


def fk_guid(constraint, table):
    str_tokens = (
        [
            table.name,
        ]
        + [element.parent.name for element in constraint.elements]
        + [element.target_fullname for element in constraint.elements]
    )
    guid = uuid.uuid5(uuid.NAMESPACE_OID, "_".join(str_tokens).encode("ascii"))
    return str(guid)


convention = {
    "fk_guid": fk_guid,
    "ix": "ix_%(column_0_label)s",
    "fk": "fk_%(fk_guid)s",
}

在上面，当我们创建一个新的 ForeignKeyConstraint 时，我们将得到一个如下名称：

>>> metadata_obj = MetaData(naming_convention=convention)

>>> user_table = Table(
...     "user",
...     metadata_obj,
...     Column("id", Integer, primary_key=True),
...     Column("version", Integer, primary_key=True),
...     Column("data", String(30)),
... )
>>> address_table = Table(
...     "address",
...     metadata_obj,
...     Column("id", Integer, primary_key=True),
...     Column("user_id", Integer),
...     Column("user_version_id", Integer),
... )
>>> fk = ForeignKeyConstraint(["user_id", "user_version_id"], ["user.id", "user.version"])
>>> address_table.append_constraint(fk)
>>> fk.name
fk_0cd51ab5-8d70-56e8-a83c-86661737766d

另请参阅

MetaData.naming_convention - 有关其他使用详细信息以及所有可用命名组件的列表。

命名约束的重要性 - 在 Alembic 文档中。

1.3.0 版本的新Function：添加了多列命名标记，例如 %（column_0_N_name）s。超出目标数据库字符限制的生成名称将被确定性截断。

命名 CHECK 约束¶

CheckConstraint 对象是针对任意 SQL 表达式配置的，该表达式可以包含任意数量的列，此外，通常使用原始 SQL 字符串进行配置。因此，与 CheckConstraint 一起使用的常见约定是，我们希望对象已经有一个名称，然后使用其他约定元素来增强它。典型的约定是 "ck_%(table_name)s_%(constraint_name)s" ：

metadata_obj = MetaData(
    naming_convention={"ck": "ck_%(table_name)s_%(constraint_name)s"}
)

Table(
    "foo",
    metadata_obj,
    Column("value", Integer),
    CheckConstraint("value > 5", name="value_gt_5"),
)

上表将生成名称 ck_foo_value_gt_5：

CREATE TABLE foo (
    value INTEGER,
    CONSTRAINT ck_foo_value_gt_5 CHECK (value > 5)
)

CheckConstraint 还支持 %（columns_0_name） 令牌;我们可以通过确保使用 Column 或 column（） 元素，方法是将约束与表分开声明：

metadata_obj = MetaData(naming_convention={"ck": "ck_%(table_name)s_%(column_0_name)s"})

foo = Table("foo", metadata_obj, Column("value", Integer))

CheckConstraint(foo.c.value > 5)

或者使用 column（） 内联：

from sqlalchemy import column

metadata_obj = MetaData(naming_convention={"ck": "ck_%(table_name)s_%(column_0_name)s"})

foo = Table(
    "foo", metadata_obj, Column("value", Integer), CheckConstraint(column("value") > 5)
)

两者都将产生名称 ck_foo_value：

CREATE TABLE foo (
    value INTEGER,
    CONSTRAINT ck_foo_value CHECK (value > 5)
)

“列零”名称的确定是通过扫描列对象的给定表达式来执行的。如果表达式存在多个列，则扫描会使用确定性搜索，但是表达式的结构将确定哪一列被记录为“列零”。

为 Boolean、Enum 和其他 schema 类型配置命名¶

SchemaType 类引用类型对象，如 Boolean 和 Enum，它们会生成一个伴随类型的 CHECK 约束。这里约束的名称可以通过发送 “name” 参数来最直接地设置，例如 Boolean.name：

Table("foo", metadata_obj, Column("flag", Boolean(name="ck_foo_flag")))

命名约定功能也可以与这些类型结合使用，通常是通过使用包含 %（constraint_name）s 的约定，然后将名称应用于类型：

metadata_obj = MetaData(
    naming_convention={"ck": "ck_%(table_name)s_%(constraint_name)s"}
)

Table("foo", metadata_obj, Column("flag", Boolean(name="flag_bool")))

上表将生成约束名称 ck_foo_flag_bool：

CREATE TABLE foo (
    flag BOOL,
    CONSTRAINT ck_foo_flag_bool CHECK (flag IN (0, 1))
)

SchemaType 类使用特殊的内部符号，因此命名约定仅在 DDL 编译时确定。在 PostgreSQL 上，有一个原生的 BOOLEAN 类型，因此 CHECK 约束为 Boolean 不需要;我们可以安全地设置一个没有名称的 Boolean 类型，即使 CHECK 约束有命名约定。只有当我们针对没有原生 BOOLEAN 类型（如 SQLite 或 MySQL）的数据库运行时，才会参考此约定来获取 CHECK 约束。

CHECK 约束还可以使用 column_0_name 令牌，它与 SchemaType 配合得很好，因为这些约束只有一列：

metadata_obj = MetaData(naming_convention={"ck": "ck_%(table_name)s_%(column_0_name)s"})

Table("foo", metadata_obj, Column("flag", Boolean()))

上述 schema 将生成：

CREATE TABLE foo (
    flag BOOL,
    CONSTRAINT ck_foo_flag CHECK (flag IN (0, 1))
)

在 ORM 声明式 mixin 中使用命名约定¶

当将命名约定功能与 ORM 声明式 Mixin 一起使用时，每个 Mixin 都必须存在单独的约束对象实际的 table 映射子类。请参阅该部分使用 Mixins 上的命名约定创建索引和约束，了解背景和示例。

约束 API¶

对象名称	描述
CheckConstraint	表级或列级 CHECK 约束。
ColumnCollectionConstraint	代理 ColumnCollection 的约束。
ColumnCollectionMixin	`列的` `ColumnCollection` 对象。
约束	表级 SQL 约束。
卷	标记一个字符串，指示名称已通过命名约定进行转换。
外键	定义两列之间的依赖关系。
ForeignKeyConstraint 的	表级 FOREIGN KEY 约束。
HasConditionalDDL	定义一个包含 `HasConditionalDDL.ddl_if（）` 的类方法，允许 DDL 的条件渲染。
PrimaryKeyConstraint	表级 PRIMARY KEY 约束。
UniqueConstraint （唯一约束）	表级 UNIQUE 约束。

类 sqlalchemy.schema 中。约束¶

表级 SQL 约束。

Constraint 充当可与 Table 关联的一系列约束对象的基类对象，包括 PrimaryKeyConstraint、 ForeignKeyConstraint、UniqueConstraint 和 CheckConstraint 的 Constraint 实例。

成员

__init__（）， argument_for（）， copy（）， ddl_if（）， dialect_kwargs， dialect_options， info， kwargs

类签名

类 sqlalchemy.schema.Constraint （ sqlalchemy.sql.base.DialectKWArgs ， sqlalchemy.schema.HasConditionalDDL ， sqlalchemy.schema.SchemaItem）

方法 sqlalchemy.schema.Constraint 中。__init__（name： _ConstraintNameArgument = None， deferrable：boolNone=None， initially：strNone=None， info：_InfoTypeNone=None， comment：strNone=None， _create_rule：AnyNone=None， _type_bound： bool = false， **dialect_kw： any）→ 无¶

创建 SQL 约束。

参数

name¶- 可选，此 Constraint 的数据库内名称。
deferrable¶ – 可选 bool。如果设置，则在为此约束发出 DDL 时发出 DEFERRABLE 或 NOT DEFERRABLE。
initially¶ – 可选字符串。如果设置，则在为此约束发出 DDL 时发出 INITIALLY <value>。
info¶– 可选的数据字典，将被填充到 SchemaItem.info 对象的属性。
评论¶ –

可选字符串，将在创建外键约束时呈现 SQL 注释。

2.0 版的新Function。
**dialect_kw¶– 其他关键字参数特定于方言，并以 <dialectname>_<argname> 的形式传递。看有关单个方言的文档，请访问 Dialects 了解记录在案的论点的详细信息。
_create_rule¶ – 由一些也创建约束的数据类型在内部使用。
_type_bound¶ – 在内部用于表示此约束与特定数据类型相关联。

类方法 sqlalchemy.schema.Constraint 中。argument_for（dialect_name， argument_name，默认）¶

继承自DialectKWArgs 的 DialectKWArgs.argument_for（） 方法

为此类添加一种新的特定于方言的关键字参数。

例如：

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

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

DialectKWArgs.argument_for（） 方法是按参数计算的方式向 DefaultDialect.construct_arguments 字典。此字典代表方言提供各种架构级构造接受的参数名称列表。

新方言通常应将此字典一次性指定为 dialect 类的数据成员。临时添加参数名称的用例通常用于最终用户代码，这些代码也使用使用额外参数的自定义编译方案。

参数

dialect_name¶ – 方言的名称。方言必须是可定位的，否则会引发 NoSuchModuleError 。这 dialect 还必须包含现有的 DefaultDialect.construct_arguments collection，表示它参与关键字参数验证和默认系统，否则会引发 ArgumentError。如果 dialect 不包含此集合，则已经可以代表此 dialect 指定任何 keyword 参数。SQLAlchemy 中打包的所有方言都包含此集合，但对于第三方方言，支持可能会有所不同。
argument_name¶ – 参数的名称。
default¶ – 参数的默认值。

方法 sqlalchemy.schema.Constraint 中。copy（**kw： Any）→ Self¶: 1.4 版后已移除： Constraint.copy（） 方法已弃用，并将在未来版本中删除。

方法 sqlalchemy.schema.Constraint 中。ddl_if（dialect：strNone=None， callable_：DDLIfCallableNone=None， state：AnyNone=None）→ 自我¶

继承自HasConditionalDDL 的 HasConditionalDDL.ddl_if（） 方法

将条件 DDL 规则应用于此架构项。

这些规则的工作方式与 ExecutableDDLElement.execute_if() callable，并添加了一个功能，即可以在 DDL 编译阶段检查结构（如 CreateTable）的条件。 HasConditionalDDL.ddl_if（） 当前应用于 索引结构以及所有 Constraint 构建。

参数

- dialect¶ - 方言的字符串名称，或字符串名称的元组，用于表示多种方言类型。
callable_¶ – 使用相同形式构建的可调用如 ExecutableDDLElement.execute_if.callable_ 。
state¶—— 任何将传递给 Callable 的任意对象（如果存在）。

2.0 版的新Function。

另请参阅

控制约束和索引的 DDL 生成 - 背景和使用示例

属性 sqlalchemy.schema.Constraint 的 Constraint 中。dialect_kwargs¶

继承自DialectKWArgs 的 DialectKWArgs.dialect_kwargs属性

指定为此构造的特定于方言的选项的关键字参数的集合。

这些论点以原始的 <dialect>_<kwarg> 显示格式。仅包含实际传递的参数; 与 DialectKWArgs.dialect_options 集合不同，后者包含此方言已知的所有选项，包括 defaults。

该集合也是可写的;接受 <dialect>_<kwarg> 形式的键，其中值将组合到选项列表中。

另请参阅

DialectKWArgs.dialect_options - 嵌套词典形式

属性 sqlalchemy.schema.Constraint 的 Constraint 中。dialect_options¶

继承自DialectKWArgs 的 DialectKWArgs.dialect_options属性

指定为此构造的特定于方言的选项的关键字参数的集合。

这是一个两级嵌套注册表，键为 <dialect_name> 和 <argument_name>。例如，postgresql_where 参数将定位为：

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

在 0.9.2 版本加入.

另请参阅

DialectKWArgs.dialect_kwargs - 平面词典形式

属性 sqlalchemy.schema.Constraint 的 Constraint 中。信息¶

继承自SchemaItem 的 SchemaItem.info属性

与对象关联的 Info 字典，允许用户定义的数据与此 SchemaItem 相关联。

首次访问时，将自动生成该词典。也可以在某些对象的构造函数中指定它，例如 Table 和 Column。

属性 sqlalchemy.schema.Constraint 的 Constraint 中。kwargs¶: 继承自DialectKWArgs 的 DialectKWArgs.kwargs 属性

DialectKWArgs.dialect_kwargs 的同义词。

类 sqlalchemy.schema 中。ColumnCollectionMixin 的集合¶

列的 ColumnCollection 对象。

此集合表示此对象引用的列。

类 sqlalchemy.schema 中。ColumnCollectionConstraint 的 Constraint 对象¶

代理 ColumnCollection 的约束。

成员

__init__（）， argument_for（），列， contains_column（）， copy（）， ddl_if（）， dialect_kwargs， dialect_options， info， kwargs

类签名

类 sqlalchemy.schema.ColumnCollectionConstraint （ sqlalchemy.schema.ColumnCollectionMixin ， sqlalchemy.schema.Constraint）

method sqlalchemy.schema.ColumnCollectionConstraint. __init__（*columns： _DDLColumnArgument， name： _ConstraintNameArgument = None， deferrable：boolNone=None， initially：strNone=None， info：_InfoTypeNone=无，_autoattach：bool = True，_column_flag：bool = False，_gather_expressions：List[_DDLColumnArgument]None=无，**dialect_kw：任意）→ 无¶

参数

columns¶—— 列名或 Column 对象的序列。
name¶— 可选，此约束的数据库内名称。
deferrable¶ – 可选 bool。如果设置，则在为此约束发出 DDL 时发出 DEFERRABLE 或 NOT DEFERRABLE。
initially¶ – 可选字符串。如果设置，则在为此约束发出 DDL 时发出 INITIALLY <value>。
dialect_kw¶——其他关键字参数，包括特定于方言的参数，被传播到 Constraint 超类。

类方法 sqlalchemy.schema.ColumnCollectionConstraint. argument_for（dialect_name， argument_name， default）¶

继承自DialectKWArgs 的 DialectKWArgs.argument_for（） 方法

为此类添加一种新的特定于方言的关键字参数。

例如：

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

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

DialectKWArgs.argument_for（） 方法是按参数计算的方式向 DefaultDialect.construct_arguments 字典。此字典代表方言提供各种架构级构造接受的参数名称列表。

新方言通常应将此字典一次性指定为 dialect 类的数据成员。临时添加参数名称的用例通常用于最终用户代码，这些代码也使用使用额外参数的自定义编译方案。

参数

dialect_name¶ – 方言的名称。方言必须是可定位的，否则会引发 NoSuchModuleError 。这 dialect 还必须包含现有的 DefaultDialect.construct_arguments collection，表示它参与关键字参数验证和默认系统，否则会引发 ArgumentError。如果 dialect 不包含此集合，则已经可以代表此 dialect 指定任何 keyword 参数。SQLAlchemy 中打包的所有方言都包含此集合，但对于第三方方言，支持可能会有所不同。
argument_name¶ – 参数的名称。
default¶ – 参数的默认值。

属性 sqlalchemy.schema.ColumnCollectionConstraint. 列：ReadOnlyColumnCollection[str， Column[Any]]¶: 继承自ColumnCollectionMixin 的 ColumnCollectionMixin.columns 属性

一个 ColumnCollection，表示此约束的列集。

方法 sqlalchemy.schema.ColumnCollectionConstraint. contains_column（col： Column[Any]）→ bool¶

如果此约束包含给定的列，则返回 True。

请注意，此对象还包含一个属性 .columns 它是 Column 对象。

方法 sqlalchemy.schema.ColumnCollectionConstraint. copy（*， target_table：TableNone=None， **kw： Any）→ ColumnCollectionConstraint¶: 1.4 版后已移除：该方法 ColumnCollectionConstraint.copy() 已弃用，并将在未来发行版中删除。

方法 sqlalchemy.schema.ColumnCollectionConstraint. ddl_if（dialect：strNone=None， callable_：DDLIfCallableNone=None， state：AnyNone=None）→ Self¶

继承自HasConditionalDDL 的 HasConditionalDDL.ddl_if（） 方法

将条件 DDL 规则应用于此架构项。

这些规则的工作方式与 ExecutableDDLElement.execute_if() callable，并添加了一个功能，即可以在 DDL 编译阶段检查结构（如 CreateTable）的条件。 HasConditionalDDL.ddl_if（） 当前应用于 索引结构以及所有 Constraint 构建。

参数

- dialect¶ - 方言的字符串名称，或字符串名称的元组，用于表示多种方言类型。
callable_¶ – 使用相同形式构建的可调用如 ExecutableDDLElement.execute_if.callable_ 。
state¶—— 任何将传递给 Callable 的任意对象（如果存在）。

2.0 版的新Function。

另请参阅

控制约束和索引的 DDL 生成 - 背景和使用示例

属性 sqlalchemy.schema.ColumnCollectionConstraint. dialect_kwargs¶

继承自DialectKWArgs 的 DialectKWArgs.dialect_kwargs属性

指定为此构造的特定于方言的选项的关键字参数的集合。

这些论点以原始的 <dialect>_<kwarg> 显示格式。仅包含实际传递的参数; 与 DialectKWArgs.dialect_options 集合不同，后者包含此方言已知的所有选项，包括 defaults。

该集合也是可写的;接受 <dialect>_<kwarg> 形式的键，其中值将组合到选项列表中。

另请参阅

DialectKWArgs.dialect_options - 嵌套词典形式

属性 sqlalchemy.schema.ColumnCollectionConstraint. dialect_options¶

继承自DialectKWArgs 的 DialectKWArgs.dialect_options属性

指定为此构造的特定于方言的选项的关键字参数的集合。

这是一个两级嵌套注册表，键为 <dialect_name> 和 <argument_name>。例如，postgresql_where 参数将定位为：

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

在 0.9.2 版本加入.

另请参阅

DialectKWArgs.dialect_kwargs - 平面词典形式

属性 sqlalchemy.schema.ColumnCollectionConstraint. 信息¶

继承自SchemaItem 的 SchemaItem.info属性

与对象关联的 Info 字典，允许用户定义的数据与此 SchemaItem 相关联。

首次访问时，将自动生成该词典。也可以在某些对象的构造函数中指定它，例如 Table 和 Column。

属性 sqlalchemy.schema.ColumnCollectionConstraint. kwargs¶: 继承自DialectKWArgs 的 DialectKWArgs.kwargs 属性

DialectKWArgs.dialect_kwargs 的同义词。

类 sqlalchemy.schema 中。CheckConstraint 的¶

表级或列级 CHECK 约束。

可以包含在 Table 或 Column 的定义中。

成员

__init__（）， argument_for（），列， contains_column（）， copy（）， ddl_if（）， dialect_kwargs， dialect_options， info， kwargs

类签名

类 sqlalchemy.schema.CheckConstraint （ sqlalchemy.schema.ColumnCollectionConstraint ）

method sqlalchemy.schema.CheckConstraint. __init__（sqltext： _TextCoercedExpressionArgument[Any]， name： _ConstraintNameArgument = None， deferrable：boolNone=无，初始：strNone=无， table：TableNone=无， info：_InfoTypeNone=无， _create_rule：AnyNone=无， _autoattach： bool = True， _type_bound： bool = False， **dialect_kw： any）→ 无¶

构造 CHECK 约束。

参数

sqltext （英语） ¶ –

一个包含约束定义（将逐字使用）的字符串，或者一个 SQL 表达式构造。如果以字符串形式给出，则对象将转换为 text（） 对象。如果文本字符串包含冒号字符，请使用反斜杠转义：
```
CheckConstraint(r"foo ~ E'a(?\:b|c)d")
```
警告

CheckConstraint 的 CheckConstraint.sqltext 参数可以作为 Python 字符串参数传递，该参数将被视为受信任的 SQL 文本并呈现为给定的。不要将不受信任的输入传递给此参数。
name¶— 可选，约束的数据库内名称。
deferrable¶ – 可选 bool。如果设置，则在为此约束发出 DDL 时发出 DEFERRABLE 或 NOT DEFERRABLE。
initially¶ – 可选字符串。如果设置，则在为此约束发出 DDL 时发出 INITIALLY <value>。
info¶– 可选的数据字典，将被填充到 SchemaItem.info 对象的属性。

类方法 sqlalchemy.schema.CheckConstraint. argument_for（dialect_name， argument_name， default）¶

继承自DialectKWArgs 的 DialectKWArgs.argument_for（） 方法

为此类添加一种新的特定于方言的关键字参数。

例如：

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

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

DialectKWArgs.argument_for（） 方法是按参数计算的方式向 DefaultDialect.construct_arguments 字典。此字典代表方言提供各种架构级构造接受的参数名称列表。

新方言通常应将此字典一次性指定为 dialect 类的数据成员。临时添加参数名称的用例通常用于最终用户代码，这些代码也使用使用额外参数的自定义编译方案。

参数

dialect_name¶ – 方言的名称。方言必须是可定位的，否则会引发 NoSuchModuleError 。这 dialect 还必须包含现有的 DefaultDialect.construct_arguments collection，表示它参与关键字参数验证和默认系统，否则会引发 ArgumentError。如果 dialect 不包含此集合，则已经可以代表此 dialect 指定任何 keyword 参数。SQLAlchemy 中打包的所有方言都包含此集合，但对于第三方方言，支持可能会有所不同。
argument_name¶ – 参数的名称。
default¶ – 参数的默认值。

属性 sqlalchemy.schema.CheckConstraint. 列：ReadOnlyColumnCollection[str， Column[Any]]¶: 继承自ColumnCollectionMixin 的 ColumnCollectionMixin.columns 属性

一个 ColumnCollection，表示此约束的列集。

方法 sqlalchemy.schema.CheckConstraint. contains_column（col： Column[Any]）→ bool¶

继承自 ColumnCollectionConstraint.contains_column() ColumnCollectionConstraint 的方法

如果此约束包含给定的列，则返回 True。

请注意，此对象还包含一个属性 .columns 它是 Column 对象。

方法 sqlalchemy.schema.CheckConstraint. copy（*， target_table：TableNone=None， **kw： Any）→ CheckConstraint¶: 1.4 版后已移除： CheckConstraint.copy（） 方法已弃用，并将在未来版本中删除。

方法 sqlalchemy.schema.CheckConstraint. ddl_if（dialect：strNone=None， callable_：DDLIfCallableNone=None， state：AnyNone=None）→ Self¶

继承自HasConditionalDDL 的 HasConditionalDDL.ddl_if（） 方法

将条件 DDL 规则应用于此架构项。

这些规则的工作方式与 ExecutableDDLElement.execute_if() callable，并添加了一个功能，即可以在 DDL 编译阶段检查结构（如 CreateTable）的条件。 HasConditionalDDL.ddl_if（） 当前应用于 索引结构以及所有 Constraint 构建。

参数

- dialect¶ - 方言的字符串名称，或字符串名称的元组，用于表示多种方言类型。
callable_¶ – 使用相同形式构建的可调用如 ExecutableDDLElement.execute_if.callable_ 。
state¶—— 任何将传递给 Callable 的任意对象（如果存在）。

2.0 版的新Function。

另请参阅

控制约束和索引的 DDL 生成 - 背景和使用示例

属性 sqlalchemy.schema.CheckConstraint. dialect_kwargs¶

继承自DialectKWArgs 的 DialectKWArgs.dialect_kwargs属性

指定为此构造的特定于方言的选项的关键字参数的集合。

这些论点以原始的 <dialect>_<kwarg> 显示格式。仅包含实际传递的参数; 与 DialectKWArgs.dialect_options 集合不同，后者包含此方言已知的所有选项，包括 defaults。

该集合也是可写的;接受 <dialect>_<kwarg> 形式的键，其中值将组合到选项列表中。

另请参阅

DialectKWArgs.dialect_options - 嵌套词典形式

属性 sqlalchemy.schema.CheckConstraint. dialect_options¶

继承自DialectKWArgs 的 DialectKWArgs.dialect_options属性

指定为此构造的特定于方言的选项的关键字参数的集合。

这是一个两级嵌套注册表，键为 <dialect_name> 和 <argument_name>。例如，postgresql_where 参数将定位为：

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

在 0.9.2 版本加入.

另请参阅

DialectKWArgs.dialect_kwargs - 平面词典形式

属性 sqlalchemy.schema.CheckConstraint. 信息¶

继承自SchemaItem 的 SchemaItem.info属性

与对象关联的 Info 字典，允许用户定义的数据与此 SchemaItem 相关联。

首次访问时，将自动生成该词典。也可以在某些对象的构造函数中指定它，例如 Table 和 Column。

属性 sqlalchemy.schema.CheckConstraint. kwargs¶: 继承自DialectKWArgs 的 DialectKWArgs.kwargs 属性

DialectKWArgs.dialect_kwargs 的同义词。

类 sqlalchemy.schema 中。ForeignKey 外键¶

定义两列之间的依赖关系。

ForeignKey 指定为 Column 的参数对象例如：

t = Table(
    "remote_table",
    metadata,
    Column("remote_id", ForeignKey("main_table.id")),
)

注意，ForeignKey 只是一个 marker 对象，它定义了两列之间的依赖关系。实际的约束在所有情况下都由 ForeignKeyConstraint 表示对象。此对象将在 一个 ForeignKey 与一个 Column 相关联，而 Column 又与 Table 相关联。相反，当 ForeignKeyConstraint 应用于 表、 ForeignKey 标记是自动生成的，它出现在每个关联的 Column 上，这些标记也与 constraint 对象相关联。

请注意，您不能使用 ForeignKey 对象定义“复合”外键约束，即多个父/子列分组之间的约束。要定义这个分组，必须使用 ForeignKeyConstraint 对象，并将其应用于 Table。关联的 ForeignKey 对象是自动创建的。

与个人关联的 ForeignKey 对象 列 object 在该列的 foreign_keys 集合中可用。

外键配置的更多示例在定义外键。

成员

__init__（）、argument_for（）、column、copy（）、dialect_kwargs、dialect_options、get_referent（）、info、kwargs、references（）target_fullname

类签名

类 sqlalchemy.schema.ForeignKey （ sqlalchemy.sql.base.DialectKWArgs ， sqlalchemy.schema.SchemaItem）

方法 sqlalchemy.schema.ForeignKey 中。__init__（列：_DDLColumnArgument，_constraint：ForeignKeyConstraintNone=None，use_alter：bool = False，名称：_ConstraintNameArgument = None， onupdate：strNone=None， ondelete：strNone=None， deferrable：boolNone=None， initially：strNone=None， link_to_name： bool = False， match：strNone=None， info：_InfoTypeNone=None， comment：strNone=None，_unresolvable： bool = False， **dialect_kw： Any）¶

构造列级 FOREIGN KEY。

构造 ForeignKey 对象时，会生成一个 ForeignKeyConstraint 的与父级关联 Table 对象的约束集合。

参数

column¶— 键关系的单个目标列。一个 列对象或列名作为字符串： tablename.columnkey 或 schema.tablename.columnKey 的 ColumnKey 进行检索。 columnkey 是已分配给列的键（默认为列名本身），除非 link_to_name True，在这种情况下，将使用列的呈现名称。
name¶- 可选字符串。如果 constraint 的 intent 值。
onupdate¶- 可选字符串。如果设置，则在为此约束发出 DDL 时发出 ON UPDATE。典型值包括 CASCADE、DELETE 和 RESTRICT。
ondelete¶– 可选字符串。如果设置，则在为此约束发出 DDL 时发出 ON DELETE。典型值包括 CASCADE、DELETE 和 RESTRICT。
deferrable¶ – 可选 bool。如果设置，则在为此约束发出 DDL 时发出 DEFERRABLE 或 NOT DEFERRABLE。
initially¶ – 可选字符串。如果设置，则在为此约束发出 DDL 时发出 INITIALLY 。
link_to_name¶ – 如果为 True，则 column 中给出的字符串名称是被引用列的渲染名称，而不是其本地分配的键。
use_alter¶ –

传递给底层 ForeignKeyConstraint 的来指示约束应从 CREATE TABLE/ DROP TABLE 外部生成/删除陈述。看 ForeignKeyConstraint.use_alter 以进一步说明。

另请参阅

ForeignKeyConstraint.use_alter

通过 ALTER 创建/删除外键约束
match¶- 可选字符串。如果设置，则在为此约束发出 DDL 时发出 MATCH。典型值包括 SIMPLE、PARTIAL 和 FULL。
info¶– 可选的数据字典，将被填充到 SchemaItem.info 对象的属性。
评论¶ –

可选字符串，将在创建外键约束时呈现 SQL 注释。

2.0 版的新Function。
**dialect_kw¶– 其他关键字参数特定于方言，并以 <dialectname>_<argname> 的形式传递。这参数最终由相应的 ForeignKeyConstraint 的 Constraint 对象。有关记录的参数的详细信息，请参阅 Dialects 中有关单个方言的文档。

类方法 sqlalchemy.schema.ForeignKey 中。argument_for（dialect_name， argument_name，默认）¶

继承自DialectKWArgs 的 DialectKWArgs.argument_for（） 方法

为此类添加一种新的特定于方言的关键字参数。

例如：

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

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

DialectKWArgs.argument_for（） 方法是按参数计算的方式向 DefaultDialect.construct_arguments 字典。此字典代表方言提供各种架构级构造接受的参数名称列表。

新方言通常应将此字典一次性指定为 dialect 类的数据成员。临时添加参数名称的用例通常用于最终用户代码，这些代码也使用使用额外参数的自定义编译方案。

参数

dialect_name¶ – 方言的名称。方言必须是可定位的，否则会引发 NoSuchModuleError 。这 dialect 还必须包含现有的 DefaultDialect.construct_arguments collection，表示它参与关键字参数验证和默认系统，否则会引发 ArgumentError。如果 dialect 不包含此集合，则已经可以代表此 dialect 指定任何 keyword 参数。SQLAlchemy 中打包的所有方言都包含此集合，但对于第三方方言，支持可能会有所不同。
argument_name¶ – 参数的名称。
default¶ – 参数的默认值。

属性 sqlalchemy.schema.ForeignKey 的 ForeignKey 中。列¶

返回此引用的目标 Column ForeignKey 的 ForeignKey 中。

如果未建立目标列，则会引发异常。

方法 sqlalchemy.schema.ForeignKey 中。copy（*， schema：strNone=None， **kw： Any）→ ForeignKey¶: 1.4 版后已移除： ForeignKey.copy（） 方法已被弃用，并将在未来版本中删除。

属性 sqlalchemy.schema.ForeignKey 的 ForeignKey 中。dialect_kwargs¶

继承自DialectKWArgs 的 DialectKWArgs.dialect_kwargs属性

指定为此构造的特定于方言的选项的关键字参数的集合。

这些论点以原始的 <dialect>_<kwarg> 显示格式。仅包含实际传递的参数; 与 DialectKWArgs.dialect_options 集合不同，后者包含此方言已知的所有选项，包括 defaults。

该集合也是可写的;接受 <dialect>_<kwarg> 形式的键，其中值将组合到选项列表中。

另请参阅

DialectKWArgs.dialect_options - 嵌套词典形式

属性 sqlalchemy.schema.ForeignKey 的 ForeignKey 中。dialect_options¶

继承自DialectKWArgs 的 DialectKWArgs.dialect_options属性

指定为此构造的特定于方言的选项的关键字参数的集合。

这是一个两级嵌套注册表，键为 <dialect_name> 和 <argument_name>。例如，postgresql_where 参数将定位为：

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

在 0.9.2 版本加入.

另请参阅

DialectKWArgs.dialect_kwargs - 平面词典形式

方法 sqlalchemy.schema.ForeignKey 中。get_referent（table： FromClause）→Column[Any]无¶

返回给定 Table （或任何 FromClause）引用的 ForeignKey 的 FromClause 中。

如果此 ForeignKey 返回 None 不引用给定的 表。

属性 sqlalchemy.schema.ForeignKey 的 ForeignKey 中。信息¶

继承自SchemaItem 的 SchemaItem.info属性

与对象关联的 Info 字典，允许用户定义的数据与此 SchemaItem 相关联。

首次访问时，将自动生成该词典。也可以在某些对象的构造函数中指定它，例如 Table 和 Column。

属性 sqlalchemy.schema.ForeignKey 的 ForeignKey 中。kwargs¶: 继承自DialectKWArgs 的 DialectKWArgs.kwargs 属性

DialectKWArgs.dialect_kwargs 的同义词。

方法 sqlalchemy.schema.ForeignKey 中。references（table： Table）→ bool¶: 如果给定的 Table 被 this 引用 ForeignKey 的 ForeignKey 中。

属性 sqlalchemy.schema.ForeignKey 的 ForeignKey 中。target_fullname¶

为此返回基于字符串的 'column specification' ForeignKey 的 ForeignKey 中。

这通常相当于首先传递给对象构造函数的基于字符串的 “tablename.colname” 参数。

类 sqlalchemy.schema 中。ForeignKeyConstraint 对象¶

表级 FOREIGN KEY 约束。

定义单个列或复合 FOREIGN KEY ...引用约束。对于简洁的单列外键，添加 ForeignKey 的 Column 定义是一个未命名的单列的简写等效项 ForeignKeyConstraint 的 Constraint 对象。

外键配置的示例在定义外键中。

成员

__init__（）、argument_for（）、column_keys、列、contains_column（）、copy（）、ddl_if（）、dialect_kwargs、dialect_options、元素、信息、kwargs referred_table

类签名

类 sqlalchemy.schema.ForeignKeyConstraint （ sqlalchemy.schema.ColumnCollectionConstraint ）

方法 sqlalchemy.schema.ForeignKeyConstraint. __init__（columns： _typing_Sequence[_DDLColumnArgument]， refcolumns： _typing_Sequence[_DDLColumnArgument]， name： _ConstraintNameArgument = None， onupdate：strNone=None， ondelete：strNone=None， deferrable：boolNone=None， initially：strNone=None， use_alter： bool = False，link_to_name： bool = False， match：strNone=None， table：TableNone=None， info：_InfoTypeNone=None， comment：strNone=None， **dialect_kw： Any）→ 无¶

构造支持复合的 FOREIGN KEY。

参数

columns¶- 本地列名序列。命名列必须定义并存在于父 Table 中。名称应与为每列提供的键匹配（默认为名称），除非 link_to_name 是真的。
refcolumns¶- 一系列外部列名或 Column 对象。这些列必须全部位于同一个 Table 中。
name¶— 可选，键的数据库内名称。
onupdate¶- 可选字符串。如果设置，则在为此约束发出 DDL 时发出 ON UPDATE。典型值包括 CASCADE、DELETE 和 RESTRICT。
ondelete¶– 可选字符串。如果设置，则在为此约束发出 DDL 时发出 ON DELETE。典型值包括 CASCADE、DELETE 和 RESTRICT。
deferrable¶ – 可选 bool。如果设置，则在为此约束发出 DDL 时发出 DEFERRABLE 或 NOT DEFERRABLE。
initially¶ – 可选字符串。如果设置，则在为此约束发出 DDL 时发出 INITIALLY 。
link_to_name¶ – 如果为 True，则列中给出的字符串名称为被引用列的呈现名称，而不是其本地分配的名称 键。
use_alter¶ –

如果为 True，则不要将此约束的 DDL 作为 CREATE TABLE 定义的一部分发出。相反，通过在创建完整表集合后发出的 ALTER TABLE 语句生成它，并在删除完整表集合之前通过 ALTER TABLE 语句删除它。

使用 of ForeignKeyConstraint.use_alter 特别适用于在相互依赖的外键约束关系中建立两个或多个表的情况;但是，MetaData.create_all（） 和 MetaData.drop_all（） 方法将执行此解析自动，因此通常不需要该标志。

另请参阅

通过 ALTER 创建/删除外键约束
match¶- 可选字符串。如果设置，则在为此约束发出 DDL 时发出 MATCH。典型值包括 SIMPLE、PARTIAL 和 FULL。
info¶– 可选的数据字典，将被填充到 SchemaItem.info 对象的属性。
评论¶ –

可选字符串，将在创建外键约束时呈现 SQL 注释。

2.0 版的新Function。
**dialect_kw¶– 其他关键字参数特定于方言，并以 <dialectname>_<argname> 的形式传递。看有关单个方言的文档，请访问 Dialects 了解记录在案的论点的详细信息。

类方法 sqlalchemy.schema.ForeignKeyConstraint. argument_for（dialect_name， argument_name， default）¶

继承自DialectKWArgs 的 DialectKWArgs.argument_for（） 方法

为此类添加一种新的特定于方言的关键字参数。

例如：

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

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

DialectKWArgs.argument_for（） 方法是按参数计算的方式向 DefaultDialect.construct_arguments 字典。此字典代表方言提供各种架构级构造接受的参数名称列表。

新方言通常应将此字典一次性指定为 dialect 类的数据成员。临时添加参数名称的用例通常用于最终用户代码，这些代码也使用使用额外参数的自定义编译方案。

参数

dialect_name¶ – 方言的名称。方言必须是可定位的，否则会引发 NoSuchModuleError 。这 dialect 还必须包含现有的 DefaultDialect.construct_arguments collection，表示它参与关键字参数验证和默认系统，否则会引发 ArgumentError。如果 dialect 不包含此集合，则已经可以代表此 dialect 指定任何 keyword 参数。SQLAlchemy 中打包的所有方言都包含此集合，但对于第三方方言，支持可能会有所不同。
argument_name¶ – 参数的名称。
default¶ – 参数的默认值。

属性 sqlalchemy.schema.ForeignKeyConstraint. column_keys¶

返回一个字符串键列表，这些键表示此 ForeignKeyConstraint 中的本地列。

这个列表要么是发送到 ForeignKeyConstraint 的构造函数的原始字符串参数，要么是 constraint 已经用 Column 初始化的 objects，是每个元素的字符串.key。

属性 sqlalchemy.schema.ForeignKeyConstraint. 列：ReadOnlyColumnCollection[str， Column[Any]]¶: 继承自ColumnCollectionMixin 的 ColumnCollectionMixin.columns 属性

一个 ColumnCollection，表示此约束的列集。

方法 sqlalchemy.schema.ForeignKeyConstraint. contains_column（col： Column[Any]）→ bool¶

继承自 ColumnCollectionConstraint.contains_column() ColumnCollectionConstraint 的方法

如果此约束包含给定的列，则返回 True。

请注意，此对象还包含一个属性 .columns 它是 Column 对象。

method sqlalchemy.schema.ForeignKeyConstraint. copy（*， schema：strNone=None， target_table：TableNone=None， **kw： Any）→ ForeignKeyConstraint¶: 1.4 版后已移除： ForeignKeyConstraint.copy（） 方法已被弃用，并将在未来版本中删除。

方法 sqlalchemy.schema.ForeignKeyConstraint. ddl_if（dialect：strNone=None， callable_：DDLIfCallableNone=None， state：AnyNone=None）→ Self¶

继承自HasConditionalDDL 的 HasConditionalDDL.ddl_if（） 方法

将条件 DDL 规则应用于此架构项。

这些规则的工作方式与 ExecutableDDLElement.execute_if() callable，并添加了一个功能，即可以在 DDL 编译阶段检查结构（如 CreateTable）的条件。 HasConditionalDDL.ddl_if（） 当前应用于 索引结构以及所有 Constraint 构建。

参数

- dialect¶ - 方言的字符串名称，或字符串名称的元组，用于表示多种方言类型。
callable_¶ – 使用相同形式构建的可调用如 ExecutableDDLElement.execute_if.callable_ 。
state¶—— 任何将传递给 Callable 的任意对象（如果存在）。

2.0 版的新Function。

另请参阅

控制约束和索引的 DDL 生成 - 背景和使用示例

属性 sqlalchemy.schema.ForeignKeyConstraint. dialect_kwargs¶

继承自DialectKWArgs 的 DialectKWArgs.dialect_kwargs属性

指定为此构造的特定于方言的选项的关键字参数的集合。

这些论点以原始的 <dialect>_<kwarg> 显示格式。仅包含实际传递的参数; 与 DialectKWArgs.dialect_options 集合不同，后者包含此方言已知的所有选项，包括 defaults。

该集合也是可写的;接受 <dialect>_<kwarg> 形式的键，其中值将组合到选项列表中。

另请参阅

DialectKWArgs.dialect_options - 嵌套词典形式

属性 sqlalchemy.schema.ForeignKeyConstraint. dialect_options¶

继承自DialectKWArgs 的 DialectKWArgs.dialect_options属性

指定为此构造的特定于方言的选项的关键字参数的集合。

这是一个两级嵌套注册表，键为 <dialect_name> 和 <argument_name>。例如，postgresql_where 参数将定位为：

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

在 0.9.2 版本加入.

另请参阅

DialectKWArgs.dialect_kwargs - 平面词典形式

attribute sqlalchemy.schema.ForeignKeyConstraint. elements： List[ForeignKey]¶

ForeignKey 对象的序列。

每个 ForeignKey 表示单个引用列/引用 column pair.

此集合旨在为只读。

属性 sqlalchemy.schema.ForeignKeyConstraint. 信息¶

继承自SchemaItem 的 SchemaItem.info属性

与对象关联的 Info 字典，允许用户定义的数据与此 SchemaItem 相关联。

首次访问时，将自动生成该词典。也可以在某些对象的构造函数中指定它，例如 Table 和 Column。

属性 sqlalchemy.schema.ForeignKeyConstraint. kwargs¶: 继承自DialectKWArgs 的 DialectKWArgs.kwargs 属性

DialectKWArgs.dialect_kwargs 的同义词。

属性 sqlalchemy.schema.ForeignKeyConstraint. referred_table¶

Table 对象，此 ForeignKeyConstraint 引用。

这是一个动态计算的属性，如果约束和/或父表尚未与包含引用表的元数据集合关联，则该属性可能不可用。

类 sqlalchemy.schema 中。HasConditionalDDL （具有条件的 DDL）¶

定义一个包含 HasConditionalDDL.ddl_if（） 的类方法，允许 DDL 的条件渲染。

当前适用于约束和索引。

成员

ddl_if（）

2.0 版的新Function。

方法 sqlalchemy.schema.HasConditionalDDL. ddl_if（dialect：strNone=None， callable_：DDLIfCallableNone=None， state：AnyNone=None）→ Self¶

将条件 DDL 规则应用于此架构项。

这些规则的工作方式与 ExecutableDDLElement.execute_if() callable，并添加了一个功能，即可以在 DDL 编译阶段检查结构（如 CreateTable）的条件。 HasConditionalDDL.ddl_if（） 当前应用于 索引结构以及所有 Constraint 构建。

参数

- dialect¶ - 方言的字符串名称，或字符串名称的元组，用于表示多种方言类型。
callable_¶ – 使用相同形式构建的可调用如 ExecutableDDLElement.execute_if.callable_ 。
state¶—— 任何将传递给 Callable 的任意对象（如果存在）。

2.0 版的新Function。

另请参阅

控制约束和索引的 DDL 生成 - 背景和使用示例

类 sqlalchemy.schema 中。PrimaryKeyConstraint 的

表级 PRIMARY KEY 约束。

PrimaryKeyConstraint 对象自动存在于任何 Table 对象上;它被分配了一组与标有 Column.primary_key 标志的列对象对应的 Column 对象：

>>> my_table = Table(
...     "mytable",
...     metadata,
...     Column("id", Integer, primary_key=True),
...     Column("version_id", Integer, primary_key=True),
...     Column("data", String(50)),
... )
>>> my_table.primary_key
PrimaryKeyConstraint(
    Column('id', Integer(), table=<mytable>,
           primary_key=True, nullable=False),
    Column('version_id', Integer(), table=<mytable>,
           primary_key=True, nullable=False)
)

Table 的主键也可以通过显式使用 PrimaryKeyConstraint 对象来指定;在这种使用模式下，还可以指定约束的 “name” ，以及方言可能识别的其他选项：

my_table = Table(
    "mytable",
    metadata,
    Column("id", Integer),
    Column("version_id", Integer),
    Column("data", String(50)),
    PrimaryKeyConstraint("id", "version_id", name="mytable_pk"),
)

column-specification 的两种样式通常不应混合使用。如果 PrimaryKeyConstraint 与标记为 primary_key=True 的列不匹配，如果两者兼而有之在场;在这种情况下，列严格取自 PrimaryKeyConstraint 声明，否则标记为 primary_key=True 的列将被忽略。此行为旨在与以前的行为向后兼容。

对于要在 PrimaryKeyConstraint 的 PrimaryKeyConstraint 方法，但通常的使用 primary_key=True 标志仍然是可取的，空的 PrimaryKeyConstraint 可以指定，它将根据标志从 Table 中获取主键列集合：

my_table = Table(
    "mytable",
    metadata,
    Column("id", Integer, primary_key=True),
    Column("version_id", Integer, primary_key=True),
    Column("data", String(50)),
    PrimaryKeyConstraint(name="mytable_pk", mssql_clustered=True),
)

成员

argument_for（），列， contains_column（）， copy（）， ddl_if （）， dialect_kwargs， dialect_options， info， kwargs

类签名

类 sqlalchemy.schema.PrimaryKeyConstraint （ sqlalchemy.schema.ColumnCollectionConstraint ）

类方法 sqlalchemy.schema.PrimaryKeyConstraint. argument_for（dialect_name， argument_name， default）¶

继承自DialectKWArgs 的 DialectKWArgs.argument_for（） 方法

为此类添加一种新的特定于方言的关键字参数。

例如：

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

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

DialectKWArgs.argument_for（） 方法是按参数计算的方式向 DefaultDialect.construct_arguments 字典。此字典代表方言提供各种架构级构造接受的参数名称列表。

新方言通常应将此字典一次性指定为 dialect 类的数据成员。临时添加参数名称的用例通常用于最终用户代码，这些代码也使用使用额外参数的自定义编译方案。

参数

dialect_name¶ – 方言的名称。方言必须是可定位的，否则会引发 NoSuchModuleError 。这 dialect 还必须包含现有的 DefaultDialect.construct_arguments collection，表示它参与关键字参数验证和默认系统，否则会引发 ArgumentError。如果 dialect 不包含此集合，则已经可以代表此 dialect 指定任何 keyword 参数。SQLAlchemy 中打包的所有方言都包含此集合，但对于第三方方言，支持可能会有所不同。
argument_name¶ – 参数的名称。
default¶ – 参数的默认值。

属性 sqlalchemy.schema.PrimaryKeyConstraint. 列：ReadOnlyColumnCollection[str， Column[Any]]¶: 继承自ColumnCollectionMixin 的 ColumnCollectionMixin.columns 属性

一个 ColumnCollection，表示此约束的列集。

方法 sqlalchemy.schema.PrimaryKeyConstraint. contains_column（col： Column[Any]）→ bool¶

继承自 ColumnCollectionConstraint.contains_column() ColumnCollectionConstraint 的方法

如果此约束包含给定的列，则返回 True。

请注意，此对象还包含一个属性 .columns 它是 Column 对象。

方法 sqlalchemy.schema.PrimaryKeyConstraint. copy（*， target_table：TableNone=None， **kw： Any）→ ColumnCollectionConstraint¶: 继承自 ColumnCollectionConstraint.copy() ColumnCollectionConstraint 的方法

1.4 版后已移除：该方法 ColumnCollectionConstraint.copy() 已弃用，并将在未来发行版中删除。

方法 sqlalchemy.schema.PrimaryKeyConstraint. ddl_if（dialect：strNone=None， callable_：DDLIfCallableNone=None， state：AnyNone=None）→ Self¶

继承自HasConditionalDDL 的 HasConditionalDDL.ddl_if（） 方法

将条件 DDL 规则应用于此架构项。

这些规则的工作方式与 ExecutableDDLElement.execute_if() callable，并添加了一个功能，即可以在 DDL 编译阶段检查结构（如 CreateTable）的条件。 HasConditionalDDL.ddl_if（） 当前应用于 索引结构以及所有 Constraint 构建。

参数

- dialect¶ - 方言的字符串名称，或字符串名称的元组，用于表示多种方言类型。
callable_¶ – 使用相同形式构建的可调用如 ExecutableDDLElement.execute_if.callable_ 。
state¶—— 任何将传递给 Callable 的任意对象（如果存在）。

2.0 版的新Function。

另请参阅

控制约束和索引的 DDL 生成 - 背景和使用示例

属性 sqlalchemy.schema.PrimaryKeyConstraint. dialect_kwargs¶

继承自DialectKWArgs 的 DialectKWArgs.dialect_kwargs属性

指定为此构造的特定于方言的选项的关键字参数的集合。

这些论点以原始的 <dialect>_<kwarg> 显示格式。仅包含实际传递的参数; 与 DialectKWArgs.dialect_options 集合不同，后者包含此方言已知的所有选项，包括 defaults。

该集合也是可写的;接受 <dialect>_<kwarg> 形式的键，其中值将组合到选项列表中。

另请参阅

DialectKWArgs.dialect_options - 嵌套词典形式

属性 sqlalchemy.schema.PrimaryKeyConstraint. dialect_options¶

继承自DialectKWArgs 的 DialectKWArgs.dialect_options属性

指定为此构造的特定于方言的选项的关键字参数的集合。

这是一个两级嵌套注册表，键为 <dialect_name> 和 <argument_name>。例如，postgresql_where 参数将定位为：

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

在 0.9.2 版本加入.

另请参阅

DialectKWArgs.dialect_kwargs - 平面词典形式

属性 sqlalchemy.schema.PrimaryKeyConstraint. 信息¶

继承自SchemaItem 的 SchemaItem.info属性

与对象关联的 Info 字典，允许用户定义的数据与此 SchemaItem 相关联。

首次访问时，将自动生成该词典。也可以在某些对象的构造函数中指定它，例如 Table 和 Column。

属性 sqlalchemy.schema.PrimaryKeyConstraint. kwargs¶: 继承自DialectKWArgs 的 DialectKWArgs.kwargs 属性

DialectKWArgs.dialect_kwargs 的同义词。

类 sqlalchemy.schema 中。UniqueConstraint 的实例¶

表级 UNIQUE 约束。

定义单个列或复合 UNIQUE 约束。对于简洁的单列约束，将 unique=True 添加到 Column definition 是未命名的单列的简写等价物 UniqueConstraint 的 UniqueConstraint 中。

成员

__init__（）， argument_for（），列， contains_column（）， copy（）， ddl_if（）， dialect_kwargs， dialect_options， info， kwargs

类签名

类 sqlalchemy.schema.UniqueConstraint （ sqlalchemy.schema.ColumnCollectionConstraint ）

method sqlalchemy.schema.UniqueConstraint. __init__（*columns： _DDLColumnArgument， name： _ConstraintNameArgument = None， deferrable：boolNone=None， initially：strNone=None， info：_InfoTypeNone=无，_autoattach：bool = True，_column_flag：bool = False，_gather_expressions：List[_DDLColumnArgument]None=无，**dialect_kw：任意）→ 无¶

继承自 sqlalchemy.schema.ColumnCollectionConstraint.__init__ ColumnCollectionConstraint 的方法

参数

columns¶—— 列名或 Column 对象的序列。
name¶— 可选，此约束的数据库内名称。
deferrable¶ – 可选 bool。如果设置，则在为此约束发出 DDL 时发出 DEFERRABLE 或 NOT DEFERRABLE。
initially¶ – 可选字符串。如果设置，则在为此约束发出 DDL 时发出 INITIALLY <value>。
dialect_kw¶——其他关键字参数，包括特定于方言的参数，被传播到 Constraint 超类。

类方法 sqlalchemy.schema.UniqueConstraint. argument_for（dialect_name， argument_name， default）¶

继承自DialectKWArgs 的 DialectKWArgs.argument_for（） 方法

为此类添加一种新的特定于方言的关键字参数。

例如：

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

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

DialectKWArgs.argument_for（） 方法是按参数计算的方式向 DefaultDialect.construct_arguments 字典。此字典代表方言提供各种架构级构造接受的参数名称列表。

新方言通常应将此字典一次性指定为 dialect 类的数据成员。临时添加参数名称的用例通常用于最终用户代码，这些代码也使用使用额外参数的自定义编译方案。

参数

dialect_name¶ – 方言的名称。方言必须是可定位的，否则会引发 NoSuchModuleError 。这 dialect 还必须包含现有的 DefaultDialect.construct_arguments collection，表示它参与关键字参数验证和默认系统，否则会引发 ArgumentError。如果 dialect 不包含此集合，则已经可以代表此 dialect 指定任何 keyword 参数。SQLAlchemy 中打包的所有方言都包含此集合，但对于第三方方言，支持可能会有所不同。
argument_name¶ – 参数的名称。
default¶ – 参数的默认值。

属性 sqlalchemy.schema.UniqueConstraint. 列：ReadOnlyColumnCollection[str， Column[Any]]¶: 继承自ColumnCollectionMixin 的 ColumnCollectionMixin.columns 属性

一个 ColumnCollection，表示此约束的列集。

方法 sqlalchemy.schema.UniqueConstraint. contains_column（col： Column[Any]）→ bool¶

继承自 ColumnCollectionConstraint.contains_column() ColumnCollectionConstraint 的方法

如果此约束包含给定的列，则返回 True。

请注意，此对象还包含一个属性 .columns 它是 Column 对象。

方法 sqlalchemy.schema.UniqueConstraint. copy（*， target_table：TableNone=None， **kw： Any）→ ColumnCollectionConstraint¶: 继承自 ColumnCollectionConstraint.copy() ColumnCollectionConstraint 的方法

1.4 版后已移除：该方法 ColumnCollectionConstraint.copy() 已弃用，并将在未来发行版中删除。

方法 sqlalchemy.schema.UniqueConstraint. ddl_if（dialect：strNone=None， callable_：DDLIfCallableNone=None， state：AnyNone=None）→ Self¶

继承自HasConditionalDDL 的 HasConditionalDDL.ddl_if（） 方法

将条件 DDL 规则应用于此架构项。

这些规则的工作方式与 ExecutableDDLElement.execute_if() callable，并添加了一个功能，即可以在 DDL 编译阶段检查结构（如 CreateTable）的条件。 HasConditionalDDL.ddl_if（） 当前应用于 索引结构以及所有 Constraint 构建。

参数

- dialect¶ - 方言的字符串名称，或字符串名称的元组，用于表示多种方言类型。
callable_¶ – 使用相同形式构建的可调用如 ExecutableDDLElement.execute_if.callable_ 。
state¶—— 任何将传递给 Callable 的任意对象（如果存在）。

2.0 版的新Function。

另请参阅

控制约束和索引的 DDL 生成 - 背景和使用示例

属性 sqlalchemy.schema.UniqueConstraint. dialect_kwargs¶

继承自DialectKWArgs 的 DialectKWArgs.dialect_kwargs属性

指定为此构造的特定于方言的选项的关键字参数的集合。

这些论点以原始的 <dialect>_<kwarg> 显示格式。仅包含实际传递的参数; 与 DialectKWArgs.dialect_options 集合不同，后者包含此方言已知的所有选项，包括 defaults。

该集合也是可写的;接受 <dialect>_<kwarg> 形式的键，其中值将组合到选项列表中。

另请参阅

DialectKWArgs.dialect_options - 嵌套词典形式

属性 sqlalchemy.schema.UniqueConstraint. dialect_options¶

继承自DialectKWArgs 的 DialectKWArgs.dialect_options属性

指定为此构造的特定于方言的选项的关键字参数的集合。

这是一个两级嵌套注册表，键为 <dialect_name> 和 <argument_name>。例如，postgresql_where 参数将定位为：

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

在 0.9.2 版本加入.

另请参阅

DialectKWArgs.dialect_kwargs - 平面词典形式

属性 sqlalchemy.schema.UniqueConstraint. 信息¶

继承自SchemaItem 的 SchemaItem.info属性

与对象关联的 Info 字典，允许用户定义的数据与此 SchemaItem 相关联。

首次访问时，将自动生成该词典。也可以在某些对象的构造函数中指定它，例如 Table 和 Column。

属性 sqlalchemy.schema.UniqueConstraint. kwargs¶: 继承自DialectKWArgs 的 DialectKWArgs.kwargs 属性

DialectKWArgs.dialect_kwargs 的同义词。

函数 sqlalchemy.schema。conv（value： str， quote：boolNone=None）→ 任意¶

标记一个字符串，指示名称已通过命名约定进行转换。

这是一个字符串子类，它表示不应受任何进一步命名约定约束的名称。

例如，当我们使用如下命名约定创建 Constraint 时：

m = MetaData(
    naming_convention={"ck": "ck_%(table_name)s_%(constraint_name)s"}
)
t = Table(
    "t", m, Column("x", Integer), CheckConstraint("x > 5", name="x5")
)

上述约束的名称将呈现为 “ck_t_x5”。也就是说，现有名称 x5 在命名约定中用作 constraint_name 令牌。

在某些情况下，例如在迁移脚本中，我们可能会使用已转换的名称来渲染上述 CheckConstraint。为了确保名称不被双重修改，使用 conv（） 标记应用新名称。我们可以按如下方式显式使用它：

m = MetaData(
    naming_convention={"ck": "ck_%(table_name)s_%(constraint_name)s"}
)
t = Table(
    "t",
    m,
    Column("x", Integer),
    CheckConstraint("x > 5", name=conv("ck_t_x5")),
)

在上面，conv（） 标记指示这里的约束名称是 final，并且该名称将呈现为 “ck_t_x5” 而不是 “ck_t_ck_t_x5”

另请参阅

配置约束命名约定

索引¶

可以匿名创建索引（使用自动生成的名称 ix_<column 标签>）对于单个列，请使用 inline index 关键字 on Column 的 Column，它还修改了 unique 将唯一性应用于索引本身，而不是添加单独的 UNIQUE 约束。对于具有特定名称或包含多个列的索引，请使用 Index 构造，该构造需要一个名称。

下面我们说明了一个包含几个 索引关联的对象。“CREATE INDEX” 的 DDL 在表的 create 语句之后立即发出：

metadata_obj=MetaData()mytable=Table("mytable",metadata_obj,# an indexed column, with index "ix_mytable_col1"Column("col1",Integer,index=True),# a uniquely indexed column with index "ix_mytable_col2"Column("col2",Integer,index=True,unique=True),Column("col3",Integer),Column("col4",Integer),Column("col5",Integer),Column("col6",Integer),)# place an index on col3, col4Index("idx_col34",mytable.c.col3,mytable.c.col4)# place a unique index on col5, col6Index("myindex",mytable.c.col5,mytable.c.col6,unique=True)mytable.create(engine)CREATE TABLE mytable (
    col1 INTEGER,
    col2 INTEGER,
    col3 INTEGER,
    col4 INTEGER,
    col5 INTEGER,
    col6 INTEGER
)
CREATE INDEX ix_mytable_col1 ON mytable (col1)
CREATE UNIQUE INDEX ix_mytable_col2 ON mytable (col2)
CREATE UNIQUE INDEX myindex ON mytable (col5, col6)
CREATE INDEX idx_col34 ON mytable (col3, col4)

请注意，在上面的示例中，Index 结构是使用 Column 在它对应的表的外部创建的对象。 Index 还支持 Table 内的 “inline” 定义，使用字符串名称来标识列：

metadata_obj = MetaData()
mytable = Table(
    "mytable",
    metadata_obj,
    Column("col1", Integer),
    Column("col2", Integer),
    Column("col3", Integer),
    Column("col4", Integer),
    # place an index on col1, col2
    Index("idx_col12", "col1", "col2"),
    # place a unique index on col3, col4
    Index("idx_col34", "col3", "col4", unique=True),
)

Index 对象还支持自己的 create（） 方法：

i=Index("someindex",mytable.c.col5)i.create(engine)CREATE INDEX someindex ON mytable (col5)

函数索引¶

Index 支持目标后端支持的 SQL 和函数表达式。要使用降序值创建针对列的索引，可以使用 ColumnElement.desc（） 修饰符：

from sqlalchemy import Index

Index("someindex", mytable.c.somecol.desc())

或者对于支持函数索引（如 PostgreSQL）的后端，可以使用 lower（） 函数创建“不区分大小写”的索引：

from sqlalchemy import func, Index

Index("someindex", func.lower(mytable.c.somecol))

索引 API¶

对象名称	描述
指数	表级 INDEX.

类 sqlalchemy.schema 中。索引¶

表级 INDEX.

定义复合（一列或多列）INDEX。

例如：

sometable = Table(
    "sometable",
    metadata,
    Column("name", String(50)),
    Column("address", String(100)),
)

Index("some_index", sometable.c.name)

对于简洁的单列索引，添加 Column 还支持 index=True：

sometable = Table(
    "sometable", metadata, Column("name", String(50), index=True)
)

对于组合索引，可以指定多个列：

Index("some_index", sometable.c.name, sometable.c.address)

还支持函数索引，通常通过使用 func 构造与 table-bound 结合使用 Column 对象：

Index("some_index", func.lower(sometable.c.name))

索引也可以手动与 表、通过内联声明或使用 Table.append_constraint（） 中。使用此方法时，可以将索引列的名称指定为字符串：

Table(
    "sometable",
    metadata,
    Column("name", String(50)),
    Column("address", String(100)),
    Index("some_index", "name", "address"),
)

要支持此形式的函数索引或基于表达式的索引， text（） 结构：

from sqlalchemy import text

Table(
    "sometable",
    metadata,
    Column("name", String(50)),
    Column("address", String(100)),
    Index("some_index", text("lower(name)")),
)

另请参阅

索引 - 有关索引的一般信息。

PostgreSQL 特定的索引选项 - 可用于索引构造的 PostgreSQL 特定选项。

MySQL / MariaDB 特定索引选项 - 可用于 Index 结构。

聚集索引支持 - 可用于 Index 结构。

成员

__init__（）， argument_for（）， create（）， ddl_if（）， dialect_kwargs， dialect_options， drop（）， info， kwargs

类签名

类 sqlalchemy.schema.Index （ sqlalchemy.sql.base.DialectKWArgs ， sqlalchemy.schema.ColumnCollectionMixin ， sqlalchemy.schema.HasConditionalDDL ， sqlalchemy.schema.SchemaItem）

方法 sqlalchemy.schema.Index 中。__init__（name：strNone， *expressions： _DDLColumnArgument， unique： bool = False， quote：boolNone=None， info：_InfoTypeNone=None， _table：TableNone=None， _column_flag： bool = False， **dialect_kw： Any）→ 无¶

构造索引对象。

参数

name¶– 索引的名称
expressions¶– 要包含在索引中的列表达式。表达式通常是 Column 的实例，但也可能是是任意 SQL 表达式，最终引用 列。
unique=False¶ - 仅关键字参数;如果为 True，则创建唯一索引。
quote=None¶- 仅关键字参数;是否对的名称应用引号索引。的工作方式与 Column.quote 的 Column.quote 中。
info=None¶– 可选的数据字典，将被填充到该对象的 SchemaItem.info 属性中。
**dialect_kw¶– 上面未提及的其他关键字参数特定于方言，并以 <dialectname>_<argname>.有关记录的参数的详细信息，请参阅 Dialects 中有关单个方言的文档。

类方法 sqlalchemy.schema.Index 中。argument_for（dialect_name， argument_name，默认）¶

继承自DialectKWArgs 的 DialectKWArgs.argument_for（） 方法

为此类添加一种新的特定于方言的关键字参数。

例如：

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

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

DialectKWArgs.argument_for（） 方法是按参数计算的方式向 DefaultDialect.construct_arguments 字典。此字典代表方言提供各种架构级构造接受的参数名称列表。

新方言通常应将此字典一次性指定为 dialect 类的数据成员。临时添加参数名称的用例通常用于最终用户代码，这些代码也使用使用额外参数的自定义编译方案。

参数

dialect_name¶ – 方言的名称。方言必须是可定位的，否则会引发 NoSuchModuleError 。这 dialect 还必须包含现有的 DefaultDialect.construct_arguments collection，表示它参与关键字参数验证和默认系统，否则会引发 ArgumentError。如果 dialect 不包含此集合，则已经可以代表此 dialect 指定任何 keyword 参数。SQLAlchemy 中打包的所有方言都包含此集合，但对于第三方方言，支持可能会有所不同。
argument_name¶ – 参数的名称。
default¶ – 参数的默认值。

方法 sqlalchemy.schema.Index 中。create（bind： _CreateDropBind， checkfirst： bool = False）→ 无¶: 为此发出 CREATE 语句 index，使用给定的 Connection 或 Engine' 用于连接。

另请参阅

MetaData.create_all（） 中。

方法 sqlalchemy.schema.Index 中。ddl_if（dialect：strNone=None， callable_：DDLIfCallableNone=None， state：AnyNone=None）→ 自我¶

继承自HasConditionalDDL 的 HasConditionalDDL.ddl_if（） 方法

将条件 DDL 规则应用于此架构项。

这些规则的工作方式与 ExecutableDDLElement.execute_if() callable，并添加了一个功能，即可以在 DDL 编译阶段检查结构（如 CreateTable）的条件。 HasConditionalDDL.ddl_if（） 当前应用于 索引结构以及所有 Constraint 构建。

参数

- dialect¶ - 方言的字符串名称，或字符串名称的元组，用于表示多种方言类型。
callable_¶ – 使用相同形式构建的可调用如 ExecutableDDLElement.execute_if.callable_ 。
state¶—— 任何将传递给 Callable 的任意对象（如果存在）。

2.0 版的新Function。

另请参阅

控制约束和索引的 DDL 生成 - 背景和使用示例

属性 sqlalchemy.schema.Index。dialect_kwargs¶

继承自DialectKWArgs 的 DialectKWArgs.dialect_kwargs属性

指定为此构造的特定于方言的选项的关键字参数的集合。

这些论点以原始的 <dialect>_<kwarg> 显示格式。仅包含实际传递的参数; 与 DialectKWArgs.dialect_options 集合不同，后者包含此方言已知的所有选项，包括 defaults。

该集合也是可写的;接受 <dialect>_<kwarg> 形式的键，其中值将组合到选项列表中。

另请参阅

DialectKWArgs.dialect_options - 嵌套词典形式

属性 sqlalchemy.schema.Index。dialect_options¶

继承自DialectKWArgs 的 DialectKWArgs.dialect_options属性

指定为此构造的特定于方言的选项的关键字参数的集合。

这是一个两级嵌套注册表，键为 <dialect_name> 和 <argument_name>。例如，postgresql_where 参数将定位为：

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

在 0.9.2 版本加入.

另请参阅

DialectKWArgs.dialect_kwargs - 平面词典形式

方法 sqlalchemy.schema.Index 中。drop（bind： _CreateDropBind， checkfirst： bool = False）→ 无¶: 为此发出 DROP 语句 index，使用给定的 Connection 或 Engine 用于连接。

另请参阅

MetaData.drop_all（） 中。

属性 sqlalchemy.schema.Index。信息¶

继承自SchemaItem 的 SchemaItem.info属性

与对象关联的 Info 字典，允许用户定义的数据与此 SchemaItem 相关联。

首次访问时，将自动生成该词典。也可以在某些对象的构造函数中指定它，例如 Table 和 Column。

属性 sqlalchemy.schema.Index。kwargs¶: 继承自DialectKWArgs 的 DialectKWArgs.kwargs 属性

DialectKWArgs.dialect_kwargs 的同义词。

SQLAlchemy 2.0 文档

SQLAlchemy 2.0 文档

SQLAlchemy 核心

定义约束和索引¶

定义外键¶

通过 ALTER 创建/删除外键约束¶

更新时和删除时¶

UNIQUE 约束¶

CHECK 约束¶

PRIMARY KEY 约束¶

使用声明式 ORM 扩展时设置 Constraints¶

配置 Constraint 命名约定¶

为 MetaData Collection 配置命名约定¶

默认命名约定¶

长名称的截断¶

为命名约定创建自定义令牌¶

命名 CHECK 约束¶

为 Boolean、Enum 和其他 schema 类型配置命名¶

在 ORM 声明式 mixin 中使用命名约定¶

约束 API¶

索引¶

函数索引¶

索引 API¶