SqlAlchemy 2.0 中文文档（四十）（3）

SqlAlchemy 2.0 中文文档（四十）（2）https://developer.aliyun.com/article/1563001

约束 API

class sqlalchemy.schema.Constraint

表级 SQL 约束。

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

成员

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)

method __init__(name: _ConstraintNameArgument = None, deferrable: bool | None = None, initially: str | None = None, info: _InfoType | None = None, comment: str | None = None, _create_rule: Any | None = None, _type_bound: bool = False, **dialect_kw: Any) → None

创建一个 SQL 约束。

参数：

• name – 可选，此 Constraint 的数据库名称。
  
• deferrable – 可选布尔值。如果设置，则在为此约束发出 DDL 时发出 DEFERRABLE 或 NOT DEFERRABLE。
  
• initially – 可选字符串。如果设置，则在为此约束发出 DDL 时发出 INITIALLY 。
  
• info – 可选数据字典，将填充到此对象的 SchemaItem.info 属性中。
  
• comment –
  可选字符串，���在创建外键约束时呈现 SQL 注释。

2.0 版本中的新功能。

• **dialect_kw – 附加关键字参数是特定于方言的，并以 _ 的形式传递。有关单个方言的文档参数详细信息，请参阅 方言。
  
• _create_rule – 一些数据类型内部使用，也创建约束。
  
• _type_bound – 内部使用，表示此约束与特定数据类型相关联。
  

classmethod argument_for(dialect_name, argument_name, default)

继承自 DialectKWArgs.argument_for() 方法的 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 – 参数的默认值。
  

method copy(**kw: Any) → Self

自 1.4 版本弃用：Constraint.copy() 方法已弃用，并将在将来的版本中删除。

method ddl_if(dialect: str | None = None, callable_: DDLIfCallable | None = None, state: Any | None = None) → Self

继承自 HasConditionalDDL.ddl_if() 的方法 HasConditionalDDL

对此模式项目应用条件 DDL 规则。

这些规则的工作方式与ExecutableDDLElement.execute_if()类似，不同之处在于可以在 DDL 编译阶段检查条件，例如CreateTable这样的结构。 HasConditionalDDL.ddl_if() 目前适用于Index结构以及所有Constraint结构。

参数：

• dialect – 方言的字符串名称，或字符串名称的元组，表示多个方言类型。
  
• callable_ – 使用与ExecutableDDLElement.execute_if.callable_中描述的相同形式构建的可调用对象。
  
• state – 将传递给可调用对象的任意任意对象（如果存在）。
  

2.0 版本中的新功能。

另请参阅

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

attribute dialect_kwargs

继承自 DialectKWArgs.dialect_kwargs 属性的 DialectKWArgs

作为针对此结构的方言特定选项指定的关键字参数的集合。

这里的参数以原始的_格式呈现。仅包含实际传递的参数；与包含此方言的所有选项（包括默认值）的DialectKWArgs.dialect_options 集合不同。

该集合也是可写的；键采用_形式，其中的值将被组装成选项列表。

另请参阅

DialectKWArgs.dialect_options - 嵌套字典形式

attribute dialect_options

继承自 DialectKWArgs.dialect_options 属性的 DialectKWArgs

作为针对此结构的方言特定选项指定的关键字参数的集合。

这是一个两级嵌套的注册表，键为 和 。例如，postgresql_where 参数可定位为：

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

0.9.2 版本中的新功能。

另请参阅

DialectKWArgs.dialect_kwargs - 平面字典形式

attribute info

继承自 SchemaItem.info 属性的 SchemaItem

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

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

attribute kwargs

继承自 DialectKWArgs.kwargs 的 DialectKWArgs 属性

DialectKWArgs.dialect_kwargs 的同义词。

class sqlalchemy.schema.ColumnCollectionMixin

一个Column对象的ColumnCollection。

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

class sqlalchemy.schema.ColumnCollectionConstraint

代理列集合的约束。

成员

init(), argument_for(), columns, contains_column(), copy(), ddl_if(), dialect_kwargs, dialect_options, info, kwargs

类签名

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

method __init__(*columns: _DDLColumnArgument, name: _ConstraintNameArgument = None, deferrable: bool | None = None, initially: str | None = None, info: _InfoType | None = None, _autoattach: bool = True, _column_flag: bool = False, _gather_expressions: List[_DDLColumnArgument] | None = None, **dialect_kw: Any) → None

参数:

• *columns – 一系列列名或列对象。
  
• name – 可选项，此约束的数据库中的名称。
  
