本节将讨论SQL constraints和索引。在SQLAlchemy中，关键类包括ForeignKeyConstraint和Index。
SQL中的外键是表级结构，限制该表中的一个或多个列，使得值能存在不同列中，通常但不总是位于不同的表。我们调用了约束外键列的列和它们被约束到引用的列的列。被引用的列几乎总是为他们拥有的表定义主键，但也有例外。外键是将具有相互关系的行对连接在一起的“联合”，SQLAlchemy几乎在其操作的每个区域都非常重视这个概念。
在SQLAlchemy以及DDL中，可以将外键约束定义为table子句中的附加属性，或者对于单列外键，可以在单列的定义内指定外键约束。单列外键更常见，并且在列级别通过构建ForeignKey对象作为Column对象的参数来指定：
user_preference = Table('user_preference', metadata,
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的参数通常是＆lt； tablename＆gt；。＆lt； columnname＆gt；＆lt； / t3＆gt；的形式的字符串，或者对于远程模式中的表或“所有者” form ＆lt； schemaname＆gt；。＆lt； tablename＆gt；。＆lt； columnname＆gt；。它也可能是一个实际的Column对象，我们稍后会看到它是通过它的c集合从现有的Table对象进行访问的：
ForeignKey(user.c.user_id)使用字符串的好处在于，仅当第一次需要时才解析user和user_preference之间的in-python链接，以便可以将表对象轻松地分布到多个模块中，按任何顺序定义。
外键也可以使用ForeignKeyConstraint对象在表级定义。该对象可以描述单列或多列外键。多列外键称为复合外键，并且几乎总是引用具有复合主键的表。下面我们定义一个表invoice，它有一个复合主键：
invoice = Table('invoice', metadata,
Column('invoice_id', Integer, primary_key=True),
Column('ref_num', Integer, primary_key=True),
Column('description', String(60), nullable=False)
)然后使用引用invoice的复合外键的表invoice_item：
invoice_item = Table('invoice_item', metadata,
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是定义组合外键的唯一方法。虽然我们也可以在invoice_item.invoice_id和invoice_item.ref_num列上放置单个ForeignKey对象，但SQLAlchemy不会意识到这两个值应该配对在一起 - 这将是两个单独的外键约束，而不是引用两列的单个组合外键。
我们在教程和其他地方看到的涉及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定义中“内联”的方式。The MetaData.create_all() and MetaData.drop_all() methods do this by default, using a topological sort of all the Table objects involved such that tables are created and dropped in order of their foreign key dependency (this sort is also available via the MetaData.sorted_tables accessor).
这种方法在两个或更多外键约束涉及“依赖周期”的情况下无法工作，其中一组表彼此相互依赖，假设后端强制执行外键（除SQLite，MySQL / MyISAM数据）。因此，这些方法将在这种循环中将约束分解为单独的ALTER语句，而不是支持大多数ALTER形式的SQLite以外的所有后端。给定一个模式如下：
node = Table(
'node', metadata,
Column('node_id', Integer, primary_key=True),
Column(
'primary_element', Integer,
ForeignKey('element.element_id')
)
)
element = Table(
'element', metadata,
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()时，解析这两个表之间的循环并分别创建约束：
>>> with engine.connect() as conn:
... metadata.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'表中，我们没有命名这个约束；系统将因此尝试仅为那些被命名的约束发出DROP：
>>> with engine.connect() as conn:
... metadata.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.这个错误只适用于DROP情况，因为我们可以在没有名字的CREATE情况下发出“ADD CONSTRAINT”；数据库通常自动分配一个。
可以使用ForeignKeyConstraint.use_alter和ForeignKey.use_alter关键字参数来手动解决依赖关系周期。我们只能将这个标志添加到'element'表中，如下所示：
element = Table(
'element', metadata,
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语句，而不是另一个：
>>> with engine.connect() as conn:
... metadata.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 and ForeignKey.use_alter, when used in conjunction with a drop operation, will require that the constraint is named, else an error like the following is generated:
sqlalchemy.exc.CompileError: Can't emit DROP CONSTRAINT for constraint
ForeignKeyConstraint(...); it has no nameChanged in version 1.0.0: - The DDL system invoked by MetaData.create_all() and MetaData.drop_all() will now automatically resolve mutually depdendent foreign keys between tables declared by ForeignKeyConstraint and ForeignKey objects, without the need to explicitly set the ForeignKeyConstraint.use_alter flag.
版本1.0.0中已更改： - ForeignKeyConstraint.use_alter标志可与未命名的约束一起使用；实际调用时，只有DROP操作会发出特定的错误。
Most databases support cascading of foreign key values, that is the when a parent row is updated the new value is placed in child rows, or when the parent row is deleted all corresponding child rows are set to null or 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', meta,
Column('id', Integer,
ForeignKey('parent.id', onupdate="CASCADE", ondelete="CASCADE"),
primary_key=True
)
)
composite = Table('composite', meta,
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"
)
)请注意，这些子句在SQLite上不受支持，并且在与MySQL一起使用时需要InnoDB表。他们也可能不支持其他数据库。
使用Column上的unique关键字，可以在单个列上匿名创建唯一约束。通过UniqueConstraint表级构造创建明确命名的唯一约束和/或具有多个列的约束。
from sqlalchemy import UniqueConstraint
meta = MetaData()
mytable = Table('mytable', meta,
# 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。
from sqlalchemy import CheckConstraint
meta = MetaData()
mytable = Table('mytable', meta,
# per-column CHECK constraint
Column('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)
)根据用Column.primary_key标志标记的Column对象，任何Table对象的主键约束都是隐式存在的。PrimaryKeyConstraint对象提供对此约束的显式访问，其中包括直接配置的选项：
from sqlalchemy import 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 - detailed API documentation.
Table是SQLAlchemy核心结构，允许用户定义表格元数据，其中SQLAlchemy ORM可以使用该元数据作为映射类别的目标。The Declarative extension allows the Table object to be created automatically, given the contents of the table primarily as a mapping of Column objects.
要将表级约束对象（如ForeignKeyConstraint）应用于使用Declarative定义的表，请使用Table Configuration中介绍的__table_args__属性。
关系数据库通常为所有约束和索引分配显式名称。在通常情况下，使用CREATE TABLE创建表，其中CHECK，UNIQUE和PRIMARY KEY约束等约束与表定义时，数据库通常会有一个系统，在这个系统中，如果没有另外指定名称，名称会自动分配给这些约束。当使用诸如ALTER TABLE的命令在数据库中更改现有数据库表时，此命令通常需要为新约束指定明确的名称以及能够指定要删除或修改的现有约束的名称。
可以使用Constraint.name参数明确命名约束，并为索引Index.name参数指定约束。但是，在约束条件下，该参数是可选的。还有一些使用Column.unique和Column.index参数来创建UniqueConstraint和Index未指定明确名称的对象。
更改现有表和约束的用例可以通过模式迁移工具（如Alembic）来处理。然而，Alembic和SQLAlchemy目前都没有为其中未指定名称的约束对象创建名称，导致能够更改现有约束的情况意味着必须对关系数据库使用的命名系统进行反向工程以自动分配名称或者必须小心确保所有约束都被命名。
与必须为所有Constraint和Index对象指定显式名称相反，可以使用事件构建自动命名方案。This approach has the advantage that constraints will get a consistent naming scheme without the need for explicit name parameters throughout the code, and also that the convention takes place just as well for those constraints and indexes produced by the Column.unique and Column.index parameters. 从SQLAlchemy 0.9.2开始，这个基于事件的方法被包含在内，并且可以使用参数MetaData.naming_convention进行配置。
MetaData.naming_convention refers to a dictionary which accepts the Index class or individual Constraint classes as keys, and Python string templates as values. 它也接受一系列的字符码作为替代键，即"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 = MetaData(naming_convention=convention)The above convention will establish names for all constraints within the target MetaData collection. 例如，我们可以观察创建未命名的UniqueConstraint时产生的名称：
>>> user_table = Table('user', metadata,
... 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,
... 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复制的。
The default value for MetaData.naming_convention handles the long-standing SQLAlchemy behavior of assigning a name to a Index object that is created using the Column.index parameter:
>>> from sqlalchemy.sql.schema import DEFAULT_NAMING_CONVENTION
>>> DEFAULT_NAMING_CONVENTION
immutabledict({'ix': 'ix_%(column_0_label)s'})The tokens available include %(table_name)s, %(referred_table_name)s, %(column_0_name)s, %(column_0_label)s, %(column_0_key)s, %(referred_column_0_name)s, and %(constraint_name)s; the documentation for MetaData.naming_convention describes each individually. 通过在naming_convention字典中指定一个额外的标记和一个可调用标记，还可以添加新的标记。例如，如果我们想使用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 = MetaData(naming_convention=convention)
>>> user_table = Table('user', metadata,
... Column('id', Integer, primary_key=True),
... Column('version', Integer, primary_key=True),
... Column('data', String(30))
... )
>>> address_table = Table('address', metadata,
... 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 - for additional usage details as well as a listing of all available naming components.
The Importance of Naming Constraints - 在Alembic文档中。
版本0.9.2新增：添加了MetaData.naming_convention参数。
CheckConstraint对象是针对任意SQL表达式配置的，该表达式可以包含任意数量的列，另外通常使用原始SQL字符串进行配置。因此，与CheckConstraint一起使用的通用约定是我们期望该对象已经拥有一个名称的公约，然后我们使用其他约定元素对其进行了增强。A typical convention is "ck_%(table_name)s_%(constraint_name)s":
metadata = MetaData(
naming_convention={"ck": "ck_%(table_name)s_%(constraint_name)s"}
)
Table('foo', metadata,
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或sql.expression.column()元素来使用它，或者通过声明与表格分开的约束：
metadata = MetaData(
naming_convention={"ck": "ck_%(table_name)s_%(column_0_name)s"}
)
foo = Table('foo', metadata,
Column('value', Integer)
)
CheckConstraint(foo.c.value > 5)或通过内联使用sql.expression.column()：
from sqlalchemy import column
metadata = MetaData(
naming_convention={"ck": "ck_%(table_name)s_%(column_0_name)s"}
)
foo = Table('foo', metadata,
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，它们会生成伴随该类型的CHECK约束。通过发送“name”参数来最直接地设置约束的名字，例如， Boolean.name
Table('foo', metadata,
Column('flag', Boolean(name='ck_foo_flag'))
)命名约定功能也可以与这些类型结合使用，通常通过使用包含%(constraint_name)s的约定，然后将名称应用于类型：
metadata = MetaData(
naming_convention={"ck": "ck_%(table_name)s_%(constraint_name)s"}
)
Table('foo', metadata,
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的CHECK约束；我们可以安全地设置一个没有名字的Boolean类型，即使检查约束有一个命名约定。如果我们针对没有像SQLite或MySQL这样的本机BOOLEAN类型的数据库运行，只会为CHECK约束查阅此约定。
CHECK约束还可以使用column_0_name标记，该标记与SchemaType很好地配合使用，因为这些约束只有一列：
metadata = MetaData(
naming_convention={"ck": "ck_%(table_name)s_%(column_0_name)s"}
)
Table('foo', metadata,
Column('flag', Boolean())
)上述模式将产生：
CREATE TABLE foo (
flag BOOL,
CONSTRAINT ck_foo_flag CHECK (flag IN (0, 1))
)版本1.0更改：不包含%(constraint_name)s的约束命名约定再次与SchemaType约束一起使用。
sqlalchemy.schema。 约束 （ name =无，可推迟=无，开始=无，_create_rule =无，info =无，_type_bound = False ，** dialect_kw ） ¶基础：sqlalchemy.sql.base.DialectKWArgs，sqlalchemy.schema.SchemaItem
表级SQL约束。
__init__(name=None, deferrable=None, initially=None, _create_rule=None, info=None, _type_bound=False, **dialect_kw)¶创建一个SQL约束。
| 参数： |
|
|---|
sqlalchemy.schema。 ColumnCollectionConstraint （ *列，**千瓦 T5> ） T6> ¶ T7>基础：sqlalchemy.schema.ColumnCollectionMixin，sqlalchemy.schema.Constraint
代表ColumnCollection的约束。
__ init __ （ *列，** kw ） T5>| 参数： |
|
|---|
argument_for （ dialect_name，argument_name，默认 ） ¶ T6>argument_for() method of DialectKWArgs为此课程添加一种新的特定于方言的关键字参数。
例如。：
Index.argument_for("mydialect", "length", None)
some_index = Index('a', 'b', mydialect_length=5)The DialectKWArgs.argument_for() method is a per-argument way adding extra arguments to the DefaultDialect.construct_arguments dictionary. 这本词典提供了代表方言的各种模式层次结构所接受的参数名称列表。
新方言通常应该一次性将该字典指定为方言类的数据成员。用于临时添加参数名称的用例通常用于最终用户代码，该代码也使用了使用额外参数的自定义编译方案。
| 参数： |
|
|---|
版本0.9.4中的新功能
contains_column T0> （ T1> COL T2> ） T3> ¶ T4>如果此约束包含给定的列，则返回True。
请注意，此对象还包含属性.columns，它是Column对象的ColumnCollection。
dialect_kwargs T0> ¶ T1>dialect_kwargs 属性 DialectKWArgs指定为此构造的方言特定选项的关键字参数的集合。
这些参数在它们的原始<dialect>_<kwarg>格式中呈现。只包括实际通过的论点；不同于DialectKWArgs.dialect_options集合，其中包含此方言已知的所有选项，包括默认值。
该集合也是可写的；键被接受为形式<dialect>_<kwarg>，其中值将被组合到选项列表中。
版本0.9.2中的新功能
在版本0.9.4中更改： DialectKWArgs.dialect_kwargs集合现在可写入。
也可以看看
DialectKWArgs.dialect_options - nested dictionary form
dialect_options T0> ¶ T1>dialect_options 属性 DialectKWArgs指定为此构造的方言特定选项的关键字参数的集合。
这是一个两级嵌套注册表，键入<dialect_name>和<argument_name>。例如，postgresql_where参数可以定位为：
arg = my_object.dialect_options['postgresql']['where']版本0.9.2中的新功能
也可以看看
DialectKWArgs.dialect_kwargs - flat dictionary form
get_children T0> （ T1> ** kwargs T2> ） T3> ¶ T4>get_children() method of SchemaItem用于允许SchemaVisitor访问
信息 T0> ¶ T1>info attribute of SchemaItem与对象关联的信息字典，允许用户定义的数据与这个SchemaItem关联。
kwargs T0> ¶ T1>kwargs 属性 DialectKWArgs引用 T0> ¶ T1>quote attribute of SchemaItem对于具有name字段的模式项，返回传递给此模式对象的quote标志的值。
从版本0.9开始弃用：使用<obj>.name.quote
sqlalchemy.schema.CheckConstraint(sqltext, name=None, deferrable=None, initially=None, table=None, info=None, _create_rule=None, _autoattach=True, _type_bound=False)¶基础：sqlalchemy.schema.ColumnCollectionConstraint
表或列级CHECK约束。
可以包含在表或列的定义中。
__init__(sqltext, name=None, deferrable=None, initially=None, table=None, info=None, _create_rule=None, _autoattach=True, _type_bound=False)¶构造一个CHECK约束。
| 参数： |
|
|---|
argument_for （ dialect_name，argument_name，默认 ） ¶ T6>argument_for() method of DialectKWArgs为此课程添加一种新的特定于方言的关键字参数。
例如。：
Index.argument_for("mydialect", "length", None)
some_index = Index('a', 'b', mydialect_length=5)The DialectKWArgs.argument_for() method is a per-argument way adding extra arguments to the DefaultDialect.construct_arguments dictionary. 这本词典提供了代表方言的各种模式层次结构所接受的参数名称列表。
新方言通常应该一次性将该字典指定为方言类的数据成员。用于临时添加参数名称的用例通常用于最终用户代码，该代码也使用了使用额外参数的自定义编译方案。
| 参数： |
|
|---|
版本0.9.4中的新功能
contains_column T0> （ T1> COL T2> ） T3> ¶ T4>contains_column() method of ColumnCollectionConstraint如果此约束包含给定的列，则返回True。
请注意，此对象还包含属性.columns，它是Column对象的ColumnCollection。
dialect_kwargs T0> ¶ T1>dialect_kwargs 属性 DialectKWArgs指定为此构造的方言特定选项的关键字参数的集合。
这些参数在它们的原始<dialect>_<kwarg>格式中呈现。只包括实际通过的论点；不同于DialectKWArgs.dialect_options集合，其中包含此方言已知的所有选项，包括默认值。
该集合也是可写的；键被接受为形式<dialect>_<kwarg>，其中值将被组合到选项列表中。
版本0.9.2中的新功能
在版本0.9.4中更改： DialectKWArgs.dialect_kwargs集合现在可写入。
也可以看看
DialectKWArgs.dialect_options - nested dictionary form
dialect_options T0> ¶ T1>dialect_options 属性 DialectKWArgs指定为此构造的方言特定选项的关键字参数的集合。
这是一个两级嵌套注册表，键入<dialect_name>和<argument_name>。例如，postgresql_where参数可以定位为：
arg = my_object.dialect_options['postgresql']['where']版本0.9.2中的新功能
也可以看看
DialectKWArgs.dialect_kwargs - flat dictionary form
get_children T0> （ T1> ** kwargs T2> ） T3> ¶ T4>get_children() method of SchemaItem用于允许SchemaVisitor访问
信息 T0> ¶ T1>info attribute of SchemaItem与对象关联的信息字典，允许用户定义的数据与这个SchemaItem关联。
kwargs T0> ¶ T1>kwargs 属性 DialectKWArgs引用 T0> ¶ T1>quote attribute of SchemaItem对于具有name字段的模式项，返回传递给此模式对象的quote标志的值。
从版本0.9开始弃用：使用<obj>.name.quote
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)¶基础：sqlalchemy.sql.base.DialectKWArgs，sqlalchemy.schema.SchemaItem
定义两列之间的依赖关系。
ForeignKey被指定为Column对象的参数，例如：
t = Table("remote_table", metadata,
Column("remote_id", ForeignKey("main_table.id"))
)请注意，ForeignKey只是一个定义两列之间相关性的标记对象。实际约束在所有情况下都由ForeignKeyConstraint对象表示。This object will be generated automatically when a ForeignKey is associated with a Column which in turn is associated with a Table. Conversely, when ForeignKeyConstraint is applied to a Table, ForeignKey markers are automatically generated to be present on each associated Column, which are also associated with the constraint object.
请注意，您无法使用ForeignKey对象定义“复合”外键约束，该约束是多个父/子列分组之间的约束。要定义此分组，必须使用ForeignKeyConstraint对象，并将其应用于Table。关联的ForeignKey对象是自动创建的。
与单个Column对象关联的ForeignKey对象在该列的foreign_keys集合中可用。
外键配置的更多示例在Defining Foreign Keys中。
__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)¶构建一个列级别的FOREIGN KEY。
The ForeignKey object when constructed generates a ForeignKeyConstraint which is associated with the parent Table object’s collection of constraints.
| 参数： |
|
|---|
argument_for （ dialect_name，argument_name，默认 ） ¶ T6>argument_for() method of DialectKWArgs为此课程添加一种新的特定于方言的关键字参数。
例如。：
Index.argument_for("mydialect", "length", None)
some_index = Index('a', 'b', mydialect_length=5)The DialectKWArgs.argument_for() method is a per-argument way adding extra arguments to the DefaultDialect.construct_arguments dictionary. 这本词典提供了代表方言的各种模式层次结构所接受的参数名称列表。
新方言通常应该一次性将该字典指定为方言类的数据成员。用于临时添加参数名称的用例通常用于最终用户代码，该代码也使用了使用额外参数的自定义编译方案。
| 参数： |
|
|---|
版本0.9.4中的新功能
列 T0> ¶ T1>返回由ForeignKey引用的目标Column。
如果没有建立目标列，则会引发异常。
版本0.9.0中已更改：只要ForeignKey对象和它所引用的远程列都与同一个MetaData对象关联，就立即发生外键目标列解析。
复制 T0> （ T1> 架构=无 T2> ） T3> ¶ T4>生成这个ForeignKey对象的副本。
新的ForeignKey不会绑定到任何Column。
This method is usually used by the internal copy procedures of Column, Table, and MetaData.
| 参数： | schema¶ – The returned ForeignKey will reference the original table and column name, qualified by the given string schema name. |
|---|
dialect_kwargs T0> ¶ T1>dialect_kwargs 属性 DialectKWArgs指定为此构造的方言特定选项的关键字参数的集合。
这些参数在它们的原始<dialect>_<kwarg>格式中呈现。只包括实际通过的论点；不同于DialectKWArgs.dialect_options集合，其中包含此方言已知的所有选项，包括默认值。
该集合也是可写的；键被接受为形式<dialect>_<kwarg>，其中值将被组合到选项列表中。
版本0.9.2中的新功能
在版本0.9.4中更改： DialectKWArgs.dialect_kwargs集合现在可写入。
也可以看看
DialectKWArgs.dialect_options - nested dictionary form
dialect_options T0> ¶ T1>dialect_options 属性 DialectKWArgs指定为此构造的方言特定选项的关键字参数的集合。
这是一个两级嵌套注册表，键入<dialect_name>和<argument_name>。例如，postgresql_where参数可以定位为：
arg = my_object.dialect_options['postgresql']['where']版本0.9.2中的新功能
也可以看看
DialectKWArgs.dialect_kwargs - flat dictionary form
get_children T0> （ T1> ** kwargs T2> ） T3> ¶ T4>get_children() method of SchemaItem用于允许SchemaVisitor访问
get_referent T0> （ T1> 表 T2> ） T3> ¶ T4>返回此ForeignKey引用的Table中的Column。
如果ForeignKey没有引用给定的Table，则返回None。
信息 T0> ¶ T1>info attribute of SchemaItem与对象关联的信息字典，允许用户定义的数据与这个SchemaItem关联。
kwargs T0> ¶ T1>kwargs 属性 DialectKWArgs引用 T0> ¶ T1>quote attribute of SchemaItem对于具有name字段的模式项，返回传递给此模式对象的quote标志的值。
从版本0.9开始弃用：使用<obj>.name.quote
引用 T0> （ T1> 表 T2> ） T3> ¶ T4>如果给定的Table被此ForeignKey引用，则返回True。
target_fullname T0> ¶ T1>为ForeignKey返回一个基于字符串的'列规范'。
这通常等同于首先传递给对象构造函数的基于字符串的“tablename.colname”参数。
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)¶基础：sqlalchemy.schema.ColumnCollectionConstraint
表级别的FOREIGN KEY约束。
定义单列或复合FOREIGN KEY ... REFERENCES约束。For a no-frills, single column foreign key, adding a ForeignKey to the definition of a Column is a shorthand equivalent for an unnamed, single column ForeignKeyConstraint.
外键配置示例位于Defining Foreign Keys中。
__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)¶构建一个支持复合的FOREIGN KEY。
| 参数： |
|
|---|
argument_for （ dialect_name，argument_name，默认 ） ¶ T6>argument_for() method of DialectKWArgs为此课程添加一种新的特定于方言的关键字参数。
例如。：
Index.argument_for("mydialect", "length", None)
some_index = Index('a', 'b', mydialect_length=5)The DialectKWArgs.argument_for() method is a per-argument way adding extra arguments to the DefaultDialect.construct_arguments dictionary. 这本词典提供了代表方言的各种模式层次结构所接受的参数名称列表。
新方言通常应该一次性将该字典指定为方言类的数据成员。用于临时添加参数名称的用例通常用于最终用户代码，该代码也使用了使用额外参数的自定义编译方案。
| 参数： |
|
|---|
版本0.9.4中的新功能
column_keys T0> ¶ T1>返回表示本ForeignKeyConstraint中本地列的字符串键列表。
该列表是发送给ForeignKeyConstraint的构造函数的原始字符串参数，或者如果约束已使用Column对象初始化，则为每个元素的字符串.key。
版本1.0.0中的新功能
contains_column T0> （ T1> COL T2> ） T3> ¶ T4>contains_column() method of ColumnCollectionConstraint如果此约束包含给定的列，则返回True。
请注意，此对象还包含属性.columns，它是Column对象的ColumnCollection。
dialect_kwargs T0> ¶ T1>dialect_kwargs 属性 DialectKWArgs指定为此构造的方言特定选项的关键字参数的集合。
这些参数在它们的原始<dialect>_<kwarg>格式中呈现。只包括实际通过的论点；不同于DialectKWArgs.dialect_options集合，其中包含此方言已知的所有选项，包括默认值。
该集合也是可写的；键被接受为形式<dialect>_<kwarg>，其中值将被组合到选项列表中。
版本0.9.2中的新功能
在版本0.9.4中更改： DialectKWArgs.dialect_kwargs集合现在可写入。
也可以看看
DialectKWArgs.dialect_options - nested dictionary form
dialect_options T0> ¶ T1>dialect_options 属性 DialectKWArgs指定为此构造的方言特定选项的关键字参数的集合。
这是一个两级嵌套注册表，键入<dialect_name>和<argument_name>。例如，postgresql_where参数可以定位为：
arg = my_object.dialect_options['postgresql']['where']版本0.9.2中的新功能
也可以看看
DialectKWArgs.dialect_kwargs - flat dictionary form
get_children T0> （ T1> ** kwargs T2> ） T3> ¶ T4>get_children() method of SchemaItem用于允许SchemaVisitor访问
信息 T0> ¶ T1>info attribute of SchemaItem与对象关联的信息字典，允许用户定义的数据与这个SchemaItem关联。
kwargs T0> ¶ T1>kwargs 属性 DialectKWArgs引用 T0> ¶ T1>quote attribute of SchemaItem对于具有name字段的模式项，返回传递给此模式对象的quote标志的值。
从版本0.9开始弃用：使用<obj>.name.quote
referred_table T0> ¶ T1>这个ForeignKeyConstraint引用的Table对象。
这是一个动态计算的属性，如果约束和/或父表尚未与包含引用表的元数据集合关联，则该属性可能不可用。
版本1.0.0中的新功能
sqlalchemy.schema。 PrimaryKeyConstraint （ *列，**千瓦 T5> ） T6> ¶ T7>基础：sqlalchemy.schema.ColumnCollectionConstraint
表级PRIMARY KEY约束。
The PrimaryKeyConstraint object is present automatically on any Table object; it is assigned a set of Column objects corresponding to those marked with the Column.primary_key flag:
>>> 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的列将被忽略。此行为旨在向后兼容以前的行为。
版本0.9.2更改：除了标记为primary_key=True的列以外，在PrimaryKeyConstraint中使用列的混合现在会发出警告if列表不匹配。忽略那些仅标有标志的列的最终行为目前保持向后兼容；此警告可能会在未来版本中引发异常。
For the use case where specific options are to be specified on the PrimaryKeyConstraint, but the usual style of using primary_key=True flags is still desirable, an empty PrimaryKeyConstraint may be specified, which will take on the primary key column collection from the Table based on the flags:
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的列将被收集到空约束的列集合中。
argument_for （ dialect_name，argument_name，默认 ） ¶ T6>argument_for() method of DialectKWArgs为此课程添加一种新的特定于方言的关键字参数。
例如。：
Index.argument_for("mydialect", "length", None)
some_index = Index('a', 'b', mydialect_length=5)The DialectKWArgs.argument_for() method is a per-argument way adding extra arguments to the DefaultDialect.construct_arguments dictionary. 这本词典提供了代表方言的各种模式层次结构所接受的参数名称列表。
新方言通常应该一次性将该字典指定为方言类的数据成员。用于临时添加参数名称的用例通常用于最终用户代码，该代码也使用了使用额外参数的自定义编译方案。
| 参数： |
|
|---|
版本0.9.4中的新功能
contains_column T0> （ T1> COL T2> ） T3> ¶ T4>contains_column() method of ColumnCollectionConstraint如果此约束包含给定的列，则返回True。
请注意，此对象还包含属性.columns，它是Column对象的ColumnCollection。
dialect_kwargs T0> ¶ T1>dialect_kwargs 属性 DialectKWArgs指定为此构造的方言特定选项的关键字参数的集合。
这些参数在它们的原始<dialect>_<kwarg>格式中呈现。只包括实际通过的论点；不同于DialectKWArgs.dialect_options集合，其中包含此方言已知的所有选项，包括默认值。
该集合也是可写的；键被接受为形式<dialect>_<kwarg>，其中值将被组合到选项列表中。
版本0.9.2中的新功能
在版本0.9.4中更改： DialectKWArgs.dialect_kwargs集合现在可写入。
也可以看看
DialectKWArgs.dialect_options - nested dictionary form
dialect_options T0> ¶ T1>dialect_options 属性 DialectKWArgs指定为此构造的方言特定选项的关键字参数的集合。
这是一个两级嵌套注册表，键入<dialect_name>和<argument_name>。例如，postgresql_where参数可以定位为：
arg = my_object.dialect_options['postgresql']['where']版本0.9.2中的新功能
也可以看看
DialectKWArgs.dialect_kwargs - flat dictionary form
get_children T0> （ T1> ** kwargs T2> ） T3> ¶ T4>get_children() method of SchemaItem用于允许SchemaVisitor访问
信息 T0> ¶ T1>info attribute of SchemaItem与对象关联的信息字典，允许用户定义的数据与这个SchemaItem关联。
kwargs T0> ¶ T1>kwargs 属性 DialectKWArgs引用 T0> ¶ T1>quote attribute of SchemaItem对于具有name字段的模式项，返回传递给此模式对象的quote标志的值。
从版本0.9开始弃用：使用<obj>.name.quote
sqlalchemy.schema.UniqueConstraint(*columns, **kw)¶基础：sqlalchemy.schema.ColumnCollectionConstraint
表级UNIQUE约束。
定义单列或复合UNIQUE约束。对于简单的单列约束，将unique=True添加到Column定义中是对未命名的单列UniqueConstraint的缩写。
__ init __ （ *列，** kw ） T5>__init__() method of ColumnCollectionConstraint| 参数： |
|
|---|
argument_for （ dialect_name，argument_name，默认 ） ¶ T6>argument_for() method of DialectKWArgs为此课程添加一种新的特定于方言的关键字参数。
例如。：
Index.argument_for("mydialect", "length", None)
some_index = Index('a', 'b', mydialect_length=5)The DialectKWArgs.argument_for() method is a per-argument way adding extra arguments to the DefaultDialect.construct_arguments dictionary. 这本词典提供了代表方言的各种模式层次结构所接受的参数名称列表。
新方言通常应该一次性将该字典指定为方言类的数据成员。用于临时添加参数名称的用例通常用于最终用户代码，该代码也使用了使用额外参数的自定义编译方案。
| 参数： |
|
|---|
版本0.9.4中的新功能
contains_column T0> （ T1> COL T2> ） T3> ¶ T4>contains_column() method of ColumnCollectionConstraint如果此约束包含给定的列，则返回True。
请注意，此对象还包含属性.columns，它是Column对象的ColumnCollection。
dialect_kwargs T0> ¶ T1>dialect_kwargs 属性 DialectKWArgs指定为此构造的方言特定选项的关键字参数的集合。
这些参数在它们的原始<dialect>_<kwarg>格式中呈现。只包括实际通过的论点；不同于DialectKWArgs.dialect_options集合，其中包含此方言已知的所有选项，包括默认值。
该集合也是可写的；键被接受为形式<dialect>_<kwarg>，其中值将被组合到选项列表中。
版本0.9.2中的新功能
在版本0.9.4中更改： DialectKWArgs.dialect_kwargs集合现在可写入。
也可以看看
DialectKWArgs.dialect_options - nested dictionary form
dialect_options T0> ¶ T1>dialect_options 属性 DialectKWArgs指定为此构造的方言特定选项的关键字参数的集合。
这是一个两级嵌套注册表，键入<dialect_name>和<argument_name>。例如，postgresql_where参数可以定位为：
arg = my_object.dialect_options['postgresql']['where']版本0.9.2中的新功能
也可以看看
DialectKWArgs.dialect_kwargs - flat dictionary form
get_children T0> （ T1> ** kwargs T2> ） T3> ¶ T4>get_children() method of SchemaItem用于允许SchemaVisitor访问
信息 T0> ¶ T1>info attribute of SchemaItem与对象关联的信息字典，允许用户定义的数据与这个SchemaItem关联。
kwargs T0> ¶ T1>kwargs 属性 DialectKWArgs引用 T0> ¶ T1>quote attribute of SchemaItem对于具有name字段的模式项，返回传递给此模式对象的quote标志的值。
从版本0.9开始弃用：使用<obj>.name.quote
sqlalchemy.schema.conv(cls, 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。为了确保该名称不被重复修改，使用schema.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')))在上面的地方，schema.conv()标记表明这里的约束名称是final的，名称将呈现为"ck_t_x5"而不是"ck_t_ck_t_x5"
版本0.9.4中的新功能
Indexes can be created anonymously (using an auto-generated name ix_<column label>) for a single column using the inline index keyword on Column, which also modifies the usage of unique to apply the uniqueness to the index itself, instead of adding a separate UNIQUE constraint. 对于具有特定名称或包含多个列的索引，请使用需要名称的Index结构。
下面我们举例说明一个Table，其中有几个Index对象关联。“CREATE INDEX”的DDL在表的create语句之后立即发布：
meta = MetaData()
mytable = Table('mytable', meta,
# 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)
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中的“内联”定义，使用字符串名称来标识列：
meta = MetaData()
mytable = Table('mytable', meta,
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))0.8版新增功能： Index支持SQL表达式和函数以及普通列。
sqlalchemy.schema.Index(name, *expressions, **kw)¶基础：sqlalchemy.sql.base.DialectKWArgs，sqlalchemy.schema.ColumnCollectionMixin，sqlalchemy.schema.SchemaItem
表级索引。
定义一个复合（一个或多个列）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结构与表结合的Column对象结合使用：
Index("some_index", func.lower(sometable.c.name))0.8版本的新功能：支持功能和基于表达式的索引。
通过内联声明或使用Table.append_constraint()，还可以将Index与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)"))
)New in version 0.9.5: the text() construct may be used to specify Index expressions, provided the Index is explicitly associated with the Table.
也可以看看
Postgresql-Specific Index Options - 可用于Index构造的PostgreSQL特定选项。
MySQL Specific Index Options - 可用于Index构造的特定于MySQL的选项。
Clustered Index Support - 可用于Index构造的MSSQL特定选项。
__init__(name, *expressions, **kw)¶构造一个索引对象。
| 参数： |
|
|---|
argument_for （ dialect_name，argument_name，默认 ） ¶ T6>argument_for() method of DialectKWArgs为此课程添加一种新的特定于方言的关键字参数。
例如。：
Index.argument_for("mydialect", "length", None)
some_index = Index('a', 'b', mydialect_length=5)The DialectKWArgs.argument_for() method is a per-argument way adding extra arguments to the DefaultDialect.construct_arguments dictionary. 这本词典提供了代表方言的各种模式层次结构所接受的参数名称列表。
新方言通常应该一次性将该字典指定为方言类的数据成员。用于临时添加参数名称的用例通常用于最终用户代码，该代码也使用了使用额外参数的自定义编译方案。
| 参数： |
|
|---|
版本0.9.4中的新功能
结合 T0> ¶ T1>返回与此索引关联的可连接。
创建 T0> （ T1> 绑定=无 T2> ） T3> ¶ T4>使用给定的Connectable进行连接，为此Index发出CREATE语句。
dialect_kwargs T0> ¶ T1>dialect_kwargs 属性 DialectKWArgs指定为此构造的方言特定选项的关键字参数的集合。
这些参数在它们的原始<dialect>_<kwarg>格式中呈现。只包括实际通过的论点；不同于DialectKWArgs.dialect_options集合，其中包含此方言已知的所有选项，包括默认值。
该集合也是可写的；键被接受为形式<dialect>_<kwarg>，其中值将被组合到选项列表中。
版本0.9.2中的新功能
在版本0.9.4中更改： DialectKWArgs.dialect_kwargs集合现在可写入。
也可以看看
DialectKWArgs.dialect_options - nested dictionary form
dialect_options T0> ¶ T1>dialect_options 属性 DialectKWArgs指定为此构造的方言特定选项的关键字参数的集合。
这是一个两级嵌套注册表，键入<dialect_name>和<argument_name>。例如，postgresql_where参数可以定位为：
arg = my_object.dialect_options['postgresql']['where']版本0.9.2中的新功能
也可以看看
DialectKWArgs.dialect_kwargs - flat dictionary form
降 T0> （ T1> 绑定=无 T2> ） T3> ¶ T4>使用给定的Connectable进行连接，为此Index发出DROP语句。
也可以看看
get_children T0> （ T1> ** kwargs T2> ） T3> ¶ T4>get_children() method of SchemaItem用于允许SchemaVisitor访问
信息 T0> ¶ T1>info attribute of SchemaItem与对象关联的信息字典，允许用户定义的数据与这个SchemaItem关联。
kwargs T0> ¶ T1>kwargs 属性 DialectKWArgs引用 T0> ¶ T1>quote attribute of SchemaItem对于具有name字段的模式项，返回传递给此模式对象的quote标志的值。
从版本0.9开始弃用：使用<obj>.name.quote
网站内容由SQLAlchemy作者和贡献者版权所有。SQLAlchemy及其文档在MIT许可下获得许可。
SQLAlchemy是Michael Bayer的商标。mike（＆）zzzcomputing.com保留所有权利。