定义约束和索引¶

本节将讨论SQL constraints 和指标。在SQLAlchemy中，键类包括 ForeignKeyConstraint 和 Index .

定义外键¶

A 外键在SQL中是一个表级构造，它约束该表中的一个或多个列，使其只允许存在于不同的列集中的值，通常但不总是位于不同的表中。我们称之为约束外键列和它们被约束到的列 引用的 柱。被引用的列几乎总是为其所属表定义主键，尽管有例外。外键是连接成对行的“关节”，这些行彼此之间具有关系，而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 表的 user_id 列。

论点 ForeignKey 通常是窗体的字符串 <tablename>.<columnname> 或远程架构中的表或表单的“所有者” <schemaname>.<tablename>.<columnname> . 它也可能是一个实际的 Column 对象，稍后我们将看到，它是从现有的 Table 对象通过其 c 收藏：

ForeignKey(user.c.user_id)

使用字符串的优势在于 user 和 user_preference 只有在第一次需要时才解析，这样表对象就可以轻松地分布在多个模块中并以任意顺序定义。

也可以在表级别定义外键，使用 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 ：：

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语句中呈现为“inline”，例如：

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 指令用于在创建表定义中以“内联”方式创建约束。这个 MetaData.create_all() 和 MetaData.drop_all() 默认情况下，方法会使用拓扑类型 Table 所涉及的对象，以便按照表的外键依赖性的顺序创建和删除表（也可以通过 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'
    )
)

当我们召唤 MetaData.create_all() 在PostgreSQL后端等后端，解决这两个表之间的循环，并分别创建约束：

>>> 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约束，需要该约束有一个名称。在这种情况下 'node' 上表中，我们没有命名这个约束；因此，系统将尝试只为那些命名为：

>>> 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

在无法解决循环的情况下，例如，如果我们没有在此处对任一约束应用名称，我们将收到以下错误：：

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.

此错误仅适用于放置案例，因为我们可以在不带名称的创建案例中发出“添加约束”；数据库通常会自动分配一个。

这个 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语句，而不会看到另一个约束：

>>> 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

在 1.0.0 版更改: -由调用的DDL系统 MetaData.create_all() 和 MetaData.drop_all() 现在将自动解析由声明的表之间的相互依赖的外键 ForeignKeyConstraint 和 ForeignKey 对象，无需显式设置 ForeignKeyConstraint.use_alter 旗帜。

在 1.0.0 版更改: - The ForeignKeyConstraint.use_alter flag can be used with an un-named constraint; only the DROP operation will emit a specific error when actually called upon.

参见

配置约束命名约定

sort_tables_and_constraints()

更新和删除时¶

大多数数据库支持级联在外键值中，即当更新父行时，新值将放置在子行中，或者当删除父行时，所有相应的子行都将设置为空或已删除。在数据定义语言中，使用与外键约束相对应的短语（如“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"
    )
)

请注意，这些条款要求 InnoDB 与MySQL一起使用时的表。其他数据库也可能不支持它们。

参见

关于 ON DELETE CASCADE 使用ORM relationship() 构件，请参见以下章节：

在具有ORM关系的DELETE cascade中使用外键

对多对多关系在DELETE上使用外键

唯一约束¶

可以使用在单个列上匿名创建唯一约束 unique 关键字在 Column . 显式命名的唯一约束和/或具有多个列的约束是通过 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')
    )

检查约束¶

检查约束可以命名或未命名，也可以在列或表级别使用 CheckConstraint 构建。检查约束的文本直接传递给数据库，因此存在有限的“与数据库无关”行为。列级检查约束通常只应引用放置它们的列，而表级约束可以引用表中的任何列。

注意，有些数据库不主动支持检查约束，比如mysql。

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'))sqlmytable.create(engine)CREATE TABLE mytable (
    col1 INTEGER  CHECK (col1>5),
    col2 INTEGER,
    col3 INTEGER,
    CONSTRAINT check1  CHECK (col2 > col3 + 5)
)

主键约束¶

任何 Table 对象隐式存在，基于 Column 用标记的对象 Column.primary_key 旗帜。这个 PrimaryKeyConstraint 对象提供对该约束的显式访问，其中包括直接配置的选项：

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扩展时设置约束¶

这个 Table 是允许定义表元数据的sqlAlchemy核心构造，其中，sqlAlchemy orm可以使用这些元数据作为映射类的目标。这个 Declarative 扩展允许 Table 将自动创建的对象，假定表的内容主要作为 Column 物体。

应用表级约束对象，例如 ForeignKeyConstraint 对于使用声明性定义的表，使用 __table_args__ 属性，描述于表配置 .

配置约束命名约定¶

关系数据库通常为所有约束和索引指定显式名称。在创建表的常见情况下，使用 CREATE TABLE 如果在表定义中生成诸如check、unique和primary key约束之类的约束，则数据库通常有一个系统，在该系统中，如果没有另外指定名称，则会自动将名称分配给这些约束。当使用诸如 ALTER TABLE ，此命令通常需要为新约束指定显式名称，并且能够指定要删除或修改的现有约束的名称。

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

修改现有表和约束的用例可以由模式迁移工具处理，例如 Alembic . 但是，alembic和sqlacalchemy目前都没有为未指定名称的约束对象创建名称，这导致了能够更改现有约束意味着必须对关系数据库使用的命名系统进行反向工程以自动分配名称，或者必须注意确保约束已命名。

与必须给所有人指定明确的名字不同 Constraint 和 Index 对象，可以使用事件构造自动命名方案。这种方法的优点是，约束将获得一致的命名方案，而不需要在整个代码中使用显式的名称参数，而且对于由 Column.unique 和 Column.index 参数。从SQLAlchemy 0.9.2开始，此基于事件的方法包括在内，并且可以使用参数进行配置 MetaData.naming_convention .

配置元数据集合的命名约定¶