• deferrable – 可选布尔值。如果设置，发出 DDL 时会发出 DEFERRABLE 或 NOT DEFERRABLE 用于此约束。
  
• initially – 可选字符串。如果设置，发出 DDL 时会发出 INITIALLY 用于此约束。
  
• **dialect_kw – 其他关键字参数，包括方言特定参数，都会传播到Constraint 超类。
  

classmethod argument_for(dialect_name, argument_name, default)

继承自 DialectKWArgs.argument_for() 方法的 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 – 参数的默认值。
  

attribute columns: ReadOnlyColumnCollection[str, Column[Any]]

继承自 ColumnCollectionMixin 属性 ColumnCollectionMixin.columns 的。

代表此约束的一组列的 ColumnCollection。

method contains_column(col: Column[Any]) → bool

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

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

method copy(*, target_table: Table | None = None, **kw: Any) → ColumnCollectionConstraint

从版本 1.4 开始弃用：ColumnCollectionConstraint.copy() 方法已弃用，并将在将来的版本中删除。

method ddl_if(dialect: str | None = None, callable_: DDLIfCallable | None = None, state: Any | None = None) → Self

继承自 HasConditionalDDL.ddl_if() 方法的 HasConditionalDDL

对此模式项应用条件 DDL 规则。

这些规则的工作方式与ExecutableDDLElement.execute_if()可调用对象类似，额外的特性是可以在 DDL 编译阶段检查条件，例如CreateTable构造中的条件。HasConditionalDDL.ddl_if()目前也适用于Index构造以及所有Constraint构造。

参数：

• dialect – 方言的字符串名称，或表示多个方言类型的字符串名称元组。
  
• callable_ – 一个可调用对象，其构造方式与ExecutableDDLElement.execute_if.callable_中描述的形式相同。
  
• state – 任意对象，如果存在将传递给可调用对象。
  

版本 2.0 中的新功能。

另请参阅

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

attribute dialect_kwargs

继承自 DialectKWArgs.dialect_kwargs 属性的 DialectKWArgs

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

这里的参数以原始的_格式呈现。仅包括实际传递的参数；与包含所有已知选项的默认值的DialectKWArgs.dialect_options集合不同。

该集合也是可写的；键的形式为_，其中的值将被组装到选项列表中。

另请参阅

DialectKWArgs.dialect_options - 嵌套字典形式

attribute dialect_options

继承自 DialectKWArgs.dialect_options 属性的 DialectKWArgs

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

这是一个两级嵌套的注册表，键入 和 。例如，postgresql_where 参数可以定位为：

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

新版本 0.9.2 中新增。

另见

DialectKWArgs.dialect_kwargs - 扁平字典形式

attribute info

继承自 SchemaItem.info 属性的 SchemaItem

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

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

attribute kwargs

继承自 DialectKWArgs.kwargs 属性的 DialectKWArgs

DialectKWArgs.dialect_kwargs 的同义词。

class sqlalchemy.schema.CheckConstraint

表或列级别的检查约束。

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

成员

init(), argument_for(), columns, contains_column(), copy(), ddl_if(), dialect_kwargs, dialect_options, info, kwargs

类签名

类 sqlalchemy.schema.CheckConstraint (sqlalchemy.schema.ColumnCollectionConstraint)

method __init__(sqltext: _TextCoercedExpressionArgument[Any], name: _ConstraintNameArgument = None, deferrable: bool | None = None, initially: str | None = None, table: Table | None = None, info: _InfoType | None = None, _create_rule: Any | None = None, _autoattach: bool = True, _type_bound: bool = False, **dialect_kw: Any) → None

构建一个检查约束。

参数：

• sqltext –
  包含约束定义的字符串，将会原样使用，或者是一个 SQL 表达式构造。如果给定为字符串，则将对象转换为 text() 对象。如果文本字符串包含冒号字符，则使用反斜杠进行转义：

CheckConstraint(r"foo ~ E'a(?\:b|c)d")

• 警告
  CheckConstraint.sqltext 参数可以作为 Python 字符串参数传递给 CheckConstraint，该参数将被视为受信任的 SQL 文本并按原样呈现。不要将不受信任的输入传递给此参数。
• name – 可选的，约束在数据库中的名称。
  
• deferrable – 可选布尔值。如果设置了，则在为此约束发出 DDL 时发出 DEFERRABLE 或 NOT DEFERRABLE。
  
• initially – 可选字符串。如果设置了，则在为此约束发出 DDL 时发出 INITIALLY 。
  
• info – 可选的数据字典，将填充到该对象的 SchemaItem.info 属性中。
  

classmethod argument_for(dialect_name, argument_name, default)

继承自 DialectKWArgs.argument_for() 方法的 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 – 参数的默认值。
  

attribute columns: ReadOnlyColumnCollection[str, Column[Any]]

继承自 ColumnCollectionMixin.columns 属性的 ColumnCollectionMixin

表示此约束的列集合。

method contains_column(col: Column[Any]) → bool

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

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

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

method copy(*, target_table: Table | None = None, **kw: Any) → CheckConstraint

自版本 1.4 起已弃用：CheckConstraint.copy() 方法已弃用，并将在将来的版本中删除。

method ddl_if(dialect: str | None = None, callable_: DDLIfCallable | None = None, state: Any | None = None) → Self

继承自 HasConditionalDDL.ddl_if() 方法的 HasConditionalDDL

对此模式项应用条件 DDL 规则。

这些规则的工作方式与ExecutableDDLElement.execute_if()可调用对象类似，但增加了一个功能，即可以在 DDL 编译阶段检查条件，例如CreateTable构造。 HasConditionalDDL.ddl_if()目前也适用于Index构造以及所有Constraint构造。

参数：

• dialect - 方言的字符串名称，或字符串名称的元组以指示多个方言类型。
  
• callable_ - 使用与ExecutableDDLElement.execute_if.callable_描述的相同形式构造的可调用对象。
  
• state - 任意对象，如果存在，将传递给可调用对象。
  

版本 2.0 中的新功能。

另请参阅

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

attribute dialect_kwargs

继承自 DialectKWArgs.dialect_kwargs 属性的 DialectKWArgs

作为方言特定选项传递给此构造函数的关键字参数集合。

这里的参数以其原始的_格式存在。只包括实际传递的参数；与包含此方言的所有选项的DialectKWArgs.dialect_options集合不同，后者包含了所有已知选项，包括默认值。

该集合也可写入；键的形式为_，其中的值将被组装到选项列表中。

另请参阅

DialectKWArgs.dialect_options - 嵌套字典形式

attribute dialect_options

继承自 DialectKWArgs.dialect_options 属性的 DialectKWArgs

作为方言特定选项传递给此构造函数的关键字参数集合。

这是一个两级嵌套的注册表，键为和。例如，postgresql_where参数可定位为：

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

版本 0.9.2 中的新功能。

另请参阅

DialectKWArgs.dialect_kwargs - 平面字典形式

attribute info

继承自 SchemaItem.info 属性的 SchemaItem。

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

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

attribute kwargs

继承自 DialectKWArgs.kwargs 属性的 DialectKWArgs。

DialectKWArgs.dialect_kwargs的同义词。

class sqlalchemy.schema.ForeignKey

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

ForeignKey被指定为Column对象的一个参数，例如：

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

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

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

与单个Column对象关联的ForeignKey对象可在该列的 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)

method __init__(column: _DDLColumnArgument, _constraint: ForeignKeyConstraint | None = None, use_alter: bool = False, name: _ConstraintNameArgument = None, onupdate: str | None = None, ondelete: str | None = None, deferrable: bool | None = None, initially: str | None = None, link_to_name: bool = False, match: str | None = None, info: _InfoType | None = None, comment: str | None = None, _unresolvable: bool = False, **dialect_kw: Any)

构造列级 FOREIGN KEY。

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

参数：

• column – 关键关系的单个目标列。一个Column对象或作为字符串的列名：tablename.columnkey或schema.tablename.columnkey。除非link_to_name为True，否则columnkey是分配给列的key（默认为列名本身）。
  
• name – 可选的字符串。如果未提供约束，则用于键的数据库内名称。
  
• onupdate – 可选的字符串。如果设置，发出 ON UPDATE 的 DDL。典型值包括 CASCADE、DELETE 和 RESTRICT。
  
• ondelete – 可选的字符串。如果设置，发出 ON DELETE 的 DDL。典型值包括 CASCADE、DELETE 和 RESTRICT。
  
• deferrable – 可选的布尔值。如果设置，发出 DEFERRABLE 或 NOT DEFERRABLE 的 DDL。
  
• initially – 可选的字符串。如果设置，发出 INITIALLY 的 DDL。
  
• link_to_name – 如果为 True，则column中给定的字符串名称是引用列的呈现名称，而不是其本地分配的key。
  
• use_alter –
  传递给底层 ForeignKeyConstraint 以指示应该从 CREATE TABLE/ DROP TABLE 语句外部生成/删除约束。 有关详细信息，请参阅 ForeignKeyConstraint.use_alter。
  另请参见
  ForeignKeyConstraint.use_alter
  通过 ALTER 创建/删除外键约束
  