MetaData.naming_convention 指接受 Index 阶级或个人 Constraint 类作为键，python字符串模板作为值。它还接受一系列字符串代码作为可选键， "fk" ， "pk" ， "ix" ， "ck" ， "uq" 分别用于外键、主键、索引、检查和唯一约束。每当约束或索引与此关联时，将使用此字典中的字符串模板 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 收集。例如，我们可以观察创建未命名的 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)s ， %(referred_table_name)s ， %(column_0_name)s ， %(column_0_label)s ， %(column_0_key)s ， %(referred_column_0_name)s 和 %(constraint_name)s 以及每个的多个列版本，包括 %(column_0N_name)s ， %(column_0_N_name)s ， %(referred_column_0_N_name)s 它呈现所有用下划线或不带下划线分隔的列名。文件 MetaData.naming_convention 对每一个约定都有进一步的详细说明。

默认命名约定¶

的默认值 MetaData.naming_convention 处理将名称分配给 Index 使用创建的对象 Column.index 参数：：

>>> 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哈希，每次都将生成相同的值，以为给定架构生成一致的名称。

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

也可以通过在命名约定字典中指定附加令牌和可调用的来添加新令牌。例如，如果我们想使用一个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 -有关其他用法的详细信息以及所有可用命名组件的列表。

The Importance of Naming Constraints -在Alembic文档中。

1.3.0 新版功能: 添加了多列命名标记，如 %(column_0_N_name)s . 如果生成的名称超出了目标数据库的字符限制，则将被确定地截断。

命名检查约束¶

这个 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)s 令牌；我们可以通过确保使用 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)
)

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

1.0.0 新版功能: 这个 CheckConstraint 对象现在支持 column_0_name 命名约定令牌。

为布尔、枚举和其他架构类型配置命名¶

这个 SchemaType 类引用类型对象，例如 Boolean 和 Enum 它会生成一个伴随类型的检查约束。这里的约束名称最直接的设置方式是发送“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 不需要；我们可以安全地设置 Boolean 不带名称的类型，即使检查约束有命名约定。只有当我们对一个没有本机布尔类型（如sqlite或mysql）的数据库运行时，才会对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())
)

上述模式将产生：

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

在 1.0 版更改: 不包括的约束命名约定 %(constraint_name)s 再次工作 SchemaType 约束条件。

约束API¶

Object Name	Description
CheckConstraint	表级或列级检查约束。
ColumnCollectionConstraint	代理ColumnCollection的约束。
ColumnCollectionMixin
Constraint	表级SQL约束。
conv	标记一个字符串，指示名称已由命名约定转换。
ForeignKey	定义两列之间的依赖关系。
ForeignKeyConstraint	表级外键约束。
PrimaryKeyConstraint	表级主键约束。
UniqueConstraint	表级唯一约束。

class sqlalchemy.schema.Constraint(name=None, deferrable=None, initially=None, _create_rule=None, info=None, _type_bound=False, **dialect_kw)¶

表级SQL约束。

Constraint 用作可与关联的一系列约束对象的基类 Table 对象，包括 PrimaryKeyConstraint ， ForeignKeyConstraint UniqueConstraint 和 CheckConstraint .

类签名

class sqlalchemy.schema.Constraint (sqlalchemy.sql.base.DialectKWArgs, sqlalchemy.schema.SchemaItem)

method sqlalchemy.schema.Constraint.__init__(name=None, deferrable=None, initially=None, _create_rule=None, info=None, _type_bound=False, **dialect_kw)¶

创建SQL约束。

参数

name¶ -- 可选，此数据库中的名称 Constraint .
deferrable¶ -- 可选布尔值。如果设置了，则在为该约束发出DDL时发出“可延迟”或“不可延迟”。
initially¶ -- 可选字符串。如果已设置，则在为此约束发出DDL时最初发出<value>。
info¶ -- 可选数据字典，将填充到 SchemaItem.info 此对象的属性。…添加的版本：1.0.0
**dialect_kw¶ -- 其他关键字参数是特定于方言的，并以形式传递 <dialectname>_<argname> . 有关单个方言的文档，请参见方言有关文档化参数的详细信息。
_create_rule¶ -- 在某些数据类型内部使用，这些数据类型也创建了约束。
_type_bound¶ -- 在内部用于指示此约束与特定数据类型关联。

method sqlalchemy.schema.Constraint.copy(**kw)¶: 1.4 版后已移除: 这个 Constraint.copy() 方法已弃用，并将在将来的版本中删除。

class sqlalchemy.schema.ColumnCollectionMixin(*columns, **kw)¶

attribute sqlalchemy.schema.ColumnCollectionMixin.columns = None¶

A ColumnCollection 属于 Column 物体。

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

class sqlalchemy.schema.ColumnCollectionConstraint(*columns, **kw)¶

代理ColumnCollection的约束。

类签名

class sqlalchemy.schema.ColumnCollectionConstraint (sqlalchemy.schema.ColumnCollectionMixin, sqlalchemy.schema.Constraint)

method sqlalchemy.schema.ColumnCollectionConstraint.__init__(*columns, **kw)¶

参数

*columns¶ -- 列名或列对象的序列。
name¶ -- 可选，此约束的数据库内名称。
deferrable¶ -- 可选布尔值。如果设置了，则在为该约束发出DDL时发出“可延迟”或“不可延迟”。
initially¶ -- 可选字符串。如果已设置，则在为此约束发出DDL时最初发出<value>。
**kw¶ -- 包括方言特定参数在内的其他关键字参数将传播到 Constraint 超类。

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

inherited from the DialectKWArgs.argument_for() method of DialectKWArgs

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

例如。：：

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

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

这个 DialectKWArgs.argument_for() 方法是按参数向 DefaultDialect.construct_arguments 字典。此字典提供了各种模式级构造代表方言接受的参数名列表。

新方言通常应同时将此字典指定为方言类的数据成员。临时添加参数名的用例通常用于最终用户代码，该代码也使用自定义编译方案，该方案使用附加参数。