• match – 可选字符串。 如果设置，当为此约束发出 DDL 时，将发出 MATCH 。 典型值包括 SIMPLE、PARTIAL 和 FULL。
  
• info – 可选数据字典，将填充到此对象的 SchemaItem.info 属性中。
  
• comment –
  可选字符串，将在外键约束创建时渲染 SQL 注释。

2.0 版中的新内容。

• **dialect_kw – 额外的关键字参数是特定于方言的，并以 _ 的形式传递。 这些参数最终由相应的 ForeignKeyConstraint 处理。 有关已记录参数的详细信息，请参阅 方言 中有关单个方言的文档。
  

classmethod argument_for(dialect_name, argument_name, default)

继承自 DialectKWArgs.argument_for() 方法的 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 – 参数的默认值。
  

attribute column

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

如果没有建立目标列，则会引发异常��

method copy(*, schema: str | None = None, **kw: Any) → ForeignKey

自版本 1.4 弃用：ForeignKey.copy() 方法已弃用，并将在将来的版本中移除。

attribute dialect_kwargs

继承自 DialectKWArgs.dialect_kwargs 属性 的 DialectKWArgs

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

这里的参数以其原始的 _ 格式呈现。只包括实际传递的参数；不像 DialectKWArgs.dialect_options 集合，该集合包含此方言已知的所有选项，包括默认值。

该集合也是可写的；键的形式为 _，其中的值将被组装到选项列表中。

另请参阅

DialectKWArgs.dialect_options - 嵌套字典形式

attribute dialect_options

继承自 DialectKWArgs.dialect_options 属性 的 DialectKWArgs

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

这是一个两级嵌套的注册表，键入为和。例如，postgresql_where参数可以定位为：

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

版本 0.9.2 中的新功能。

另请参阅

DialectKWArgs.dialect_kwargs - 扁平字典形式

method get_referent(table: FromClause) → Column[Any] | None

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

如果此ForeignKey未引用给定的Table，则返回 None。

attribute info

继承自 SchemaItem.info 属性的 SchemaItem

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

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

attribute kwargs

继承自 DialectKWArgs.kwargs 属性的 DialectKWArgs

DialectKWArgs.dialect_kwargs的同义词。

method references(table: Table) → bool

如果此ForeignKey引用给定的Table，则返回 True。

attribute target_fullname

返回此ForeignKey的基于字符串的‘列规范’。

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

class sqlalchemy.schema.ForeignKeyConstraint

表级别的外键约束。

定义单列或复合 FOREIGN KEY … REFERENCES 约束。对于简单的、单列的外键，将 ForeignKey 添加到 Column 的定义中相当于一个未命名的、单列的 ForeignKeyConstraint。

外键配置示例位于 定义外键 中。

成员

init(), argument_for(), column_keys, columns,  contains_column(), copy(), ddl_if(), dialect_kwargs, dialect_options,  elements, info, kwargs, referred_table

类签名

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

method __init__(columns: _typing_Sequence[_DDLColumnArgument], refcolumns: _typing_Sequence[_DDLColumnArgument], name: _ConstraintNameArgument = None, onupdate: str | None = None, ondelete: str | None = None, deferrable: bool | None = None, initially: str | None = None, use_alter: bool = False, link_to_name: bool = False, match: str | None = None, table: Table | None = None, info: _InfoType | None = None, comment: str | None = None, **dialect_kw: Any) → None

构造一个能够处理复合键的 FOREIGN KEY。

参数：

• columns – 一系列本地列名称。所命名的列必须在父表中定义并存在。除非 link_to_name 为 True，否则名称应与每列给定的 key 匹配（默认为名称）。
  
• refcolumns – 一系列外键列名称或 Column 对象。这些列必须全部位于同一张表内。
  
• name – 可选，键的数据库内名称。
  
• onupdate – 可选字符串。如果设置，则在为此约束发出 DDL 时发出 ON UPDATE 。典型值包括 CASCADE、DELETE 和 RESTRICT。
  
• ondelete – 可选字符串。如果设置，则在为此约束发出 DDL 时发出 ON DELETE 。典型值包括 CASCADE、DELETE 和 RESTRICT。
  
• deferrable – 可选布尔值。如果设置，则在发出此约束的 DDL 时发出 DEFERRABLE 或 NOT DEFERRABLE。
  
• initially – 可选字符串。如果设置，则在为此约束发出 DDL 时发出 INITIALLY 。
  
• link_to_name – 如果为 True，则 column 中给定的字符串名称是引用列的渲染名称，而不是其本地分配的 key。
  