参数

dialect_name¶ -- 方言的名称。方言必须可定位，否则 NoSuchModuleError 提高了。方言还必须包括现有的 DefaultDialect.construct_arguments 集合，指示它参与关键字参数验证和默认系统，否则 ArgumentError 提高了。如果方言不包含此集合，则可以代表此方言指定任何关键字参数。包含在sqlAlchemy中的所有方言都包含此集合，但是对于第三方方言，支持可能有所不同。
argument_name¶ -- 参数的名称。
default¶ -- 参数的默认值。

0.9.4 新版功能.

attribute sqlalchemy.schema.ColumnCollectionConstraint.columns = None¶: A ColumnCollection 表示此约束的列集。

method sqlalchemy.schema.ColumnCollectionConstraint.contains_column(col)¶

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

请注意，此对象还包含一个属性 .columns 哪个是 ColumnCollection 属于 Column 物体。

method sqlalchemy.schema.ColumnCollectionConstraint.copy(target_table=None, **kw)¶: 1.4 版后已移除: 这个 ColumnCollectionConstraint.copy() 方法已弃用，并将在将来的版本中删除。

attribute sqlalchemy.schema.ColumnCollectionConstraint.dialect_kwargs¶

inherited from the DialectKWArgs.dialect_kwargs attribute of DialectKWArgs

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

这些论据以原版呈现在这里。 <dialect>_<kwarg> 格式。只包括实际传递的参数；与 DialectKWArgs.dialect_options 集合，其中包含此方言已知的所有选项，包括默认值。

集合也是可写的；接受窗体的键 <dialect>_<kwarg> 值将组合到选项列表中。

0.9.2 新版功能.

在 0.9.4 版更改: 这个 DialectKWArgs.dialect_kwargs 集合现在可写。

参见

DialectKWArgs.dialect_options -嵌套字典窗体

attribute sqlalchemy.schema.ColumnCollectionConstraint.dialect_options¶

inherited from the DialectKWArgs.dialect_options attribute of DialectKWArgs

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

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

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

0.9.2 新版功能.

参见

DialectKWArgs.dialect_kwargs -平字典形式

method sqlalchemy.schema.ColumnCollectionConstraint.get_children(omit_attrs=(), **kw)¶

inherited from the Traversible.get_children() method of Traversible

返回直接子对象 Traversible 这其中的要素 Traversible 。

这用于访问遍历。

**kw可能包含更改返回的集合的标志，例如，返回项的子集以减少更大的遍历，或者从不同的上下文返回子项(例如模式级集合而不是子句级集合)。

attribute sqlalchemy.schema.ColumnCollectionConstraint.info¶

inherited from the SchemaItem.info attribute of SchemaItem

与对象关联的信息字典，允许用户定义的数据与此关联 SchemaItem .

字典在第一次访问时自动生成。它也可以在一些对象的构造函数中指定，例如 Table 和 Column .

attribute sqlalchemy.schema.ColumnCollectionConstraint.kwargs¶: inherited from the DialectKWArgs.kwargs attribute of DialectKWArgs

同义词 DialectKWArgs.dialect_kwargs .

class sqlalchemy.schema.CheckConstraint(sqltext, name=None, deferrable=None, initially=None, table=None, info=None, _create_rule=None, _autoattach=True, _type_bound=False, **kw)¶

表级或列级检查约束。

可以包含在表或列的定义中。

类签名

class sqlalchemy.schema.CheckConstraint (sqlalchemy.schema.ColumnCollectionConstraint)

method sqlalchemy.schema.CheckConstraint.__init__(sqltext, name=None, deferrable=None, initially=None, table=None, info=None, _create_rule=None, _autoattach=True, _type_bound=False, **kw)¶

构造检查约束。

参数

sqltext¶ -- 包含约束定义（将按原样使用）的字符串或SQL表达式构造。如果以字符串形式给出，则对象将转换为 text() 对象。如果文本字符串包含冒号字符，请使用反斜杠：：checkConstraint（r“foo~e'a（？）来转义它。b：c）d）。警告：： CheckConstraint.sqltext 参数 CheckConstraint 可以作为python字符串参数传递，该参数将被视为 可信SQL文本 并按规定呈现。 不要将不受信任的输入传递给此参数 .
name¶ -- 可选，约束的数据库内名称。
deferrable¶ -- 可选布尔值。如果设置了，则在为该约束发出DDL时发出“可延迟”或“不可延迟”。
initially¶ -- 可选字符串。如果已设置，则在为此约束发出DDL时最初发出<value>。
info¶ -- 可选数据字典，将填充到 SchemaItem.info 此对象的属性。…添加的版本：1.0.0

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

inherited from the DialectKWArgs.argument_for() method of DialectKWArgs

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

例如。：：

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

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

这个 DialectKWArgs.argument_for() 方法是按参数向 DefaultDialect.construct_arguments 字典。此字典提供了各种模式级构造代表方言接受的参数名列表。

参数

dialect_name¶ -- 方言的名称。方言必须可定位，否则 NoSuchModuleError 提高了。方言还必须包括现有的 DefaultDialect.construct_arguments 集合，指示它参与关键字参数验证和默认系统，否则 ArgumentError 提高了。如果方言不包含此集合，则可以代表此方言指定任何关键字参数。包含在sqlAlchemy中的所有方言都包含此集合，但是对于第三方方言，支持可能有所不同。
argument_name¶ -- 参数的名称。
default¶ -- 参数的默认值。

0.9.4 新版功能.

method sqlalchemy.schema.CheckConstraint.contains_column(col)¶

inherited from the ColumnCollectionConstraint.contains_column() method of ColumnCollectionConstraint

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

请注意，此对象还包含一个属性 .columns 哪个是 ColumnCollection 属于 Column 物体。

method sqlalchemy.schema.CheckConstraint.copy(target_table=None, **kw)¶: 1.4 版后已移除: 这个 CheckConstraint.copy() 方法已弃用，并将在将来的版本中删除。

attribute sqlalchemy.schema.CheckConstraint.dialect_kwargs¶

inherited from the DialectKWArgs.dialect_kwargs attribute of DialectKWArgs

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

集合也是可写的；接受窗体的键 <dialect>_<kwarg> 值将组合到选项列表中。

0.9.2 新版功能.

在 0.9.4 版更改: 这个 DialectKWArgs.dialect_kwargs 集合现在可写。

参见

DialectKWArgs.dialect_options -嵌套字典窗体

attribute sqlalchemy.schema.CheckConstraint.dialect_options¶

inherited from the DialectKWArgs.dialect_options attribute of DialectKWArgs

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

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

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

0.9.2 新版功能.

参见

DialectKWArgs.dialect_kwargs -平字典形式

method sqlalchemy.schema.CheckConstraint.get_children(omit_attrs=(), **kw)¶

inherited from the Traversible.get_children() method of Traversible

返回直接子对象 Traversible 这其中的要素 Traversible 。

这用于访问遍历。

**kw可能包含更改返回的集合的标志，例如，返回项的子集以减少更大的遍历，或者从不同的上下文返回子项(例如模式级集合而不是子句级集合)。

attribute sqlalchemy.schema.CheckConstraint.info¶

inherited from the SchemaItem.info attribute of SchemaItem

与对象关联的信息字典，允许用户定义的数据与此关联 SchemaItem .

字典在第一次访问时自动生成。它也可以在一些对象的构造函数中指定，例如 Table 和 Column .

attribute sqlalchemy.schema.CheckConstraint.kwargs¶: inherited from the DialectKWArgs.kwargs attribute of DialectKWArgs

同义词 DialectKWArgs.dialect_kwargs .

class sqlalchemy.schema.ForeignKey(column, _constraint=None, use_alter=False, name=None, onupdate=None, ondelete=None, deferrable=None, initially=None, link_to_name=False, match=None, info=None, **dialect_kw)¶

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

ForeignKey 被指定为 Column 对象，例如：

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

注意 ForeignKey 仅是定义两列之间依赖关系的标记对象。实际约束在所有情况下都由 ForeignKeyConstraint 对象。当 ForeignKey 与 Column 反过来又与 Table . 相反，当 ForeignKeyConstraint 应用于 Table ， ForeignKey 自动生成标记，以显示在每个关联的 Column ，也与约束对象关联。

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

这个 ForeignKey 与单个对象关联的对象 Column 对象在中可用 foreign_keys 该列的集合。

外键配置的其他示例在定义外键 .

类签名

class sqlalchemy.schema.ForeignKey (sqlalchemy.sql.base.DialectKWArgs, sqlalchemy.schema.SchemaItem)

method sqlalchemy.schema.ForeignKey.__init__(column, _constraint=None, use_alter=False, name=None, onupdate=None, ondelete=None, deferrable=None, initially=None, link_to_name=False, match=None, info=None, **dialect_kw)¶

构造列级外键。

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

参数

column¶ -- 键关系的单个目标列。一 Column 对象或列名称作为字符串： tablename.columnkey 或 schema.tablename.columnkey . columnkey 是 key 已分配给列（默认为列名称本身），除非 link_to_name 是 True 在这种情况下，将使用列的呈现名称。
name¶ -- 可选字符串。键的数据库内名称if constraint 未提供。
onupdate¶ -- 可选字符串。如果设置，则在为该约束发出DDL时在更新时发出。典型值包括层叠、删除和限制。
ondelete¶ -- 可选字符串。如果设置了，则在为该约束发出DDL时在删除时发出。典型值包括层叠、删除和限制。
deferrable¶ -- 可选的布尔。如果设置了，则在为该约束发出DDL时发出“可延迟”或“不可延迟”。
initially¶ -- 可选字符串。如果已设置，则在为此约束发出DDL时最初发出<value>。
link_to_name¶ -- 如果为true，则返回 column 是被引用列的呈现名称，而不是其本地分配的名称 key .
use_alter¶ --
传递给基础 ForeignKeyConstraint 指示约束应该从create table/drop table语句外部生成/删除。见 ForeignKeyConstraint.use_alter 进一步说明。

参见

ForeignKeyConstraint.use_alter

通过alter创建/删除外键约束
match¶ -- 可选字符串。如果已设置，则在为此约束发出DDL时发出match<value>。典型值包括简单值、部分值和完整值。
info¶ -- 可选数据字典，将填充到 SchemaItem.info 此对象的属性。…添加的版本：1.0.0
**dialect_kw¶ -- 其他关键字参数是特定于方言的，并以形式传递 <dialectname>_<argname> . 这些参数最终由相应的 ForeignKeyConstraint . 有关单个方言的文档，请参见方言有关文档化参数的详细信息。…添加的版本：0.9.2

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

inherited from the DialectKWArgs.argument_for() method of DialectKWArgs

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

例如。：：

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

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

这个 DialectKWArgs.argument_for() 方法是按参数向 DefaultDialect.construct_arguments 字典。此字典提供了各种模式级构造代表方言接受的参数名列表。

参数

dialect_name¶ -- 方言的名称。方言必须可定位，否则 NoSuchModuleError 提高了。方言还必须包括现有的 DefaultDialect.construct_arguments 集合，指示它参与关键字参数验证和默认系统，否则 ArgumentError 提高了。如果方言不包含此集合，则可以代表此方言指定任何关键字参数。包含在sqlAlchemy中的所有方言都包含此集合，但是对于第三方方言，支持可能有所不同。
argument_name¶ -- 参数的名称。
default¶ -- 参数的默认值。

0.9.4 新版功能.

attribute sqlalchemy.schema.ForeignKey.column¶

返回目标 Column 引用人： ForeignKey .

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