• use_alter –
  如果为 True，则不会将此约束的 DDL 作为 CREATE TABLE 定义的一部分输出。相反，在创建完整的表集合之后，通过 ALTER TABLE 语句生成它，在删除完整的表集合之前，通过 ALTER TABLE 语句将其删除。
  ForeignKeyConstraint.use_alter 的使用特别适用于两个或多个表在相互依赖的外键约束关系内建立的情况；然而，MetaData.create_all() 和 MetaData.drop_all() 方法将自动执行此解析，因此通常不需要该标志。
  另请参阅
  通过 ALTER 创建/删除外键约束
  
• match – 可选字符串。如果设置，则在为此约束发出 DDL 时发出 MATCH 。典型值包括 SIMPLE、PARTIAL 和 FULL。
  
• info – 将填充到此对象的 SchemaItem.info 属性中的可选数据字典。
  
• comment –
  可选字符串，将在创建外键约束时呈现 SQL 注释。

新版本 2.0 中新增。

• **dialect_kw – 附加关键字参数是方言特定的，并以 <方言名称>_<参数名称> 形式传递。有关文档中记录的参数的详细信息，请参阅方言中有关单个方言的文档。
  

classmethod 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_name – 方言的名称。如果无法定位方言，将引发 NoSuchModuleError。方言还必须包括一个现有的 DefaultDialect.construct_arguments 集合，表示它参与关键字参数的验证和默认系统，否则将引发 ArgumentError。如果方言不包括此集合，则可以代表此方言已经指定任何关键字参数。SQLAlchemy 中打包的所有方言都包括此集合，但是对于第三方方言，支持可能有所不同。
  
• argument_name – 参数的名称。
  
• default – 参数的默认值。
  

attribute column_keys

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

此列表是发送到 ForeignKeyConstraint 构造函数的原始字符串参数，或者如果约束已使用 Column 对象进行初始化，则是每个元素的字符串 .key。

attribute columns: ReadOnlyColumnCollection[str, Column[Any]]

从 ColumnCollectionMixin 的 ColumnCollectionMixin.columns 属性继承

表示此约束的列集合的 ColumnCollection。

method contains_column(col: Column[Any]) → bool

从 ColumnCollectionConstraint.contains_column() 方法继承

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

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

method copy(*, schema: str | None = None, target_table: Table | None = None, **kw: Any) → ForeignKeyConstraint

从版本 1.4 起弃用：ForeignKeyConstraint.copy() 方法已弃用，并将在将来的版本中删除。

method ddl_if(dialect: str | None = None, callable_: DDLIfCallable | None = None, state: Any | None = None) → Self

从 HasConditionalDDL 的 HasConditionalDDL.ddl_if() 方法继承

对此模式项应用条件 DDL 规则。

这些规则的工作方式与ExecutableDDLElement.execute_if()可调用对象类似，但增加了在 DDL 编译阶段检查条件的功能，例如CreateTable构造。HasConditionalDDL.ddl_if()当前还适用于Index构造以及所有Constraint构造。

参数：

• dialect – 方言的字符串名称，或一个字符串名称元组，表示多个方言类型。
  
• callable_ – 使用与ExecutableDDLElement.execute_if.callable_描述的相同形式构造的可调用对象。
  
• state – 如果存在，则会传递给可调用对象的任意对象。
  

版本 2.0 中的新功能。

另请参阅

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

attribute dialect_kwargs

继承自 DialectKWArgs.dialect_kwargs 属性的 DialectKWArgs

一组关键字参数，指定为此构造的方言特定选项。

这些参数在这里以其原始的_格式呈现。只包括实际传递的参数；与包含此方言的所有选项（包括默认值）的DialectKWArgs.dialect_options集合不同。

该集合也是可写的；接受形式为_的键，值将被组装到选项列表中。

另请参阅

DialectKWArgs.dialect_options - 嵌套字典形式

attribute dialect_options

继承自 DialectKWArgs.dialect_options 属性的 DialectKWArgs

一组关键字参数，指定为此构造的方言特定选项。

这是一个两级嵌套的注册表，键为和。例如，postgresql_where参数可以定位为：

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

版本 0.9.2 中的新功能。

另请参阅

DialectKWArgs.dialect_kwargs - 平面字典形式

attribute elements: List[ForeignKey]

一系列ForeignKey对象。

每个ForeignKey表示一个引用列/被引用列对。

此集合预期为只读。

attribute info

继承自SchemaItem.info 属性的

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

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

attribute kwargs

继承自DialectKWArgs.kwargs 属性的

DialectKWArgs.dialect_kwargs的同义词。

attribute referred_table

此ForeignKeyConstraint引用的Table对象。

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

class sqlalchemy.schema.HasConditionalDDL

定义一个包含HasConditionalDDL.ddl_if()方法的类，允许对 DDL 进行条件渲染。

目前适用于约束和索引。

成员

ddl_if()

版本 2.0 中的新功能。

method ddl_if(dialect: str | None = None, callable_: DDLIfCallable | None = None, state: Any | None = None) → Self

对此模式项应用条件 DDL 规则。

这些规则的工作方式类似于 ExecutableDDLElement.execute_if() 可调用对象，但增加了一个特性，即在 DDL 编译阶段可以检查条件，例如 CreateTable 等构造中的条件。 HasConditionalDDL.ddl_if() 目前也适用于 Index 构造以及所有 Constraint 构造。

参数：

• dialect – 方言的字符串名称，或者字符串名称的元组，表示多种方言类型。
  
• callable_ – 一个可调用对象，其构造方式与 ExecutableDDLElement.execute_if.callable_ 中描述的相同。
  
• state – 如果存在，则将传递给可调用对象的任意对象。
  

版本 2.0 中的新增内容。

另请参阅

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

class sqlalchemy.schema.PrimaryKeyConstraint

表级别的主键约束。

Table 对象上自动存在 PrimaryKeyConstraint 对象；它被分配了一组与标记有 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)
)

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

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 的列将被忽略。此行为旨在向后兼容以前的行为。

对于需要在 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(), columns, contains_column(), copy(), ddl_if(), dialect_kwargs, dialect_options, info, kwargs

类签名

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

classmethod argument_for(dialect_name, argument_name, default)

继承自 DialectKWArgs.argument_for() 方法的 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 – 参数的默认值。
  

attribute columns: ReadOnlyColumnCollection[str, Column[Any]]

继承自 ColumnCollectionMixin.columns 属性的 ColumnCollectionMixin

代表此约束的一组列的 ColumnCollection。

method contains_column(col: Column[Any]) → bool

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

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

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

method copy(*, target_table: Table | None = None, **kw: Any) → ColumnCollectionConstraint

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

从版本 1.4 开始已弃用：ColumnCollectionConstraint.copy() 方法已弃用，并将在将来的版本中删除。

method ddl_if(dialect: str | None = None, callable_: DDLIfCallable | None = None, state: Any | None = None) → Self

继承自 HasConditionalDDL.ddl_if() 方法的 HasConditionalDDL

对这个模式项应用一个条件 DDL 规则。

这些规则与ExecutableDDLElement.execute_if()可调用对象的工作方式类似，额外的特性是可以在 DDL 编译阶段检查条件，例如CreateTable这样的结构。 HasConditionalDDL.ddl_if()目前也适用于Index结构以及所有Constraint结构。

参数：

• dialect – 方言的字符串名称，或者字符串名称的元组以指示多个方言类型。
  
• callable_ – 使用与ExecutableDDLElement.execute_if.callable_中描述的相同形式构造的可调用对象。
  
• state – 如果存在，将传递给可调用对象的任意对象。
  

版本 2.0 中的新功能。

另请参阅

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

attribute dialect_kwargs

继承自 DialectKWArgs.dialect_kwargs 属性的 DialectKWArgs

一组作为特定于方言的选项指定为此结构的关键字参数。

这些参数以原始的 _ 格式出现在此处。仅包括实际传递的参数；不像DialectKWArgs.dialect_options集合，该集合包含该方言知道的所有选项，包括默认值。

该集合也是可写的；键以 _ 形式接受，其中值将被组装到选项列表中。

另请参阅

DialectKWArgs.dialect_options - 嵌套字典形式

attribute dialect_options

继承自 DialectKWArgs.dialect_options 属性的 DialectKWArgs

一组作为特定于方言的选项指定为此结构的关键字参数。

这是一个两级嵌套的注册表，键为 和 。例如，postgresql_where 参数可定位为：

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

版本 0.9.2 中的新功能。

另请参阅

DialectKWArgs.dialect_kwargs - 平展的字典形式

attribute info

继承自 SchemaItem.info 属性的 SchemaItem 的

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

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

attribute kwargs

继承自 DialectKWArgs.kwargs 属性的 DialectKWArgs

DialectKWArgs.dialect_kwargs 的同义词。

class sqlalchemy.schema.UniqueConstraint

表级别的唯一约束。

定义单列或组合唯一约束。对于简单的单列约束，向 Column 定义中添加 unique=True 是一个等效的缩写，相当于未命名的单列 UniqueConstraint。