在 0.9.0 版更改: 当foreign key对象和它引用的远程列都与同一元数据对象关联时，将立即发生外键目标列解析。

method sqlalchemy.schema.ForeignKey.copy(schema=None, **kw)¶: 1.4 版后已移除: 这个 ForeignKey.copy() 方法已弃用，并将在将来的版本中删除。

attribute sqlalchemy.schema.ForeignKey.dialect_kwargs¶

inherited from the DialectKWArgs.dialect_kwargs attribute of DialectKWArgs

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

集合也是可写的；接受窗体的键 <dialect>_<kwarg> 值将组合到选项列表中。

0.9.2 新版功能.

在 0.9.4 版更改: 这个 DialectKWArgs.dialect_kwargs 集合现在可写。

参见

DialectKWArgs.dialect_options -嵌套字典窗体

attribute sqlalchemy.schema.ForeignKey.dialect_options¶

inherited from the DialectKWArgs.dialect_options attribute of DialectKWArgs

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

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

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

0.9.2 新版功能.

参见

DialectKWArgs.dialect_kwargs -平字典形式

method sqlalchemy.schema.ForeignKey.get_children(omit_attrs=(), **kw)¶

inherited from the Traversible.get_children() method of Traversible

返回直接子对象 Traversible 这其中的要素 Traversible 。

这用于访问遍历。

**kw可能包含更改返回的集合的标志，例如，返回项的子集以减少更大的遍历，或者从不同的上下文返回子项(例如模式级集合而不是子句级集合)。

method sqlalchemy.schema.ForeignKey.get_referent(table)¶

返回 Column 在给定的 Table 引用人： ForeignKey .

如果这样，则返回“无” ForeignKey 不引用给定的 Table .

attribute sqlalchemy.schema.ForeignKey.info¶

inherited from the SchemaItem.info attribute of SchemaItem

与对象关联的信息字典，允许用户定义的数据与此关联 SchemaItem .

字典在第一次访问时自动生成。它也可以在一些对象的构造函数中指定，例如 Table 和 Column .

attribute sqlalchemy.schema.ForeignKey.kwargs¶: inherited from the DialectKWArgs.kwargs attribute of DialectKWArgs

同义词 DialectKWArgs.dialect_kwargs .

method sqlalchemy.schema.ForeignKey.references(table)¶: 如果给定 Table 被此引用 ForeignKey .

attribute sqlalchemy.schema.ForeignKey.target_fullname¶

为此返回基于字符串的“列规范” ForeignKey .

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

class sqlalchemy.schema.ForeignKeyConstraint(columns, refcolumns, name=None, onupdate=None, ondelete=None, deferrable=None, initially=None, use_alter=False, link_to_name=False, match=None, table=None, info=None, **dialect_kw)¶

表级外键约束。

定义单列或复合外键…引用约束。对于无虚饰、单列外键，添加 ForeignKey 到a的定义 Column 是对未命名的单列的简写等价物 ForeignKeyConstraint .

外键配置的示例在定义外键 .

类签名

class sqlalchemy.schema.ForeignKeyConstraint (sqlalchemy.schema.ColumnCollectionConstraint)

method sqlalchemy.schema.ForeignKeyConstraint.__init__(columns, refcolumns, name=None, onupdate=None, ondelete=None, deferrable=None, initially=None, use_alter=False, link_to_name=False, match=None, table=None, info=None, **dialect_kw)¶

构造一个具有复合功能的外键。

参数

columns¶ -- 本地列名的序列。必须在父表中定义和显示命名列。名称应与 key 指定给每列（默认为名称），除非 link_to_name 是True。
refcolumns¶ -- 外部列名或列对象的序列。所有列都必须位于同一个表中。
name¶ -- 可选，键在数据库中的名称。
onupdate¶ -- 可选字符串。如果设置，则在为该约束发出DDL时在更新时发出。典型值包括层叠、删除和限制。
ondelete¶ -- 可选字符串。如果设置了，则在为该约束发出DDL时在删除时发出。典型值包括层叠、删除和限制。
deferrable¶ -- 可选的布尔。如果设置了，则在为该约束发出DDL时发出“可延迟”或“不可延迟”。
initially¶ -- 可选字符串。如果已设置，则在为此约束发出DDL时最初发出<value>。
link_to_name¶ -- 如果为true，则返回 column 是被引用列的呈现名称，而不是其本地分配的名称 key .
use_alter¶ -- 如果为true，则不要将此约束的DDL作为创建表定义的一部分发出。相反，通过在创建表的完整集合之后发出的alter table语句生成它，并在删除表的完整集合之前通过alter table语句删除它。使用 ForeignKeyConstraint.use_alter 特别适合于在相互依赖的外键约束关系中建立两个或多个表的情况；但是， MetaData.create_all() 和 MetaData.drop_all() 方法将自动执行此解析，因此通常不需要标记。…versionChanged:添加了1.0.0自动解析外键循环，消除了使用 ForeignKeyConstraint.use_alter 在典型的用例中。…参阅：通过alter创建/删除外键约束
match¶ -- 可选字符串。如果已设置，则在为此约束发出DDL时发出match<value>。典型值包括简单值、部分值和完整值。
info¶ -- 可选数据字典，将填充到 SchemaItem.info 此对象的属性。…添加的版本：1.0.0
**dialect_kw¶ -- 其他关键字参数是特定于方言的，并以形式传递 <dialectname>_<argname> . 有关单个方言的文档，请参见方言有关文档化参数的详细信息。…添加的版本：0.9.2

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

inherited from the DialectKWArgs.argument_for() method of DialectKWArgs

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

例如。：：

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

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

这个 DialectKWArgs.argument_for() 方法是按参数向 DefaultDialect.construct_arguments 字典。此字典提供了各种模式级构造代表方言接受的参数名列表。

参数