成员

init(), argument_for(), columns, contains_column(), copy(), ddl_if(), dialect_kwargs, dialect_options, info, kwargs

类签名

类 sqlalchemy.schema.UniqueConstraint (sqlalchemy.schema.ColumnCollectionConstraint)。

method __init__(*columns: _DDLColumnArgument, name: _ConstraintNameArgument = None, deferrable: bool | None = None, initially: str | None = None, info: _InfoType | None = None, _autoattach: bool = True, _column_flag: bool = False, _gather_expressions: List[_DDLColumnArgument] | None = None, **dialect_kw: Any) → None

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

参数：

• *columns – 一系列列名或 Column 对象。
  
• name – 可选项，此约束的数据库内名称。
  
• deferrable – 可选的布尔值。如果设置，当为此约束发出 DDL 时会发出 DEFERRABLE 或 NOT DEFERRABLE。
  
• initially – 可选字符串。如果设置，当为此约束发出 DDL 时，会发出 INITIALLY 。
  
• **dialect_kw – 其他关键字参数，包括方言特定参数，将传播到 Constraint 超类。
  

classmethod 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_name – 方言的名称。方言必须可定位，否则会引发 NoSuchModuleError。方言还必须包括现有的 DefaultDialect.construct_arguments 集合，指示其参与关键字参数验证和默认系统，否则会引发 ArgumentError。如果方言不包括此集合，则已经可以代表此方言指定任何关键字参数。SQLAlchemy 中打包的所有方言都包含此集合，但是对于第三方方言，支持可能有所不同。
  
• argument_name – 参数的名称。
  
• default – 参数的默认值。
  

attribute columns: ReadOnlyColumnCollection[str, Column[Any]]

继承自 ColumnCollectionMixin 的 ColumnCollectionMixin.columns 属性。

表示此约束的列集合的 ColumnCollection。

method contains_column(col: Column[Any]) → bool

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

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

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

method copy(*, target_table: Table | None = None, **kw: Any) → ColumnCollectionConstraint

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

自版本 1.4 开始已弃用：ColumnCollectionConstraint.copy() 方法已弃用，将在未来版本中删除。

method ddl_if(dialect: str | None = None, callable_: DDLIfCallable | None = None, state: Any | None = None) → Self

继承自 HasConditionalDDL.ddl_if() 方法的 HasConditionalDDL

对此模式项应用一个条件 DDL 规则。

这些规则的工作方式与ExecutableDDLElement.execute_if()可调用对象类似，但添加了一个特性，即可以在 DDL 编译阶段检查条件，例如CreateTable构造。 HasConditionalDDL.ddl_if() 目前也适用于Index构造以及所有Constraint构造。

参数：

• dialect – 方言的字符串名称，或者一个字符串名称的元组，表示多个方言类型。
  
• callable_ – 使用与ExecutableDDLElement.execute_if.callable_描述的相同形式构建的可调用对象。
  
• state – 如果存在，将传递给可调用对象的任意对象。
  

2.0 版中的新功能。

另请参阅

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

attribute dialect_kwargs

继承自 DialectKWArgs.dialect_kwargs 属性的 DialectKWArgs

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

这里的参数以其原始的 _ 格式呈现。仅包括实际传递的参数；与 DialectKWArgs.dialect_options 集合不同，后者包含此方言的所有已知选项，包括默认值。

该集合也是可写的；接受形式为 _ 的键，其值将被组装到选项列表中。

另请参阅

DialectKWArgs.dialect_options - 嵌套字典形式

attribute dialect_options

继承自 DialectKWArgs.dialect_options 属性的 DialectKWArgs

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

这是一个两级嵌套的注册表，键入为 和 。例如，postgresql_where 参数可以定位为：

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

新版本中新增 0.9.2。

另请参阅

DialectKWArgs.dialect_kwargs - 平面字典形式

attribute info

继承自 SchemaItem.info 属性的 SchemaItem

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

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

attribute kwargs

继承自 DialectKWArgs.kwargs 属性的 DialectKWArgs

DialectKWArgs.dialect_kwargs 的同义词。

function sqlalchemy.schema.conv(value: str, quote: bool | None = None) → Any

标记字符串，指示名称已经被命名约定转换。

这是一个字符串子类，指示不应再受任何进一步命名约定的影响的名称。

例如，当我们按照以下命名约定创建一个 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"

另请参见

配置约束命名约定

索引