dialect_name¶ -- 方言的名称。方言必须可定位，否则 NoSuchModuleError 提高了。方言还必须包括现有的 DefaultDialect.construct_arguments 集合，指示它参与关键字参数验证和默认系统，否则 ArgumentError 提高了。如果方言不包含此集合，则可以代表此方言指定任何关键字参数。包含在sqlAlchemy中的所有方言都包含此集合，但是对于第三方方言，支持可能有所不同。
argument_name¶ -- 参数的名称。
default¶ -- 参数的默认值。

0.9.4 新版功能.

attribute sqlalchemy.schema.ForeignKeyConstraint.column_keys¶

返回表示此中本地列的字符串键列表 ForeignKeyConstraint .

此列表是发送给 ForeignKeyConstraint ，或者如果约束已用初始化 Column 对象，是字符串 .key 每个元素的。

1.0.0 新版功能.

attribute sqlalchemy.schema.ForeignKeyConstraint.columns = None¶: A ColumnCollection 表示此约束的列集。

method sqlalchemy.schema.ForeignKeyConstraint.contains_column(col)¶

inherited from the ColumnCollectionConstraint.contains_column() method of ColumnCollectionConstraint

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

请注意，此对象还包含一个属性 .columns 哪个是 ColumnCollection 属于 Column 物体。

method sqlalchemy.schema.ForeignKeyConstraint.copy(schema=None, target_table=None, **kw)¶: 1.4 版后已移除: 这个 ForeignKeyConstraint.copy() 方法已弃用，并将在将来的版本中删除。

attribute sqlalchemy.schema.ForeignKeyConstraint.dialect_kwargs¶

inherited from the DialectKWArgs.dialect_kwargs attribute of DialectKWArgs

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

集合也是可写的；接受窗体的键 <dialect>_<kwarg> 值将组合到选项列表中。

0.9.2 新版功能.

在 0.9.4 版更改: 这个 DialectKWArgs.dialect_kwargs 集合现在可写。

参见

DialectKWArgs.dialect_options -嵌套字典窗体

attribute sqlalchemy.schema.ForeignKeyConstraint.dialect_options¶

inherited from the DialectKWArgs.dialect_options attribute of DialectKWArgs

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

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

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

0.9.2 新版功能.

参见

DialectKWArgs.dialect_kwargs -平字典形式

attribute sqlalchemy.schema.ForeignKeyConstraint.elements = None¶

一系列 ForeignKey 物体。

各 ForeignKey 表示单个引用列/引用列对。

此集合是只读的。

method sqlalchemy.schema.ForeignKeyConstraint.get_children(omit_attrs=(), **kw)¶

inherited from the Traversible.get_children() method of Traversible

返回直接子对象 Traversible 这其中的要素 Traversible 。

这用于访问遍历。

**kw可能包含更改返回的集合的标志，例如，返回项的子集以减少更大的遍历，或者从不同的上下文返回子项(例如模式级集合而不是子句级集合)。

attribute sqlalchemy.schema.ForeignKeyConstraint.info¶

inherited from the SchemaItem.info attribute of SchemaItem

与对象关联的信息字典，允许用户定义的数据与此关联 SchemaItem .

字典在第一次访问时自动生成。它也可以在一些对象的构造函数中指定，例如 Table 和 Column .

attribute sqlalchemy.schema.ForeignKeyConstraint.kwargs¶: inherited from the DialectKWArgs.kwargs attribute of DialectKWArgs

同义词 DialectKWArgs.dialect_kwargs .

attribute sqlalchemy.schema.ForeignKeyConstraint.referred_table¶

这个 Table 对象 ForeignKeyConstraint 参考文献。

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

1.0.0 新版功能.

class sqlalchemy.schema.PrimaryKeyConstraint(*columns, **kw)¶

表级主键约束。

这个 PrimaryKeyConstraint 对象自动出现在任何 Table 对象；它被分配一组 Column 与标记有 Column.primary_key 旗帜：

>>> 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 对象显式；在这种使用模式下，还可以指定约束的“名称”，以及方言可以识别的其他选项：

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

两种类型的列规范通常不应混合使用。如果列存在于 PrimaryKeyConstraint 与标记为的列不匹配 primary_key=True ，如果两者都存在；在这种情况下，列严格取自 PrimaryKeyConstraint 声明，以及其他标记为 primary_key=True 被忽略。此行为旨在向后兼容以前的行为。

在 0.9.2 版更改: 在 PrimaryKeyConstraint 除了列标记为 primary_key=True 如果列表不匹配，则会发出警告。忽略标记为“仅”标志的列的最终行为当前是为了向后兼容而维护的；此警告可能会在将来的版本中引发异常。

对于要在 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)
        )

0.9.2 新版功能: 空的 PrimaryKeyConstraint 现在可以指定用于建立带有约束的关键字参数，而不依赖于 Table 本身；列标记为 primary_key=True 将被收集到空约束的列集合中。

类签名

class sqlalchemy.schema.PrimaryKeyConstraint (sqlalchemy.schema.ColumnCollectionConstraint)

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

inherited from the DialectKWArgs.argument_for() method of DialectKWArgs

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

例如。：：

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

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

这个 DialectKWArgs.argument_for() 方法是按参数向 DefaultDialect.construct_arguments 字典。此字典提供了各种模式级构造代表方言接受的参数名列表。

参数

dialect_name¶ -- 方言的名称。方言必须可定位，否则 NoSuchModuleError 提高了。方言还必须包括现有的 DefaultDialect.construct_arguments 集合，指示它参与关键字参数验证和默认系统，否则 ArgumentError 提高了。如果方言不包含此集合，则可以代表此方言指定任何关键字参数。包含在sqlAlchemy中的所有方言都包含此集合，但是对于第三方方言，支持可能有所不同。
argument_name¶ -- 参数的名称。
default¶ -- 参数的默认值。

0.9.4 新版功能.

method sqlalchemy.schema.PrimaryKeyConstraint.contains_column(col)¶

inherited from the ColumnCollectionConstraint.contains_column() method of ColumnCollectionConstraint

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

请注意，此对象还包含一个属性 .columns 哪个是 ColumnCollection 属于 Column 物体。

method sqlalchemy.schema.PrimaryKeyConstraint.copy(target_table=None, **kw)¶: inherited from the ColumnCollectionConstraint.copy() method of ColumnCollectionConstraint

1.4 版后已移除: 这个 ColumnCollectionConstraint.copy() 方法已弃用，并将在将来的版本中删除。

attribute sqlalchemy.schema.PrimaryKeyConstraint.dialect_kwargs¶

inherited from the DialectKWArgs.dialect_kwargs attribute of DialectKWArgs

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

集合也是可写的；接受窗体的键 <dialect>_<kwarg> 值将组合到选项列表中。

0.9.2 新版功能.

在 0.9.4 版更改: 这个 DialectKWArgs.dialect_kwargs 集合现在可写。

参见

DialectKWArgs.dialect_options -嵌套字典窗体

attribute sqlalchemy.schema.PrimaryKeyConstraint.dialect_options¶

inherited from the DialectKWArgs.dialect_options attribute of DialectKWArgs

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

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

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

0.9.2 新版功能.

参见

DialectKWArgs.dialect_kwargs -平字典形式

method sqlalchemy.schema.PrimaryKeyConstraint.get_children(omit_attrs=(), **kw)¶

inherited from the Traversible.get_children() method of Traversible

返回直接子对象 Traversible 这其中的要素 Traversible 。

这用于访问遍历。

**kw可能包含更改返回的集合的标志，例如，返回项的子集以减少更大的遍历，或者从不同的上下文返回子项(例如模式级集合而不是子句级集合)。

attribute sqlalchemy.schema.PrimaryKeyConstraint.info¶

inherited from the SchemaItem.info attribute of SchemaItem

与对象关联的信息字典，允许用户定义的数据与此关联 SchemaItem .

字典在第一次访问时自动生成。它也可以在一些对象的构造函数中指定，例如 Table 和 Column .

attribute sqlalchemy.schema.PrimaryKeyConstraint.kwargs¶: inherited from the DialectKWArgs.kwargs attribute of DialectKWArgs

同义词 DialectKWArgs.dialect_kwargs .

class sqlalchemy.schema.UniqueConstraint(*columns, **kw)¶

表级唯一约束。

定义单个列或复合唯一约束。对于无褶皱，单柱约束，添加 unique=True 到 Column 定义是未命名的单列唯一约束的简写等价物。

类签名

class sqlalchemy.schema.UniqueConstraint (sqlalchemy.schema.ColumnCollectionConstraint)

method sqlalchemy.schema.UniqueConstraint.__init__(*columns, **kw)¶

inherited from the sqlalchemy.schema.ColumnCollectionConstraint.__init__ method of ColumnCollectionConstraint

参数

*columns¶ -- 列名或列对象的序列。
name¶ -- 可选，此约束的数据库内名称。
deferrable¶ -- 可选布尔值。如果设置了，则在为该约束发出DDL时发出“可延迟”或“不可延迟”。
initially¶ -- 可选字符串。如果已设置，则在为此约束发出DDL时最初发出<value>。
**kw¶ -- 包括方言特定参数在内的其他关键字参数将传播到 Constraint 超类。

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

inherited from the DialectKWArgs.argument_for() method of DialectKWArgs

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

例如。：：

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

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

这个 DialectKWArgs.argument_for() 方法是按参数向 DefaultDialect.construct_arguments 字典。此字典提供了各种模式级构造代表方言接受的参数名列表。

参数

dialect_name¶ -- 方言的名称。方言必须可定位，否则 NoSuchModuleError 提高了。方言还必须包括现有的 DefaultDialect.construct_arguments 集合，指示它参与关键字参数验证和默认系统，否则 ArgumentError 提高了。如果方言不包含此集合，则可以代表此方言指定任何关键字参数。包含在sqlAlchemy中的所有方言都包含此集合，但是对于第三方方言，支持可能有所不同。
argument_name¶ -- 参数的名称。
default¶ -- 参数的默认值。

0.9.4 新版功能.

method sqlalchemy.schema.UniqueConstraint.contains_column(col)¶

inherited from the ColumnCollectionConstraint.contains_column() method of ColumnCollectionConstraint

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

请注意，此对象还包含一个属性 .columns 哪个是 ColumnCollection 属于 Column 物体。

method sqlalchemy.schema.UniqueConstraint.copy(target_table=None, **kw)¶: inherited from the ColumnCollectionConstraint.copy() method of ColumnCollectionConstraint

1.4 版后已移除: 这个 ColumnCollectionConstraint.copy() 方法已弃用，并将在将来的版本中删除。

attribute sqlalchemy.schema.UniqueConstraint.dialect_kwargs¶

inherited from the DialectKWArgs.dialect_kwargs attribute of DialectKWArgs

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

集合也是可写的；接受窗体的键 <dialect>_<kwarg> 值将组合到选项列表中。

0.9.2 新版功能.

在 0.9.4 版更改: 这个 DialectKWArgs.dialect_kwargs 集合现在可写。

参见

DialectKWArgs.dialect_options -嵌套字典窗体

attribute sqlalchemy.schema.UniqueConstraint.dialect_options¶

inherited from the DialectKWArgs.dialect_options attribute of DialectKWArgs

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

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

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

0.9.2 新版功能.

参见

DialectKWArgs.dialect_kwargs -平字典形式

method sqlalchemy.schema.UniqueConstraint.get_children(omit_attrs=(), **kw)¶

inherited from the Traversible.get_children() method of Traversible

返回直接子对象 Traversible 这其中的要素 Traversible 。

这用于访问遍历。

**kw可能包含更改返回的集合的标志，例如，返回项的子集以减少更大的遍历，或者从不同的上下文返回子项(例如模式级集合而不是子句级集合)。