可以匿名创建索引（使用自动生成的名称 ix_）来为单个列使用内联 index 关键字，该关键字还修改了 unique 的使用，将唯一性应用于索引本身，而不是添加单独的 UNIQUE 约束。对于具有特定名称或涵盖多个列的索引，请使用 Index 构造，该构造需要一个名称。

下面我们示例了一个带有多个相关 Index 对象的 Table。DDL “创建索引”的语句会在表的创建语句之后立即发出：

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, col4
Index("idx_col34", mytable.c.col3, mytable.c.col4)
# place a unique index on col5, col6
Index("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 内部“内联”定义，使用字符串名称标识列：

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) 

函数索引

索引 支持 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

class sqlalchemy.schema.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)

也支持功能性索引，通常通过结合绑定到表的 Column 对象使用 func 构造来实现：

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

Index 也可以通过内联声明或使用 Table.append_constraint() 与 Table 手动关联。当使用这种方法时，索引列的名称可以指定为字符串：

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

另请参阅

索引 - 关于 Index 的一般信息。

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

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

聚集索引支持 - 用于 Index 构造的特定于 MSSQL 的选项。

成员

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)

method __init__(name: str | None, *expressions: _DDLColumnArgument, unique: bool = False, quote: bool | None = None, info: _InfoType | None = None, _table: Table | None = None, _column_flag: bool = False, **dialect_kw: Any) → None

构造索引对象。

参数：

• name – 索引的名称
  
• *expressions – 要包含在索引中的列表达式。这些表达式通常是 Column 的实例，但也可以是最终引用 Column 的任意 SQL 表达式。
  
• unique=False – 仅限关键字参数；如果为 True，则创建唯一索引。
  
• quote=None – 仅限关键字参数；是否对索引名称应用引号。其工作方式与 Column.quote 相同。
  
• info=None – 可选数据字典，将填充到此对象的 SchemaItem.info 属性中。
  
• **dialect_kw – 除上述未提及的其他关键字参数是方言特定的，并以_的形式传递。有关文档中列出的参数的详细信息，请参阅有关单个方言的文档 方言 。
  

classmethod argument_for(dialect_name, argument_name, default)

继承自 DialectKWArgs.argument_for() 方法的 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 – 参数的默认值。
  

method create(bind: _CreateDropBind, checkfirst: bool = False) → None

为这个 Index 发出一个 CREATE 语句，使用给定的 Connection 或 Engine 进行连接。

另请参见

MetaData.create_all().

method ddl_if(dialect: str | None = None, callable_: DDLIfCallable | None = None, state: Any | None = None) → Self

继承自 HasConditionalDDL.ddl_if() 方法的 HasConditionalDDL

对此模式项应用条件 DDL 规则。

这些规则的工作方式类似于 ExecutableDDLElement.execute_if() 可调用对象，额外的功能是可以在 DDL 编译阶段检查条件，例如 CreateTable 这样的构造。HasConditionalDDL.ddl_if() 目前也适用于 Index 构造以及所有 Constraint 构造。

参数:

• dialect – 方言的字符串名称，或者字符串名称的元组，表示多个方言类型。
  
• callable_ – 一个可调用对象，其构造方式与 ExecutableDDLElement.execute_if.callable_ 中描述的形式相同。
  
• state – 如果存在，将传递给可调用对象的任意对象。
  

版本 2.0 中的新功能。

另请参见

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

attribute dialect_kwargs

继承自 DialectKWArgs.dialect_kwargs 属性的 DialectKWArgs

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

这里的参数以原始的_格式呈现。仅包括实际传递的参数；不像DialectKWArgs.dialect_options集合，该集合包含此方言已知的所有选项，包括默认值。

该集合也是可写的；接受形式为_的键，其值将被组装到选项列表中。

另请参阅

DialectKWArgs.dialect_options - 嵌套字典形式

attribute dialect_options

继承自 DialectKWArgs.dialect_options 属性的 DialectKWArgs

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

这是一个两级嵌套的注册表，键为和。例如，postgresql_where参数可以定位为：

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

从版本 0.9.2 开始。

另请参阅

DialectKWArgs.dialect_kwargs - 扁平字典形式

method drop(bind: _CreateDropBind, checkfirst: bool = False) → None

使用给定的Connection或Engine进行此Index的DROP语句。

另请参阅

MetaData.drop_all()。

attribute info

继承自 SchemaItem.info 属性的 SchemaItem

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

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

attribute kwargs

继承自 DialectKWArgs.kwargs 属性的 DialectKWArgs

DialectKWArgs.dialect_kwargs 的一个同义词。

SqlAlchemy 2.0 中文文档（四十）（4）https://developer.aliyun.com/article/1563003