attribute sqlalchemy.schema.UniqueConstraint.info¶

inherited from the SchemaItem.info attribute of SchemaItem

与对象关联的信息字典，允许用户定义的数据与此关联 SchemaItem .

字典在第一次访问时自动生成。它也可以在一些对象的构造函数中指定，例如 Table 和 Column .

attribute sqlalchemy.schema.UniqueConstraint.kwargs¶: inherited from the DialectKWArgs.kwargs attribute of DialectKWArgs

同义词 DialectKWArgs.dialect_kwargs .

function sqlalchemy.schema.conv(value, quote=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() 标记表示此处的约束名称是最终的，名称将呈现为 "ck_t_x5" 而不是 "ck_t_ck_t_x5"

0.9.4 新版功能.

参见

配置约束命名约定

索引¶

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

下面我们举例说明 Table 用几个 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)sqlmytable.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 ，使用字符串名称标识列：：

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)sqli.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¶

Object Name	Description
Index	表级索引。

class sqlalchemy.schema.Index(name, *expressions, **kw)¶

表级索引。

定义复合（一列或多列）索引。

例如。：：

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 与表绑定一起构造 Column 物体：：

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

安 Index 也可以手动与 Table ，通过内联声明或使用 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)"))
        )

0.9.5 新版功能: 这个 text() 构造可用于指定 Index 表达式，前提是 Index 与 Table .

参见

索引 -一般信息 Index .

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

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

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

类签名

class sqlalchemy.schema.Index (sqlalchemy.sql.base.DialectKWArgs, sqlalchemy.schema.ColumnCollectionMixin, sqlalchemy.schema.SchemaItem)

method sqlalchemy.schema.Index.__init__(name, *expressions, **kw)¶

构造索引对象。

参数

name¶ -- 索引的名称
*expressions¶ -- 要包含在索引中的列表达式。表达式通常是 Column ，但也可能是最终引用 Column .
unique=False¶ -- 仅关键字参数；如果为true，则创建唯一索引。
quote=None¶ -- 仅关键字参数；是否对索引名称应用引号。工作方式与 Column.quote .
info=None¶ -- 可选数据字典，将填充到 SchemaItem.info 此对象的属性。…添加的版本：1.0.0
**kw¶ -- 上面未提到的其他关键字参数是特定于方言的，并以形式传递 <dialectname>_<argname> . 有关单个方言的文档，请参见方言有关文档化参数的详细信息。

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

inherited from the DialectKWArgs.argument_for() method of DialectKWArgs

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

例如。：：

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

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

这个 DialectKWArgs.argument_for() 方法是按参数向 DefaultDialect.construct_arguments 字典。此字典提供了各种模式级构造代表方言接受的参数名列表。

参数

dialect_name¶ -- 方言的名称。方言必须可定位，否则 NoSuchModuleError 提高了。方言还必须包括现有的 DefaultDialect.construct_arguments 集合，指示它参与关键字参数验证和默认系统，否则 ArgumentError 提高了。如果方言不包含此集合，则可以代表此方言指定任何关键字参数。包含在sqlAlchemy中的所有方言都包含此集合，但是对于第三方方言，支持可能有所不同。
argument_name¶ -- 参数的名称。
default¶ -- 参数的默认值。

0.9.4 新版功能.

attribute sqlalchemy.schema.Index.bind¶: 返回与此索引关联的可连接项。

method sqlalchemy.schema.Index.create(bind=None, checkfirst=False)¶: 发行A CREATE 声明 Index ，使用给定的 Connectable 用于连接。

参见

MetaData.create_all() .

attribute sqlalchemy.schema.Index.dialect_kwargs¶

inherited from the DialectKWArgs.dialect_kwargs attribute of DialectKWArgs

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

集合也是可写的；接受窗体的键 <dialect>_<kwarg> 值将组合到选项列表中。

0.9.2 新版功能.

在 0.9.4 版更改: 这个 DialectKWArgs.dialect_kwargs 集合现在可写。

参见

DialectKWArgs.dialect_options -嵌套字典窗体

attribute sqlalchemy.schema.Index.dialect_options¶

inherited from the DialectKWArgs.dialect_options attribute of DialectKWArgs

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

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

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

0.9.2 新版功能.

参见

DialectKWArgs.dialect_kwargs -平字典形式

method sqlalchemy.schema.Index.drop(bind=None, checkfirst=False)¶: 发行A DROP 声明 Index ，使用给定的 Connectable 用于连接。

参见

MetaData.drop_all() .

method sqlalchemy.schema.Index.get_children(omit_attrs=(), **kw)¶

inherited from the Traversible.get_children() method of Traversible

返回直接子对象 Traversible 这其中的要素 Traversible 。

这用于访问遍历。

**kw可能包含更改返回的集合的标志，例如，返回项的子集以减少更大的遍历，或者从不同的上下文返回子项(例如模式级集合而不是子句级集合)。

attribute sqlalchemy.schema.Index.info¶

inherited from the SchemaItem.info attribute of SchemaItem

与对象关联的信息字典，允许用户定义的数据与此关联 SchemaItem .

字典在第一次访问时自动生成。它也可以在一些对象的构造函数中指定，例如 Table 和 Column .

attribute sqlalchemy.schema.Index.kwargs¶: inherited from the DialectKWArgs.kwargs attribute of DialectKWArgs

同义词 DialectKWArgs.dialect_kwargs .

SQLAlchemy 1.4 Documentation

SQLAlchemy 1.4 Documentation

SQLAlchemy Core

定义约束和索引¶

定义外键¶

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

更新和删除时¶

唯一约束¶

检查约束¶

主键约束¶

使用声明性ORM扩展时设置约束¶

配置约束命名约定¶

配置元数据集合的命名约定¶

默认命名约定¶

长名称的截断¶

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

命名检查约束¶

为布尔、枚举和其他架构类型配置命名¶

约束API¶

索引¶

功能指标¶

索引API¶