用元数据描述数据库

优质

小牛编辑

138浏览

2023-12-01

本节讨论了 Table ， Column 和 MetaData 物体。

元数据实体的集合存储在适当命名的对象中。 MetaData ：：

from sqlalchemy import *

metadata_obj = MetaData()

MetaData 是一个容器对象，它将描述的数据库（或多个数据库）的许多不同功能放在一起。

要表示表，请使用 Table 班级。它的两个主要参数是表名，然后是 MetaData 它将与之关联的对象。其余的位置参数主要是 Column 描述每列的对象：

user = Table('user', metadata_obj,
    Column('user_id', Integer, primary_key=True),
    Column('user_name', String(16), nullable=False),
    Column('email_address', String(60)),
    Column('nickname', String(50), nullable=False)
)

上面是一张叫做 user 描述，其中包含四列。表的主键由 user_id 列。可以为多个列分配 primary_key=True 表示多列主键的标志，称为 混合成的 主键。

还要注意，每一列都使用与泛型类型相对应的对象来描述其数据类型，例如 Integer 和 String . SQLAlchemy具有数十种不同类型的特殊性以及创建自定义类型的能力。有关类型系统的文档，请访问列和数据类型 .

访问表和列

这个 MetaData 对象包含我们与之关联的所有架构构造。它支持一些访问这些表对象的方法，例如 sorted_tables 访问器，返回每个访问器的列表 Table 按外键依赖项的顺序排列的对象（即，每个表前面都有它引用的所有表）：：

>>> for t in metadata_obj.sorted_tables:
...    print(t.name)
user
user_preference
invoice
invoice_item

在大多数情况下，个人 Table 对象已显式声明，这些对象通常作为应用程序中的模块级变量直接访问。曾经一次 Table 它有一整套访问器，允许检查其属性。给出以下内容 Table 定义：

employees = Table('employees', metadata_obj,
    Column('employee_id', Integer, primary_key=True),
    Column('employee_name', String(60), nullable=False),
    Column('employee_dept', Integer, ForeignKey("departments.department_id"))
)

注意 ForeignKey 此表中使用的对象-此构造定义对远程表的引用，并在定义外键 . 访问此表信息的方法包括：

# access the column "employee_id":
employees.columns.employee_id

# or just
employees.c.employee_id

# via string
employees.c['employee_id']

# iterate through all columns
for c in employees.c:
    print(c)

# get the table's primary key columns
for primary_key in employees.primary_key:
    print(primary_key)

# get the table's foreign key objects:
for fkey in employees.foreign_keys:
    print(fkey)

# access the table's MetaData:
employees.metadata

# access the table's bound Engine or Connection, if its MetaData is bound:
employees.bind

# access a column's name, type, nullable, primary key, foreign key
employees.c.employee_id.name
employees.c.employee_id.type
employees.c.employee_id.nullable
employees.c.employee_id.primary_key
employees.c.employee_dept.foreign_keys

# get the "key" of a column, which defaults to its name, but can
# be any user-defined string:
employees.c.employee_name.key

# access a column's table:
employees.c.employee_id.table is employees

# get the table related by a foreign key
list(employees.c.employee_dept.foreign_keys)[0].column.table

小技巧

这个 FromClause.c 集合，与 FromClause.columns 集合，是 ColumnCollection ，它提供了一个 dictionary-like interface 添加到列集合。名称通常像属性名称一样被访问，例如 employees.c.employee_name 。但是，对于带有空格的特殊名称或那些与字典方法的名称匹配的名称，如 ColumnCollection.keys() 或 ColumnCollection.values() ，则必须使用索引访问，例如 employees.c['values'] 或 employees.c["some column"] 。看见 ColumnCollection 了解更多信息。

创建和删除数据库表

一旦你定义了一些 Table 对象，假设您正在使用一个全新的数据库，您可能要做的一件事是为这些表及其相关构造发出create语句（顺便说一句，也很可能是不要要做到这一点，如果您已经有了一些首选的方法，例如数据库或现有脚本系统中包含的工具（如果是这样的话，请随意跳过这一部分）-SQLAlchemy不要求使用它来创建表）。

发布create的通常方法是使用 create_all() 上 MetaData 对象。此方法将发出查询，首先检查每个单独表的存在性，如果未找到，将发出create语句：

engine = create_engine('sqlite:///:memory:')

metadata_obj = MetaData()

user = Table('user', metadata_obj,
    Column('user_id', Integer, primary_key=True),
    Column('user_name', String(16), nullable=False),
    Column('email_address', String(60), key='email'),
    Column('nickname', String(50), nullable=False)
)

user_prefs = Table('user_prefs', 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))
)

sqlmetadata_obj.create_all(engine)
PRAGMA table_info(user){}
CREATE TABLE user(
        user_id INTEGER NOT NULL PRIMARY KEY,
        user_name VARCHAR(16) NOT NULL,
        email_address VARCHAR(60),
        nickname VARCHAR(50) NOT NULL
)
PRAGMA table_info(user_prefs){}
CREATE TABLE user_prefs(
        pref_id INTEGER NOT NULL PRIMARY KEY,
        user_id INTEGER NOT NULL REFERENCES user(user_id),
        pref_name VARCHAR(40) NOT NULL,
        pref_value VARCHAR(100)
)

create_all() 在通常与表定义本身内联的表之间创建外键约束，因此，它还按照表的依赖关系的顺序生成表。可以选择更改此行为，以便 ALTER TABLE 而是使用。

使用 drop_all() 方法。这个方法与 create_all() -首先检查每个表的存在情况，然后按依赖关系的相反顺序删除表。

创建和删除单个表可以通过 create() 和 drop() 方法 Table . 默认情况下，无论表是否存在，这些方法都会发出create或drop：

engine = create_engine('sqlite:///:memory:')

metadata_obj = MetaData()

employees = Table('employees', metadata_obj,
    Column('employee_id', Integer, primary_key=True),
    Column('employee_name', String(60), nullable=False, key='name'),
    Column('employee_dept', Integer, ForeignKey("departments.department_id"))
)
sqlemployees.create(engine)
CREATE TABLE employees(
employee_id SERIAL NOT NULL PRIMARY KEY,
employee_name VARCHAR(60) NOT NULL,
employee_dept INTEGER REFERENCES departments(department_id)
)
{}

drop() 方法：

sqlemployees.drop(engine)
DROP TABLE employees
{}

要启用“先检查现有表”逻辑，请添加 checkfirst=True 参数 create() 或 drop() ：：

employees.create(engine, checkfirst=True)
employees.drop(engine, checkfirst=False)

通过迁移更改数据库对象

虽然SQLAlchemy直接支持为模式构造发出CREATE和DROP语句，但是通常通过alter语句以及其他特定于数据库的构造来更改这些构造的能力不在SQLAlchemy本身的范围之内。而手工发出ALTER语句和类似语句很容易，比如通过传递 text() 构造到 Connection.execute() 或通过使用 DDL 构造，使用模式迁移工具自动维护与应用程序代码相关的数据库模式是一种常见的实践。

SQLAlchemy项目提供了 Alembic 用于此目的的迁移工具。Alembic的特点是高度可定制的环境和最低限度的使用模式，支持事务性DDL、“候选”迁移的自动生成、生成SQL脚本的“脱机”模式以及对分支解析的支持。

Alembic取代 SQLAlchemy-Migrate 项目，它是SQLAlchemy的原始迁移工具，现在被认为是遗留的。

指定架构名称

大多数数据库支持多个“模式”的概念，即引用备用表集和其他构造的名称空间。“模式”的服务器端几何结构有多种形式，包括特定数据库范围内的“模式”名称（例如PostgreSQL模式）、命名的同级数据库（例如MySQL/MariaDB访问同一服务器上的其他数据库）以及其他概念，如由其他用户名（Oracle、SQL server）拥有的表，甚至包括请参阅备用数据库文件（SQLite ATTACH）或远程服务器（Oracle DBLINK with synonymes）。

以上所有方法的共同点（主要是）是有一种方法可以使用字符串名称来引用这个备用表集。SQLAlchemy将此名称称为 架构名称 . 在SQLAlchemy中，这只不过是一个与 Table 对象，然后以适合于目标数据库的方式呈现为SQL语句，以便在其远程“schema”中引用该表，无论目标数据库上的机制是什么。

“schema”名称可以直接与 Table 使用 Table.schema 参数；当将ORM与 declarative table 配置，则使用 __table_args__ 参数字典。

“schema”名称也可以与 MetaData 对象，它将自动对所有对象生效 Table 与之关联的对象 MetaData 他们没有指定自己的名字。最后，SQLAlchemy还支持“动态”模式名系统，该系统通常用于多租户应用程序，例如 Table 元数据可以在每个连接或每个语句的基础上引用一组动态配置的模式名称。

参见

具有声明性表的显式架构名称 -使用ORM时指定架构名称 declarative table 配置

最基本的例子是 Table.schema 使用核心的参数 Table 对象如下：

metadata_obj = MetaData()

financial_info = Table(
    'financial_info',
    metadata_obj,
    Column('id', Integer, primary_key=True),
    Column('value', String(100), nullable=False),
    schema='remote_banks'
)

使用此 Table ，如下面的SELECT语句，将显式限定表名 financial_info 与 remote_banks 架构名称：

>>> print(select(financial_info))
SELECT remote_banks.financial_info.id, remote_banks.financial_info.value
FROM remote_banks.financial_info

当A Table 对象是用显式架构名称声明的，它存储在内部 MetaData 命名空间，使用架构和表名的组合。我们可以在 MetaData.tables 通过搜索密钥收集 'remote_banks.financial_info' ：：

>>> metadata_obj.tables['remote_banks.financial_info']
Table('financial_info', MetaData(),
Column('id', Integer(), table=<financial_info>, primary_key=True, nullable=False),
Column('value', String(length=100), table=<financial_info>, nullable=False),
schema='remote_banks')

当引用要与一起使用的表时，也必须使用此虚线名称 ForeignKey 或 ForeignKeyConstraint 对象，即使引用表也在同一架构中：

customer = Table(
    "customer",
    metadata_obj,
    Column('id', Integer, primary_key=True),
    Column('financial_info_id', ForeignKey("remote_banks.financial_info.id")),
    schema='remote_banks'
)

这个 Table.schema 参数也可以与某些方言一起使用，以表示指向特定表的多个标记（例如点）路径。这在Microsoft SQL Server之类的数据库中尤其重要，因为在这些数据库中，常常有点“数据库/所有者”标记。令牌可以一次直接放在名称中，例如：

schema="dbo.scott"

参见

多部分架构名称 -描述如何将点模式名称与SQL Server方言一起使用。

使用元数据指定默认架构名称

这个 MetaData 对象还可以为所有 Table.schema 通过传递 MetaData.schema 最高层的争论 MetaData 结构：

metadata_obj = MetaData(schema="remote_banks")

financial_info = Table(
    'financial_info',
    metadata_obj,
    Column('id', Integer, primary_key=True),
    Column('value', String(100), nullable=False),
)

以上，任何 Table 对象（或 Sequence 对象与 MetaData )这就留下了 Table.schema 参数的默认值为 None 将改为将参数设置为值 "remote_banks" . 这包括 Table 在 MetaData 使用架构限定名，即：

metadata_obj.tables['remote_banks.financial_info']

当使用 ForeignKey 或 ForeignKeyConstraint 对象引用此表时，可以使用架构限定名或非架构限定名来引用 remote_banks.financial_info 表：

# either will work:

refers_to_financial_info = Table(
    'refers_to_financial_info',
    metadata_obj,
    Column('id', Integer, primary_key=True),
    Column('fiid', ForeignKey('financial_info.id')),
)


# or

refers_to_financial_info = Table(
    'refers_to_financial_info',
    metadata_obj,
    Column('id', Integer, primary_key=True),
    Column('fiid', ForeignKey('remote_banks.financial_info.id')),
)

当使用 MetaData 设置的对象 MetaData.schema ，A Table 如果希望指定它不应该是模式限定的，则可以使用特殊符号 BLANK_SCHEMA ：：

from sqlalchemy import BLANK_SCHEMA

metadata_obj = MetaData(schema="remote_banks")

financial_info = Table(
    'financial_info',
    metadata_obj,
    Column('id', Integer, primary_key=True),
    Column('value', String(100), nullable=False),
    schema=BLANK_SCHEMA  # will not use "remote_banks"
)

参见

MetaData.schema

应用动态模式命名约定

使用的名称 Table.schema 参数还可以应用于基于每个连接或每次执行的动态查找，因此，例如在多租户情况下，每个事务或语句都可以针对更改的特定模式名称集。部门模式名称的翻译描述如何使用此功能。

参见

模式名称的翻译

为新连接设置默认架构

以上方法都是指在SQL语句中包含显式模式名的方法。事实上，数据库连接的特点是“默认”模式的概念，即如果表名没有明确的模式限定，则会出现“模式”（或数据库、所有者等）的名称。这些名称通常在登录级别配置，例如在连接到PostgreSQL数据库时，默认的“schema”称为“public”。

通常情况下，默认的“schema”不能通过登录名本身设置，而是在每次连接时使用诸如PostgreSQL上的“setsearch_PATH”或Oracle上的“ALTER SESSION”之类的语句进行配置。这些方法可以通过使用 PoolEvents.connect() 事件，允许在首次创建DBAPI连接时访问它。例如，要将Oracle CURRENT U SCHEMA变量设置为备用名称：

from sqlalchemy import event
from sqlalchemy import create_engine

engine = create_engine("oracle+cx_oracle://scott:tiger@tsn_name")

@event.listens_for(engine, "connect", insert=True)
def set_current_schema(dbapi_connection, connection_record):
    cursor_obj = dbapi_connection.cursor()
    cursor_obj.execute("ALTER SESSION SET CURRENT_SCHEMA=%s" % schema_name)
    cursor_obj.close()

上面， set_current_schema() 当发生上述情况时，事件处理程序将立即发生 Engine 第一个连接；当事件“插入”到处理程序列表的开头时，它也将在运行方言自己的事件处理程序之前发生，特别是包括将确定连接“默认模式”的事件处理程序。

对于其他数据库，请参考数据库和/或方言文档，以获取有关如何配置默认模式的特定信息。

在 1.4.0b2 版更改: 上面的方法现在不需要建立额外的事件处理程序。

参见

在连接上设置备用搜索路径 -在《PostgreSQL》方言文献。

后端特定选项

Table 支持特定于数据库的选项。例如，mysql有不同的表后端类型，包括“myisam”和“innodb”。这可以用 Table 使用 mysql_engine ：：

addresses = Table('engine_email_addresses', metadata_obj,
    Column('address_id', Integer, primary_key=True),
    Column('remote_user_id', Integer, ForeignKey(users.c.user_id)),
    Column('email_address', String(20)),
    mysql_engine='InnoDB'
)

其他后端也可能支持表级选项——这些将在每个方言的单独文档部分中描述。

列、表、元数据API

Object Name	Description
Column	表示数据库表中的列。
MetaData	收藏 `Table` 对象及其关联的架构构造。
SchemaItem	定义数据库架构的项的基类。
BLANK_SCHEMA	表示a的符号 `Table` 或 `Sequence` 其架构应为“none”，即使父级 `MetaData` 已指定架构。
Table	表示数据库中的表。
ThreadLocalMetaData	呈现不同 `bind` 在每一条线上。

attribute sqlalchemy.schema.sqlalchemy.schema.sqlalchemy.schema.BLANK_SCHEMA¶

表示a的符号 Table 或 Sequence 其架构应为“none”，即使父级 MetaData 已指定架构。

参见

MetaData.schema

Table.schema

Sequence.schema

1.0.14 新版功能.

class sqlalchemy.schema.Column(*args, **kwargs)¶

表示数据库表中的列。

类签名

class sqlalchemy.schema.Column (sqlalchemy.sql.base.DialectKWArgs, sqlalchemy.schema.SchemaItem, sqlalchemy.sql.expression.ColumnClause)

method sqlalchemy.schema.Column.__eq__(other)¶

inherited from the sqlalchemy.sql.expression.ColumnOperators.__eq__ method of ColumnOperators

实施 == 操作员。

在列上下文中，生成子句 a = b . 如果目标是 None 生产 a IS NULL .

method sqlalchemy.schema.Column.__init__(*args, **kwargs)¶

构建新的 Column 对象。

参数

name¶ -- 数据库中表示的此列的名称。此参数可以是第一个位置参数，也可以通过关键字指定。不包含大写字符的名称将被视为不区分大小写的名称，除非它们是保留字，否则不会被引用。带有任意数量大写字符的名称将被引用并准确发送。请注意，这种行为甚至适用于将大写名称标准化为不区分大小写的数据库，如Oracle。在构造时可以省略“名称”字段，并在该列与 Table . 这是为了支持在 declarative 延伸。
type_¶ -- 列的类型，使用子类的实例指示 TypeEngine . 如果该类型不需要参数，则也可以发送该类型的类，例如：：使用带参数的类型列（“数据”，字符串（50））不使用参数列（“级别”，整数）和 type 参数可以是第二个位置参数，也可以由关键字指定。如果 type 是 None 或者省略，它将首先默认为特殊类型 NullType . 如果和什么时候 Column 用于引用另一列 ForeignKey 和/或 ForeignKeyConstraint ，在对该远程对象解析外键时，远程引用列的类型也将复制到此列。 Column 对象。…versionChanged:：0.9.0支持将类型传播到 Column 从其 ForeignKey 目标得到了改进，应该更加可靠和及时。
*args¶ -- 其他位置参数包括 SchemaItem 将作为列的选项应用的派生构造。其中包括 Constraint ， ForeignKey ， ColumnDefault ， Sequence ， Computed Identity . 在某些情况下，可以使用等效的关键字参数，例如 server_default ， default 和 unique .
autoincrement¶ -- 为整数主键列设置“自动递增”语义。默认值是字符串 "auto" 这表示一个整型的、没有指定客户端或Python端默认值的单列主键应该自动接收自动递增语义；所有其他类型的主键列都不会。这包括那个 DDL 例如PostgreSQL SERIAL或MySQL AUTO_INCREMENT将在表创建过程中为该列发出，并且假定该列在INSERT语句调用时生成新的整数主键值，该主键将由方言检索。当与 Identity 对于支持它的方言，此参数无效。标志可以设置为 True 要指示作为复合（例如多列）主键的一部分的列应该具有自动递增语义，尽管请注意，主键中只有一列可能具有此设置。也可以设置为 True 要在配置了客户端或服务器端默认值的列上指示自动增量语义，但是请注意，并非所有方言都可以将所有默认样式作为“自动增量”来容纳。也可以设置为 False 在数据类型为整数的单列主键上，以禁用该列的自动递增语义。…versionChanged:：1.1自动增量标志现在默认为 "auto" 默认情况下，它仅指示单列整数主键的自动增量语义；对于复合（多列）主键，从不隐式启用自动增量；一如既往， autoincrement=True 最多允许其中一列是“autoincrement”列。 autoincrement=True 也可以设置在 Column 它有一个明确的客户端或服务器端默认值，受制于后端数据库和方言的限制。设置 only 对以下列有效果： 派生的整数（即int、smallint、bigint）。 主键的一部分 * Not referring to another column via ForeignKey, unless the value is specified as 'ignore_fk':: # turn on autoincrement for this column despite # the ForeignKey() Column('id', ForeignKey('other.id'), primary_key=True, autoincrement='ignore_fk') It is typically not desirable to have "autoincrement" enabled on a column that refers to another via foreign key, as such a column is required to refer to a value that originates from elsewhere. The setting has these two effects on columns that meet the above criteria: * 为该列发布的DDL将包含特定于数据库的关键字，用于将该列表示为“auto increment”列，例如mysql上的auto increment、postgresql上的serial和ms-sql上的identity。它确实 not 为sqlite发出autoincrement，因为这是一个特殊的sqlite标志，自动增量行为不需要它。…参阅： SQLite自动递增行为 *该列将被视为可用，使用后端数据库特有的“autoincrement”方法，例如调用 cursor.lastrowid ，使用在insert语句中返回以获取序列生成的值，或使用诸如“select scope_identity（）”之类的特殊函数。这些方法对使用中的DBAPIS和数据库非常特定，并且差异很大，因此在关联时应该小心。 autoincrement=True 使用自定义默认生成函数。
default¶ -- 标量、python可调用或 ColumnElement 表达式表示 默认值 对于此列，如果在insert的values子句中未指定此列，则将在insert时调用此列。这是使用的快捷方式 ColumnDefault 作为位置参数；有关参数结构的完整详细信息，请参见该类。把这个论点与 Column.server_default 它在数据库端创建一个默认生成器。…参阅：列插入/更新默认值
doc¶ -- 可选字符串，可由ORM使用或类似于Python端的文档属性。这个属性有 not 呈现SQL注释；使用 Column.comment 用于此目的的参数。
key¶ -- 一个可选的字符串标识符，它将标识此 Column 对象上 Table . 提供键时，这是引用 Column 在应用程序中，包括ORM属性映射； name 字段仅在呈现SQL时使用。
index¶ --
什么时候 True ，表示一个 Index 构造将为此自动生成 Column ，这将导致为“CREATE INDEX”语句发出一条“CREATE INDEX”语句。 Table 调用DDL创建操作时。
使用此标志等效于使用 Index 在 Table 构建自身：：
```
Table(
    "some_table",
    metadata,
    Column("x", Integer),
    Index("ix_some_table_x", "x")
)
```
要添加 Index.unique 标志添加到 Index ，则将 Column.unique 和 Column.index 标志同时设置为True，这将产生呈现“create only index”DDL指令而不是“create index”的效果。
索引的名称是使用 default naming convention 这对于 Index 构式的形式是 ix_<tablename>_<columnname> 。
由于此标志只是为了方便向表定义添加单列的默认配置索引这一常见情况，因此显式使用 Index 构造应该是大多数用例的首选，包括包含多个列的复合索引、带有SQL表达式或排序的索引、特定于后端的索引配置选项，以及使用特定名称的索引。
注解
the Column.index attribute on Column does not indicate if this column is indexed or not, only if this flag was explicitly set here. To view indexes on a column, view the Table.indexes collection or use Inspector.get_indexes().
参见
索引
配置约束命名约定
Column.unique
info¶ -- 可选数据字典，将填充到 SchemaItem.info 此对象的属性。
nullable¶ -- 当设置为时 False 将导致在为列生成DDL时添加“not null”短语。什么时候 True 通常不会生成任何内容(在SQL中，此默认值为“null”)，除非在某些非常特定的后端特定的边缘情况下，“null”可能会显式呈现。默认为 True 除非 Column.primary_key 也是 True 或者该列指定一个 Identity ，在这种情况下，它默认为 False 。此参数仅在发出CREATE TABLE语句时使用。。。注意：：当该列指定 Identity DDL编译器通常会忽略此参数。通过将此参数设置为，PostgreSQL数据库允许使用可为空的标识列 True 明确地说。
onupdate¶ -- 标量、python可调用或 ClauseElement 表示要应用于update语句中的列的默认值，如果该列不在update的set子句中，则在更新时调用该值。这是使用的快捷方式 ColumnDefault 作为位置参数 for_update=True . …参阅：列插入/更新默认值 -关于更新的完整讨论
primary_key¶ -- 如果 True ，将此列标记为主键列。多列可以设置此标志以指定复合主键。另一种选择是 Table 可以通过显式 PrimaryKeyConstraint 对象。
server_default¶ -- A FetchedValue 实例、字符串、Unicode或 text() 表示列的DDL默认值的构造。字符串类型将按原样发出，并用单引号括起来：：column(‘x’，text，server_default=“val”)x文本默认值‘val’A text() 表达式将按原样呈现，不带引号：：column(‘y’，datetime，server_default=text(‘now()’))y datetime default now()字符串和text()将转换为 DefaultClause 对象。此参数还可以接受上下文有效的SQLAlChemy表达式或构造的复杂组合：：from sqlalChemy import CREATE_ENGINE FROM SQL ALCHEMY IMPORT Table，Column，Metadata，Array，Text from sqlalChemy.Dialts.postgresql import array engine=CREATE_ENGINE(‘postgresql://scott:tiger@localhost/mydatabase’)METADATA_OBJ=METADATA()TBL=TABL表(“foo”，METADATA_OBJ，Column(“bar”，array(文本)，server_default=array( [“biz”，“bang”，“bash”] )METADATA_OBJ.CREATE_ALL(引擎)以上将生成一个使用以下SQL：：CREATE TABLE FOO(BAR TEXT)创建的表 []默认数组[‘biz’，‘bang’，‘bash’] )使用 FetchedValue 以指示已存在的列将在数据库端生成默认值，该默认值将可供SQLAlChemy在插入后用于后取。此构造不指定任何DDL，实现留给数据库，例如通过触发器。。。另请参阅：：服务器调用了DDL显式默认表达式 -完整讨论服务器端默认值
server_onupdate¶ -- A FetchedValue 实例，该实例表示数据库端的默认生成函数，如触发器。这向SQLAlchemy指示新生成的值将在更新后可用。这个构造实际上并没有在数据库中实现任何类型的生成函数，而是必须单独指定。。警告：：此指令不当前生成MySQL的“ON UPDATE CURRENT_TIMESTAMP（）”子句。看到了吗 MySQL/MariaDB在更新当前时间戳时呈现的显式“默认值”为“时间戳” 关于如何产生这个条款的背景。。另请参见：标记隐式生成的值、时间戳和触发的列
quote¶ -- 打开或关闭此列名称的强制引用，对应于 True 或 False . 当其违约时 None ，列标识符将根据名称是否区分大小写（具有至少一个大写字符的标识符被视为区分大小写）或是否为保留字来引用。此标志只需要强制引用一个不被SQLAlchemy方言识别的保留字。
unique¶ --
什么时候 True ，以及 Column.index 参数保留其默认值 False ，表示一个 UniqueConstraint 构造将为此自动生成 Column ，这将导致引用此列的“唯一约束”子句包含在 CREATE TABLE 对象的DDL CREATE操作时发出的语句 Table 对象被调用。
当此标志为 True 在此期间， Column.index 参数同时设置为 True ，其效果反而是一个 Index 构造，该构造包括 Index.unique 参数设置为 True 是生成的。请参阅的文档 Column.index 有关更多详细信息，请参阅。
使用此标志等效于使用 UniqueConstraint 在 Table 构建自身：：
```
Table(
    "some_table",
    metadata,
    Column("x", Integer),
    UniqueConstraint("x")
)
```
这个 UniqueConstraint.name 唯一约束对象的参数保留其默认值 None ；在没有 naming convention 对于所附的 MetaData 时，唯一约束构造将以未命名的形式发出，这通常会调用特定于数据库的命名约定。
由于此标志只是为了方便向表定义添加默认配置的单列唯一约束这一常见情况，因此显式使用 UniqueConstraint 构造应该是大多数用例的首选，包括包含多个列的复合约束、特定于后端的索引配置选项，以及使用特定名称的约束。
注解
the Column.unique attribute on Column does not indicate if this column has a unique constraint or not, only if this flag was explicitly set here. To view indexes and unique constraints that may involve this column, view the Table.indexes and/or Table.constraints collections or use Inspector.get_indexes() and/or Inspector.get_unique_constraints()
参见
唯一约束
配置约束命名约定
Column.index
system¶ -- 什么时候？ True ，表示这是一个“系统”列，该列由数据库自动提供，不应包含在 CREATE TABLE 语句。对于应该在不同后端有条件地呈现不同列的更详细的场景，请考虑自定义编译规则 CreateColumn .
comment¶ -- 用于在创建表时呈现SQL注释的可选字符串。…版本添加：：1.2添加了 Column.comment 参数到 Column .

method sqlalchemy.schema.Column.__le__(other)¶

inherited from the sqlalchemy.sql.expression.ColumnOperators.__le__ method of ColumnOperators

实施 <= 操作员。

在列上下文中，生成子句 a <= b .

method sqlalchemy.schema.Column.__lt__(other)¶

inherited from the sqlalchemy.sql.expression.ColumnOperators.__lt__ method of ColumnOperators

实施 < 操作员。

在列上下文中，生成子句 a < b .

method sqlalchemy.schema.Column.__ne__(other)¶

inherited from the sqlalchemy.sql.expression.ColumnOperators.__ne__ method of ColumnOperators

实施 != 操作员。

在列上下文中，生成子句 a != b . 如果目标是 None 生产 a IS NOT NULL .

method sqlalchemy.schema.Column.all_()¶

inherited from the ColumnOperators.all_() method of ColumnOperators

制作一个 all_() 子句对父对象执行操作。

请参阅的文档 all_() 举个例子。

注解

一定不要把新的弄糊涂了 ColumnOperators.all_() 方法及其较旧的 ARRAY -特定的对应方，即 Comparator.all() 方法，该方法使用不同的调用语法和使用模式。

1.1 新版功能.

attribute sqlalchemy.schema.Column.anon_key_label¶

inherited from the ColumnElement.anon_key_label attribute of ColumnElement

1.4 版后已移除: 这个 ColumnElement.anon_key_label 属性现在是私有的，并且不推荐使用公共访问器。

attribute sqlalchemy.schema.Column.anon_label¶

inherited from the ColumnElement.anon_label attribute of ColumnElement

1.4 版后已移除: 这个 ColumnElement.anon_label 属性现在是私有的，并且不推荐使用公共访问器。

method sqlalchemy.schema.Column.any_()¶

inherited from the ColumnOperators.any_() method of ColumnOperators

制作一个 any_() 子句对父对象执行操作。

请参阅的文档 any_() 举个例子。

注解

一定不要把新的弄糊涂了 ColumnOperators.any_() 方法及其较旧的 ARRAY -特定的对应方，即 Comparator.any() 方法，该方法使用不同的调用语法和使用模式。

1.1 新版功能.

method sqlalchemy.schema.Column.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.Column.asc()¶

inherited from the ColumnOperators.asc() method of ColumnOperators

产生一个 asc() 针对父对象的子句。

method sqlalchemy.schema.Column.between(cleft, cright, symmetric=False)¶

inherited from the ColumnOperators.between() method of ColumnOperators

产生一个 between() 在给定上下限的情况下，针对父对象的子句。

method sqlalchemy.schema.Column.bool_op(opstring, precedence=0)¶

inherited from the Operators.bool_op() method of Operators

返回自定义布尔运算符。

这个方法是调用 Operators.op() 并通过 Operators.op.is_comparison 标记为真。

参见

Operators.op()

method sqlalchemy.schema.Column.cast(type_)¶

inherited from the ColumnElement.cast() method of ColumnElement

生成类型转换，即 CAST(<expression> AS <type>) .

这是到 cast() 功能。

参见

数据强制转换和类型强制

cast()

type_coerce()

1.0.7 新版功能.

method sqlalchemy.schema.Column.collate(collation)¶

inherited from the ColumnOperators.collate() method of ColumnOperators

产生一个 collate() 在给定排序规则字符串的情况下，对父对象执行子句。

参见

collate()

method sqlalchemy.schema.Column.compare(other, **kw)¶

inherited from the ClauseElement.compare() method of ClauseElement

比较一下 ClauseElement 到给定的 ClauseElement .

子类应该覆盖默认行为，这是一个直接的身份比较。

* *kw是子类消耗的参数 compare() 方法和可用于修改比较标准（请参见 ColumnElement ）

method sqlalchemy.schema.Column.compile(bind=None, dialect=None, **kw)¶

inherited from the ClauseElement.compile() method of ClauseElement

编译此SQL表达式。

返回值为 Compiled 对象。打电话 str() 或 unicode() 返回的值将生成结果的字符串表示形式。这个 Compiled 对象还可以返回绑定参数名称和值的字典，方法是 params 访问器。

参数

bind¶ -- 安 Engine 或 Connection 从哪一个 Compiled 将被收购。此参数优先于此 ClauseElement 如果有绑定的引擎。
column_keys¶ -- 用于insert和update语句，列名称的列表，应出现在编译语句的values子句中。如果 None ，将呈现目标表对象中的所有列。
dialect¶ -- A Dialect 实例，其中 Compiled 将被收购。此参数优先于 bind argument as well as this :class:`_ 子句元素表达式`如果有的话。
compile_kwargs¶ -- 附加参数的可选字典，这些参数将在所有“访问”方法中传递给编译器。例如，这允许将任何自定义标志传递给自定义编译构造。它还用于传递 literal_binds 标志通过：FROM sqlalChemy.sql导入表，列，SELECT t=TABLE(‘t’，COLUMN(‘x’))s=SELECT(T).WHERE(t.c.x==5)print(s.compile(compile_kwargs={“literal_binds”：True}))..添加的版本：：0.9.0

参见

如何将SQL表达式呈现为字符串（可能是内联绑定参数）？

method sqlalchemy.schema.Column.concat(other)¶

inherited from the ColumnOperators.concat() method of ColumnOperators

实现“concat”运算符。

在列上下文中，生成子句 a || b 或使用 concat() mysql上的操作符。

method sqlalchemy.schema.Column.contains(other, **kwargs)¶

inherited from the ColumnOperators.contains() method of ColumnOperators

实现“contains”运算符。

生成一个类似表达式，该表达式根据字符串值中间的匹配项进行测试：

column LIKE '%' || <other> || '%'

例如。：：

stmt = select(sometable).\
    where(sometable.c.column.contains("foobar"))

因为操作员使用 LIKE ，通配符 "%" 和 "_" 存在于<other>表达式中的也将表现为通配符。对于文本字符串值， ColumnOperators.contains.autoescape 标志可以设置为 True 将转义应用于字符串值中出现的这些字符，以便它们与自身匹配，而不是作为通配符匹配。或者， ColumnOperators.contains.escape 参数将建立一个给定字符作为转义字符，当目标表达式不是文本字符串时可以使用该字符。

参数

other¶ -- 要比较的表达式。这通常是一个纯字符串值，但也可以是任意的SQL表达式。类似通配符 % 和 _ 默认情况下不转义，除非 ColumnOperators.contains.autoescape 标志设置为真。
autoescape¶ -- 布尔值；如果为true，则在like表达式中建立转义符，然后将其应用于 "%" ， "_" 以及比较值中的转义字符本身，该值被假定为文本字符串而不是SQL表达式。例如：：somecolumn.包含（“foo%bar”，autoescape=True）将呈现为：：somecolumn，如“%”| |：param |‘%‘ESCAPE’/”，值为 :param 作为 "foo/%bar" .
escape¶ -- 一个字符，当给定时将用 ESCAPE 关键字将该字符建立为转义字符。然后可以将此字符置于 % 和 _ 允许它们充当自己而不是通配符。表达式如：：somecolumn.contains（“foo/%bar”，escape=“^”）将呈现为：：somecolumn，如“%”。|| :param || '%' ESCAPE '^' The parameter may also be combined with ColumnOperators.contains.autoescape ：：someColumn.contains（“foo%bar^bat”，escape=“^”，autoescape=true），其中，给定的文本参数将转换为 "foo^%bar^^bat" 在被传递到数据库之前。

参见

ColumnOperators.startswith()

ColumnOperators.endswith()

ColumnOperators.like()

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

method sqlalchemy.schema.Column.desc()¶

inherited from the ColumnOperators.desc() method of ColumnOperators

产生一个 desc() 针对父对象的子句。

attribute sqlalchemy.schema.Column.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.Column.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.Column.distinct()¶

inherited from the ColumnOperators.distinct() method of ColumnOperators

产生一个 distinct() 针对父对象的子句。

method sqlalchemy.schema.Column.endswith(other, **kwargs)¶

inherited from the ColumnOperators.endswith() method of ColumnOperators

实现“endswith”运算符。

生成一个类似表达式，该表达式根据字符串值末尾的匹配项进行测试：

column LIKE '%' || <other>

例如。：：

stmt = select(sometable).\
    where(sometable.c.column.endswith("foobar"))

因为操作员使用 LIKE ，通配符 "%" 和 "_" 存在于<other>表达式中的也将表现为通配符。对于文本字符串值， ColumnOperators.endswith.autoescape 标志可以设置为 True 将转义应用于字符串值中出现的这些字符，以便它们与自身匹配，而不是作为通配符匹配。或者， ColumnOperators.endswith.escape 参数将建立一个给定字符作为转义字符，当目标表达式不是文本字符串时可以使用该字符。

参数

other¶ -- 要比较的表达式。这通常是一个纯字符串值，但也可以是任意的SQL表达式。类似通配符 % 和 _ 默认情况下不转义，除非 ColumnOperators.endswith.autoescape 标志设置为真。
autoescape¶ -- 布尔值；如果为true，则在like表达式中建立转义符，然后将其应用于 "%" ， "_" 以及比较值中的转义字符本身，该值被假定为文本字符串而不是SQL表达式。例如：：somecolumn.endswith（“foo%bar”，autoescape=True）将呈现为：：somecolumn，如“%”| |：param ESCAPE“/”值为 :param 作为 "foo/%bar" .
escape¶ -- 一个字符，当给定时将用 ESCAPE 关键字将该字符建立为转义字符。然后可以将此字符置于 % 和 _ 允许它们充当自己而不是通配符。表达式如：：somecolumn.endswith（“foo/%bar”，escape=“^”）将呈现为：：somecolumn，如“%”。|| :param ESCAPE '^' The parameter may also be combined with ColumnOperators.endswith.autoescape ：：someColumn.endsWith（“foo%bar^bat”，escape=“^”，autoescape=true），其中，给定的文本参数将转换为 "foo^%bar^^bat" 在被传递到数据库之前。

参见

ColumnOperators.startswith()

ColumnOperators.contains()

ColumnOperators.like()

attribute sqlalchemy.schema.Column.expression¶

inherited from the ColumnElement.expression attribute of ColumnElement

返回列表达式。

检查界面的一部分；返回自身。

attribute sqlalchemy.schema.Column.foreign_keys = None¶

所有内容的集合 ForeignKey 与此关联的标记对象 Column 。

每个对象都是 Table -宽度 ForeignKeyConstraint 。

参见

Table.foreign_keys

method sqlalchemy.schema.Column.get_children(column_tables=False, **kw)¶

inherited from the ColumnClause.get_children() method of ColumnClause

返回直接子项 Traversible 其中的要素 Traversible .

用于访问遍历。

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

method sqlalchemy.schema.Column.ilike(other, escape=None)¶

inherited from the ColumnOperators.ilike() method of ColumnOperators

实施 ilike 运算符，例如不区分大小写的like。

在列上下文中，生成以下任一形式的表达式：

lower(a) LIKE lower(other)

或者在支持ilike运算符的后端：

a ILIKE other

例如。：：

stmt = select(sometable).\
    where(sometable.c.column.ilike("%foobar%"))

参数

other¶ -- 要比较的表达式
escape¶ -- 可选转义符，呈现 ESCAPE 关键字，例如：somecolumn.ilike（“foo/%bar”，escape=“/”）

参见

ColumnOperators.like()

method sqlalchemy.schema.Column.in_(other)¶

inherited from the ColumnOperators.in_() method of ColumnOperators

实施 in 操作员。

在列上下文中，生成子句 column IN <other> .

给定参数 other 可能是：

文字值列表，例如：
```
stmt.where(column.in_([1, 2, 3]))
```
在此调用表单中，项目列表将转换为一组与给定列表长度相同的绑定参数：
```
WHERE COL IN (?, ?, ?)
```

如果比较与 tuple_() 包含多个表达式：

from sqlalchemy import tuple_
stmt.where(tuple_(col1, col2).in_([(1, 10), (2, 20), (3, 30)]))

空列表，例如：
```
stmt.where(column.in_([]))
```
在此调用形式中，表达式呈现“空集”表达式。这些表达式是针对各个后端量身定做的，通常会尝试将空的SELECT语句作为子查询。例如在SQLite上，表达式为：：
```
WHERE col IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1)
```
在 1.4 版更改: 空IN表达式现在在所有情况下都使用生成的SELECT子查询的执行时间。
绑定参数，例如 bindparam() ，如果包含 bindparam.expanding 旗帜：
```
stmt.where(column.in_(bindparam('value', expanding=True)))
```
在此调用表单中，表达式呈现一个特殊的非SQL占位符表达式，其外观如下：
```
WHERE COL IN ([EXPANDING_value])
```
此占位符表达式在语句执行时被截取，以便转换为前面所示的绑定参数表单的变量号。如果语句的执行方式为：
```
connection.execute(stmt, {"value": [1, 2, 3]})
```
将为数据库传递每个值的绑定参数：
```
WHERE COL IN (?, ?, ?)
```
1.2 新版功能: 添加了“扩展”绑定参数
如果传递空列表，将呈现一个特定于正在使用的数据库的特殊“空列表”表达式。在sqlite上：
```
WHERE COL IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1)
```
1.3 新版功能: “expanding”绑定参数现在支持空列表

一 select() 构造，通常是相关的标量选择：

stmt.where(
    column.in_(
        select(othertable.c.y).
        where(table.c.x == othertable.c.x)
    )
)

在这个调用表单中， ColumnOperators.in_() 按给定呈现：

WHERE COL IN (SELECT othertable.y
FROM othertable WHERE othertable.x = table.x)

参数: other¶ -- 文字列表，a select() 构造，或 bindparam() 构造，包括 bindparam.expanding 标志设置为真。

attribute sqlalchemy.schema.Column.index = None¶

的价值 Column.index 参数。

不会指示此选项是否 Column 是否已实际编入索引；使用 Table.indexes 。

参见

Table.indexes

attribute sqlalchemy.schema.Column.info¶

inherited from the SchemaItem.info attribute of SchemaItem

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

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

method sqlalchemy.schema.Column.is_(other)¶

inherited from the ColumnOperators.is_() method of ColumnOperators

实施 IS 操作员。

通常情况下， IS 与以下值比较时自动生成 None ，决定 NULL . 但是，明确使用 IS 如果与某些平台上的布尔值进行比较，可能是可取的。

参见

ColumnOperators.is_not()

method sqlalchemy.schema.Column.is_distinct_from(other)¶

inherited from the ColumnOperators.is_distinct_from() method of ColumnOperators

实施 IS DISTINCT FROM 操作员。

在大多数平台上呈现“a与b不同”；在某些平台上，例如sqlite可能呈现“a不是b”。

1.1 新版功能.

method sqlalchemy.schema.Column.is_not(other)¶

inherited from the ColumnOperators.is_not() method of ColumnOperators

实施 IS NOT 操作员。

通常情况下， IS NOT 与以下值比较时自动生成 None ，决定 NULL . 但是，明确使用 IS NOT 如果与某些平台上的布尔值进行比较，可能是可取的。

在 1.4 版更改: 这个 is_not() 运算符重命名自 isnot() 在以前的版本中。以前的名称仍然可以向后兼容。

参见

ColumnOperators.is_()

method sqlalchemy.schema.Column.is_not_distinct_from(other)¶

inherited from the ColumnOperators.is_not_distinct_from() method of ColumnOperators

实施 IS NOT DISTINCT FROM 操作员。

在大多数平台上呈现“a与b不同”；在某些平台上，例如sqlite可能呈现“a是b”。

在 1.4 版更改: 这个 is_not_distinct_from() 运算符重命名自 isnot_distinct_from() 在以前的版本中。以前的名称仍然可以向后兼容。

1.1 新版功能.

method sqlalchemy.schema.Column.isnot(other)¶

inherited from the ColumnOperators.isnot() method of ColumnOperators

实施 IS NOT 操作员。

通常情况下， IS NOT 与以下值比较时自动生成 None ，决定 NULL . 但是，明确使用 IS NOT 如果与某些平台上的布尔值进行比较，可能是可取的。

在 1.4 版更改: 这个 is_not() 运算符重命名自 isnot() 在以前的版本中。以前的名称仍然可以向后兼容。

参见

ColumnOperators.is_()

method sqlalchemy.schema.Column.isnot_distinct_from(other)¶

inherited from the ColumnOperators.isnot_distinct_from() method of ColumnOperators

实施 IS NOT DISTINCT FROM 操作员。

在大多数平台上呈现“a与b不同”；在某些平台上，例如sqlite可能呈现“a是b”。

在 1.4 版更改: 这个 is_not_distinct_from() 运算符重命名自 isnot_distinct_from() 在以前的版本中。以前的名称仍然可以向后兼容。

1.1 新版功能.

attribute sqlalchemy.schema.Column.kwargs¶

inherited from the DialectKWArgs.kwargs attribute of DialectKWArgs

同义词 DialectKWArgs.dialect_kwargs .

method sqlalchemy.schema.Column.label(name)¶

inherited from the ColumnElement.label() method of ColumnElement

生成列标签，即 <columnname> AS <name> .

这是到 label() 功能。

如果'name'是 None ，将生成匿名标签名称。

method sqlalchemy.schema.Column.like(other, escape=None)¶

inherited from the ColumnOperators.like() method of ColumnOperators

实施 like 操作员。

在列上下文中，生成表达式：：

a LIKE other

例如。：：

stmt = select(sometable).\
    where(sometable.c.column.like("%foobar%"))

参数

other¶ -- 要比较的表达式
escape¶ -- 可选转义符，呈现 ESCAPE 关键字，例如：somecolumn.like（“foo/%bar”，escape=“/”）

参见

ColumnOperators.ilike()

method sqlalchemy.schema.Column.match(other, **kwargs)¶

inherited from the ColumnOperators.match() method of ColumnOperators

实现特定于数据库的“match”运算符。

ColumnOperators.match() 尝试解析为后端提供的类似匹配的函数或运算符。示例包括：

PostgreSQL-呈现 x @@ to_tsquery(y)
MySQL -渲染器 MATCH (x) AGAINST (y IN BOOLEAN MODE)
参见
match -具有附加功能的MySQL特定构造。
Oracle-呈现 CONTAINS(x, y)
其他后端可能提供特殊的实现。
没有任何特殊实现的后端将发出“match”操作符。例如，这与sqlite兼容。

class memoized_attribute(fget, doc=None)¶: 只读@属性，只计算一次。

method sqlalchemy.schema.Column.classmethod memoized_instancemethod(fn)¶

inherited from the HasMemoized.memoized_instancemethod() method of HasMemoized

装饰一个方法记下它的返回值。

method sqlalchemy.schema.Column.not_ilike(other, escape=None)¶

inherited from the ColumnOperators.not_ilike() method of ColumnOperators

实施 NOT ILIKE 操作员。

这相当于使用否定 ColumnOperators.ilike() ，即 ~x.ilike(y) .

在 1.4 版更改: 这个 not_ilike() 运算符重命名自 notilike() 在以前的版本中。以前的名称仍然可以向后兼容。

参见

ColumnOperators.ilike()

method sqlalchemy.schema.Column.not_in(other)¶

inherited from the ColumnOperators.not_in() method of ColumnOperators

实施 NOT IN 操作员。

这相当于使用否定 ColumnOperators.in_() ，即 ~x.in_(y) .

在这种情况下 other 是一个空序列，编译器生成一个“empty not in”表达式。这将默认表达式“1=1”在所有情况下都生成“真”。这个 create_engine.empty_in_strategy 可用于更改此行为。

在 1.4 版更改: 这个 not_in() 运算符重命名自 notin_() 在以前的版本中。以前的名称仍然可以向后兼容。

在 1.2 版更改: 这个 ColumnOperators.in_() 和 ColumnOperators.not_in() 现在，默认情况下，运算符为空序列生成一个“静态”表达式。

参见

ColumnOperators.in_()

method sqlalchemy.schema.Column.not_like(other, escape=None)¶

inherited from the ColumnOperators.not_like() method of ColumnOperators

实施 NOT LIKE 操作员。

这相当于使用否定 ColumnOperators.like() ，即 ~x.like(y) .

在 1.4 版更改: 这个 not_like() 运算符重命名自 notlike() 在以前的版本中。以前的名称仍然可以向后兼容。

参见

ColumnOperators.like()

method sqlalchemy.schema.Column.notilike(other, escape=None)¶

inherited from the ColumnOperators.notilike() method of ColumnOperators

实施 NOT ILIKE 操作员。

这相当于使用否定 ColumnOperators.ilike() ，即 ~x.ilike(y) .

在 1.4 版更改: 这个 not_ilike() 运算符重命名自 notilike() 在以前的版本中。以前的名称仍然可以向后兼容。

参见

ColumnOperators.ilike()

method sqlalchemy.schema.Column.notin_(other)¶

inherited from the ColumnOperators.notin_() method of ColumnOperators

实施 NOT IN 操作员。

这相当于使用否定 ColumnOperators.in_() ，即 ~x.in_(y) .

在 1.4 版更改: 这个 not_in() 运算符重命名自 notin_() 在以前的版本中。以前的名称仍然可以向后兼容。

在 1.2 版更改: 这个 ColumnOperators.in_() 和 ColumnOperators.not_in() 现在，默认情况下，运算符为空序列生成一个“静态”表达式。

参见

ColumnOperators.in_()

method sqlalchemy.schema.Column.notlike(other, escape=None)¶

inherited from the ColumnOperators.notlike() method of ColumnOperators

实施 NOT LIKE 操作员。

这相当于使用否定 ColumnOperators.like() ，即 ~x.like(y) .

在 1.4 版更改: 这个 not_like() 运算符重命名自 notlike() 在以前的版本中。以前的名称仍然可以向后兼容。

参见

ColumnOperators.like()

method sqlalchemy.schema.Column.nulls_first()¶

inherited from the ColumnOperators.nulls_first() method of ColumnOperators

产生一个 nulls_first() 针对父对象的子句。

在 1.4 版更改: 这个 nulls_first() 运算符重命名自 nullsfirst() 在以前的版本中。以前的名称仍然可以向后兼容。

method sqlalchemy.schema.Column.nulls_last()¶

inherited from the ColumnOperators.nulls_last() method of ColumnOperators

产生一个 nulls_last() 针对父对象的子句。

在 1.4 版更改: 这个 nulls_last() 运算符重命名自 nullslast() 在以前的版本中。以前的名称仍然可以向后兼容。

method sqlalchemy.schema.Column.nullsfirst()¶

inherited from the ColumnOperators.nullsfirst() method of ColumnOperators

产生一个 nulls_first() 针对父对象的子句。

在 1.4 版更改: 这个 nulls_first() 运算符重命名自 nullsfirst() 在以前的版本中。以前的名称仍然可以向后兼容。

method sqlalchemy.schema.Column.nullslast()¶

inherited from the ColumnOperators.nullslast() method of ColumnOperators

产生一个 nulls_last() 针对父对象的子句。

在 1.4 版更改: 这个 nulls_last() 运算符重命名自 nullslast() 在以前的版本中。以前的名称仍然可以向后兼容。

method sqlalchemy.schema.Column.op(opstring, precedence=0, is_comparison=False, return_type=None)¶

inherited from the Operators.op() method of Operators

生成泛型运算符函数。

例如。：：

somecolumn.op("*")(5)

生产：：

somecolumn * 5

此函数还可用于显式地生成位运算符。例如：：

somecolumn.op('&')(0xff)

是中的值的位与 somecolumn .

参数

operator¶ -- 将作为该元素和传递给生成函数的表达式之间的中缀运算符输出的字符串。
precedence¶ -- 在对表达式加括号时应用于运算符的优先级。当对具有更高优先级的另一个运算符应用时，较低的数字将导致表达式加括号。默认值为 0 低于除逗号之外的所有运算符 (, ） AS 运算符。值100将大于或等于所有运算符，-100将小于或等于所有运算符。
is_comparison¶ -- 如果为真，则该运算符将被视为“比较”运算符，即计算为布尔真/假值，如 == ， > 等等。应设置此标志，以便ORM关系可以确定在自定义联接条件中使用的运算符是比较运算符。…versionAdded:：0.9.2-添加了 Operators.op.is_comparison 旗帜。
return_type¶ -- 一 TypeEngine 类或对象，它将强制此运算符生成的表达式的返回类型为该类型。默认情况下，指定 Operators.op.is_comparison 将决心 Boolean ，而那些不属于左侧操作数的类型。

参见

重新定义和创建新的运算符

在联接条件中使用自定义运算符

method sqlalchemy.schema.Column.operate(op, *other, **kwargs)¶

inherited from the ColumnElement.operate() method of ColumnElement

对参数进行运算。

这是最低级别的操作，提升 NotImplementedError 默认情况下。

在子类上覆盖此项可以允许将公共行为应用于所有操作。例如，重写 ColumnOperators 申请 func.lower() 左右两侧：

class MyComparator(ColumnOperators):
    def operate(self, op, other):
        return op(func.lower(self), func.lower(other))

参数

op¶ -- 操作员可调用。
*other¶ -- 操作的“另一方”。对于大多数操作，将是单个标量。
**kwargs¶ -- 修饰语。这些可由特殊操作员通过，如 ColumnOperators.contains() .

method sqlalchemy.schema.Column.params(*optionaldict, **kwargs)¶

inherited from the Immutable.params() method of Immutable

用以下方式退还一份副本 bindparam() 已替换元素。

返回此ClauseElement的副本，其中包含 bindparam() 元素替换为从给定字典中获取的值：：

>>> clause = column('x') + bindparam('foo')
>>> print(clause.compile().params)
{'foo':None}
>>> print(clause.params({'foo':7}).compile().params)
{'foo':7}

method sqlalchemy.schema.Column.references(column)¶: 如果此列通过外键引用给定列，则返回true。

method sqlalchemy.schema.Column.regexp_match(pattern, flags=None)¶

inherited from the ColumnOperators.regexp_match() method of ColumnOperators

实现特定于数据库的“regexp match”运算符。

例如。：：

stmt = select(table.c.some_column).where(
    table.c.some_column.regexp_match('^(b|c)')
)

ColumnOperators.regexp_match() 尝试解析为后端提供的类似REGEXP的函数或运算符，但是可用的特定正则表达式语法和标志是 不是后端不可知的 .

示例包括：

PostgreSQL-呈现 x ~ y 或 x !~ y 当被否定时。
Oracle-呈现 REGEXP_LIKE(x, y)
SQLite-使用SQLite的 REGEXP 占位符运算符和对Python的调用 re.match() 内置的。
其他后端可能提供特殊的实现。
没有任何特殊实现的后端将发出操作符“REGEXP”或“NOT REGEXP”。例如，这与SQLite和MySQL兼容。

正则表达式支持目前是针对Oracle、PostgreSQL、MySQL和MariaDB实现的。部分支持SQLite。第三方方言之间的支持可能会有所不同。

参数

pattern¶ -- 正则表达式模式字符串或列子句。
flags¶ -- 要应用的任何正则表达式字符串标志。标志往往是特定于后端的。它可以是字符串或列子句。一些后端，比如PostgreSQL和MariaDB，可以选择将标志指定为模式的一部分。在PostgreSQL中使用ignore case标志“i”时，ignore case regexp match运算符 ~* 或 !~* 将被使用。

1.4 新版功能.

参见

ColumnOperators.regexp_replace()

method sqlalchemy.schema.Column.regexp_replace(pattern, replacement, flags=None)¶

inherited from the ColumnOperators.regexp_replace() method of ColumnOperators

实现特定于数据库的“regexp replace”运算符。

例如。：：

stmt = select(
    table.c.some_column.regexp_replace(
        'b(..)',
        'XY',
        flags='g'
    )
)

ColumnOperators.regexp_replace() 尝试解析为后端提供的类似REGEXP_REPLACE的函数，该函数通常发出该函数 REGEXP_REPLACE() . 但是，可用的特定正则表达式语法和标志是 不是后端不可知的 .

目前已为Oracle、PostgreSQL、MySQL8或更高版本和MariaDB实现正则表达式替换支持。第三方方言之间的支持可能会有所不同。

参数

pattern¶ -- 正则表达式模式字符串或列子句。
pattern¶ -- 替换字符串或列子句。
flags¶ -- 要应用的任何正则表达式字符串标志。标志往往是特定于后端的。它可以是字符串或列子句。一些后端，比如PostgreSQL和MariaDB，可以选择将标志指定为模式的一部分。

1.4 新版功能.

参见

ColumnOperators.regexp_match()

method sqlalchemy.schema.Column.reverse_operate(op, other, **kwargs)¶

inherited from the ColumnElement.reverse_operate() method of ColumnElement

对参数进行反向运算。

用法与 operate() .

method sqlalchemy.schema.Column.self_group(against=None)¶

inherited from the ColumnElement.self_group() method of ColumnElement

对此应用“分组” ClauseElement .

此方法被子类重写以返回“grouping”构造，即括号。尤其是“binary”表达式使用它在放入更大的表达式时提供围绕其自身的分组，以及 select() 当放入另一个的FROM子句时构造 select() . （请注意，通常应使用 Select.alias() 方法，因为许多平台都需要命名嵌套的select语句）。

当表达式组合在一起时，应用 self_group() 是自动的-最终用户代码不需要直接使用这个方法。请注意，sqlachemy的子句构造将运算符优先考虑在内，因此可能不需要括号，例如，在类似这样的表达式中 x OR (y AND z) -优先于或。

底座 self_group() 方法 ClauseElement 只需返回自我。

method sqlalchemy.schema.Column.shares_lineage(othercolumn)¶

inherited from the ColumnElement.shares_lineage() method of ColumnElement

如果给定 ColumnElement 有着共同的祖先 ColumnElement .

method sqlalchemy.schema.Column.startswith(other, **kwargs)¶

inherited from the ColumnOperators.startswith() method of ColumnOperators

实施 startswith 操作员。

生成一个类似表达式，该表达式根据字符串值开头的匹配项进行测试：

column LIKE <other> || '%'

例如。：：

stmt = select(sometable).\
    where(sometable.c.column.startswith("foobar"))

因为操作员使用 LIKE ，通配符 "%" 和 "_" 存在于<other>表达式中的也将表现为通配符。对于文本字符串值， ColumnOperators.startswith.autoescape 标志可以设置为 True 将转义应用于字符串值中出现的这些字符，以便它们与自身匹配，而不是作为通配符匹配。或者， ColumnOperators.startswith.escape 参数将建立一个给定字符作为转义字符，当目标表达式不是文本字符串时可以使用该字符。

参数

other¶ -- 要比较的表达式。这通常是一个纯字符串值，但也可以是任意的SQL表达式。类似通配符 % 和 _ 默认情况下不转义，除非 ColumnOperators.startswith.autoescape 标志设置为真。
autoescape¶ -- 布尔值；如果为true，则在like表达式中建立转义符，然后将其应用于 "%" ， "_" 以及比较值中的转义字符本身，该值被假定为文本字符串而不是SQL表达式。例如：：somecolumn.startswith（“foo%bar”，autoescape=True）将呈现为：：somecolumn，类似于：param |'%'ESCAPE'/'的值为 :param 作为 "foo/%bar" .
escape¶ -- 一个字符，当给定时将用 ESCAPE 关键字将该字符建立为转义字符。然后可以将此字符置于 % 和 _ 允许它们充当自己而不是通配符。表达式如：：somecolumn.startswith（“foo/%bar”，escape=“^”）将呈现为：：somecolumn-like :param || '%' ESCAPE '^' The parameter may also be combined with ColumnOperators.startswith.autoescape ：：somecolumn.startswith（“foo%bar^bat”，escape=“^”，autoescape=true），其中，给定的文本参数将转换为 "foo^%bar^^bat" 在被传递到数据库之前。

参见

ColumnOperators.endswith()

ColumnOperators.contains()

ColumnOperators.like()

attribute sqlalchemy.schema.Column.unique = None¶

的价值 Column.unique 参数。

不会指示此选项是否 Column 实际上是否受唯一约束；使用 Table.indexes 和 Table.constraints 。

参见

Table.indexes

Table.constraints 。

method sqlalchemy.schema.Column.unique_params(*optionaldict, **kwargs)¶

inherited from the Immutable.unique_params() method of Immutable

用以下方式退还一份副本 bindparam() 已替换元素。

与以下功能相同的功能 ClauseElement.params() ，除添加 unique=True 绑定受影响的参数，以便可以使用多个语句。

class sqlalchemy.schema.MetaData(bind=None, schema=None, quote_schema=None, naming_convention=None, info=None)¶

收藏 Table 对象及其关联的架构构造。

持有的集合 Table 对象以及到 Engine 或 Connection . 如果绑定，则 Table 集合中的对象及其列可能参与隐式SQL执行。

这个 Table 对象本身存储在 MetaData.tables 字典。

MetaData 是用于读取操作的线程安全对象。在单个表中构建新表 MetaData 对象（显式或通过反射）可能不是完全线程安全的。

参见

用元数据描述数据库 -数据库元数据简介

类签名

class sqlalchemy.schema.MetaData (sqlalchemy.schema.SchemaItem)

method sqlalchemy.schema.MetaData.__init__(bind=None, schema=None, quote_schema=None, naming_convention=None, info=None)¶

创建新的元数据对象。

参数

bind¶ -- 要绑定到的引擎或连接。也可以是一个字符串或URL实例，它们被传递到 create_engine() 还有这个 MetaData 将绑定到生成的引擎。。已弃用：：1.4 MetaData.bind 参数已弃用，将在SQLAlchemy 2.0中删除。
schema¶ --
用于的默认架构 Table ， Sequence 以及可能与此关联的其他对象 MetaData .默认为 None .
参见
使用元数据指定默认架构名称 -关于 MetaData.schema 使用了参数。
Table.schema
Sequence.schema
quote_schema¶ -- 设置 quote_schema 那些旗帜 Table ， Sequence 以及其他使用本地 schema 姓名。
info¶ -- 可选数据字典，将填充到 SchemaItem.info 此对象的属性。…添加的版本：1.0.0
naming_convention¶ -- 一个引用值的字典，该值将为 Constraint 和 Index 对象，对于那些未显式给定名称的对象。本词典的关键字可能是： * a constraint or Index class, e.g. the UniqueConstraint, ForeignKeyConstraint class, the Index class * 已知约束类之一的字符串助记符； "fk" ， "pk" ， "ix" ， "ck" ， "uq" 分别用于外键、主键、索引、检查和唯一约束。 * the string name of a user-defined "token" that can be used to define new naming tokens. The values associated with each "constraint class" or "constraint mnemonic" key are string naming templates, such as "uq_%(table_name)s_%(column_0_name)s", which describe how the name should be composed. The values associated with user-defined "token" keys should be callables of the form fn(constraint, table), which accepts the constraint/index object and Table as arguments, returning a string result. The built-in names are as follows, some of which may only be available for certain types of constraint: * %(table_name)s -的名称 Table 与约束关联的对象。 * %(referred_table_name)s - the name of the Table object associated with the referencing target of a ForeignKeyConstraint. * %(column_0_name)s -的名称 Column 在约束内的索引位置“0”处。 * %(column_0N_name)s - the name of all Column objects in order within the constraint, joined without a separator. * %(column_0_N_name)s -所有人的名字 Column 对象在约束内按顺序排列，并用下划线作为分隔符联接。 * %(column_0_label)s, %(column_0N_label)s, %(column_0_N_label)s - the label of either the zeroth Column or all Columns, separated with or without an underscore * %(column_0_key)s ， %(column_0N_key)s ， %(column_0_N_key)s -零的键 Column 或全部 Columns ，用下划线或不带下划线分隔 * %(referred_column_0_name)s, %(referred_column_0N_name)s %(referred_column_0_N_name)s, %(referred_column_0_key)s, %(referred_column_0N_key)s, ... column tokens which render the names/keys/labels of columns that are referenced by a ForeignKeyConstraint. * %(constraint_name)s -引用给定给约束的现有名称的特殊键。当此密钥存在时， Constraint 对象的现有名称将替换为由使用此标记的模板字符串组成的名称。当此令牌存在时，需要 Constraint 提前给出一个明确的名称。*用户定义的：任何附加令牌都可以通过将其与 fn(constraint, table) 可调用命名约定字典。…版本已添加：：1.3.0-已添加新版本 %(column_0N_name)s ， %(column_0_N_name)s ，以及为给定约束引用的所有列生成名称、键或标签串联的相关标记。…参阅：配置约束命名约定 -有关详细的用法示例。

attribute sqlalchemy.schema.MetaData.bind¶

安 Engine 或 Connection 对此 MetaData 是绑定的。

典型地，A Engine 分配给该属性，以便可以使用“隐式执行”，或者作为向ORM提供引擎绑定信息的方法。 Session 对象：

engine = create_engine("someurl://")
metadata.bind = engine

参见

无连接执行，隐式执行 -“绑定元数据”的背景

method sqlalchemy.schema.MetaData.clear()¶: 清除此元数据中的所有表对象。

method sqlalchemy.schema.MetaData.create_all(bind=None, tables=None, checkfirst=True)¶

创建存储在此元数据中的所有表。

默认情况下，将不会尝试重新创建目标数据库中已存在的表。

参数

bind¶ -- A Connectable 用于访问数据库；如果没有，则对此使用现有绑定 MetaData ，如果有的话。。注意：SQLAlchemy 2.0中需要“bind”参数。
tables¶ -- 可选列表 Table 对象，它是 MetaData （其他被忽略）。
checkfirst¶ -- 默认为true，不为目标数据库中已存在的表发出creates。

method sqlalchemy.schema.MetaData.drop_all(bind=None, tables=None, checkfirst=True)¶

删除此元数据中存储的所有表。

条件默认情况下，不会尝试删除目标数据库中不存在的表。

参数

bind¶ -- A Connectable 用于访问数据库；如果没有，则对此使用现有绑定 MetaData ，如果有的话。。注意：SQLAlchemy 2.0中需要“bind”参数。
tables¶ -- 可选列表 Table 对象，它是 MetaData （其他被忽略）。
checkfirst¶ -- 默认值为true，仅对确认存在于目标数据库中的表发出drops。

method sqlalchemy.schema.MetaData.is_bound()¶: 如果此元数据绑定到引擎或连接，则为true。

method sqlalchemy.schema.MetaData.reflect(bind=None, schema=None, views=False, only=None, extend_existing=False, autoload_replace=True, resolve_fks=True, **dialect_kwargs)¶

从数据库加载所有可用的表定义。

自动创建 Table 条目在此 MetaData 对于数据库中可用但尚未存在于 MetaData . 可以多次调用以提取最近添加到数据库中的表，但是如果此数据库中的表 MetaData 数据库中不再存在。

参数

bind¶ -- A Connectable 用于访问数据库；如果没有，则对此使用现有绑定 MetaData ，如果有的话。。注意：SQLAlchemy 2.0中需要“bind”参数。
schema¶ -- 可选，从备用架构查询和反映表。如果没有，则与此关联的架构 MetaData 如果有的话。
views¶ -- 如果为真，也反映观点。
only¶ -- 可选的。仅加载可用命名表的子集。可以指定为名称序列或可调用。如果提供了一系列名称，则只会反映这些表。如果请求表但不可用，则会引发错误。此中已存在命名表 MetaData 被忽略。如果提供了可调用的，它将用作布尔谓词来筛选潜在表名的列表。使用表名调用可调用文件，并且 MetaData 实例作为位置参数，应为要反映的任何表返回一个真值。
extend_existing¶ -- 传给每个人 Table 作为 Table.extend_existing . …添加的版本：0.9.1
autoload_replace¶ -- 传给每个人 Table 作为 Table.autoload_replace . …添加的版本：0.9.1
resolve_fks¶ -- 如果为真，请反映 Table 链接到的对象 ForeignKey 位于每个 Table . 为了 MetaData.reflect() ，这具有反射相关表的效果，否则这些表可能不在要反射的表列表中，例如，如果引用的表位于不同的架构中或通过 MetaData.reflect.only 参数。当错误时， ForeignKey 对象不跟随到 Table 但是，如果相关表也是在任何情况下都会反映的表列表的一部分，那么 ForeignKey 对象仍将解析为其相关的 Table 后 MetaData.reflect() 操作完成。默认为true。…版本已添加：：1.3.0..参阅： Table.resolve_fks
**dialect_kwargs¶ -- 上面未提到的其他关键字参数是特定于方言的，并以形式传递 <dialectname>_<argname> . 有关单个方言的文档，请参见方言有关文档化参数的详细信息。…版本已添加：：0.9.2-已添加 MetaData.reflect.**dialect_kwargs 为所有用户支持方言级反射选项 Table 反射的对象。

method sqlalchemy.schema.MetaData.remove(table)¶: 从此元数据中删除给定的表对象。

attribute sqlalchemy.schema.MetaData.sorted_tables¶

返回的列表 Table 按外键依赖项的顺序排序的对象。

将进行排序 Table 首先具有依赖项的对象，在依赖项本身之前，表示它们的创建顺序。要获取表的删除顺序，请使用 reversed() python内置。

警告

这个 MetaData.sorted_tables 属性本身不能自动解析表之间的依赖循环，这通常是由相互依赖的外键约束引起的。当检测到这些循环时，将在排序时忽略这些表的外键。当这种情况发生时，会发出一个警告，这将在将来的版本中引发异常。不属于循环一部分的表仍将按依赖关系顺序返回。

为了解决这些周期 ForeignKeyConstraint.use_alter 参数可应用于创建循环的约束。或者 sort_tables_and_constraints() 当检测到循环时，函数将自动返回单独集合中的外键约束，以便将它们分别应用于架构。

在 1.3.17 版更改: -出现以下情况时发出警告 MetaData.sorted_tables 由于循环依赖关系，无法执行正确的排序。这将是未来版本中的一个例外。此外，sort将继续按依赖关系顺序返回循环中未涉及的其他表（以前不是这样）。

参见

sort_tables()

sort_tables_and_constraints()

MetaData.tables

Inspector.get_table_names()

Inspector.get_sorted_table_and_fkc_names()

attribute sqlalchemy.schema.MetaData.tables = None¶

一本字典 Table 键入其名称或“表键”的对象。

确切的关键是 Table.key 属性；对于没有 Table.schema 属性，这与 Table.name . 对于带有模式的表，它通常是 schemaname.tablename .

参见

MetaData.sorted_tables

class sqlalchemy.schema.SchemaItem¶

定义数据库架构的项的基类。

类签名

class sqlalchemy.schema.SchemaItem (sqlalchemy.sql.expression.SchemaEventTarget, sqlalchemy.sql.visitors.Traversible)

attribute sqlalchemy.schema.SchemaItem.info¶

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

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

class sqlalchemy.schema.Table(*args, **kw)¶

表示数据库中的表。

例如。：：

mytable = Table("mytable", metadata,
                Column('mytable_id', Integer, primary_key=True),
                Column('value', String(50))
           )

这个 Table 对象根据其名称和给定架构中的可选架构名称构造其自身的唯一实例。 MetaData 对象。调用 Table 名称相同的构造函数 MetaData 参数第二次将返回 same Table 对象-以这种方式 Table 构造函数充当注册表函数。

参见

用元数据描述数据库 -数据库元数据简介

构造函数参数如下：

参数

name¶ -- 数据库中表示的此表的名称。表名，以及 schema 参数，形成唯一标识此 Table 在所有权范围内 MetaData 收集。其他呼叫 Table 使用相同的名称、元数据和架构名称将返回相同的 Table 对象。不包含大写字符的名称将被视为不区分大小写的名称，除非它们是保留字或包含特殊字符，否则不会被引用。具有任意数量大写字符的名称视为区分大小写，并将按引用方式发送。要为表名启用无条件报价，请指定标志 quote=True 或使用 quoted_name 构造以指定名称。
metadata¶ -- 一 MetaData 将包含此表的对象。元数据用作此表与通过外键引用的其他表的关联点。它还可以用于将此表与特定的 Connectable .
*args¶ -- 其他位置参数主要用于添加 Column 包含在此表中的对象。类似于create table语句的样式，其他 SchemaItem 可以在此处添加构造，包括 PrimaryKeyConstraint 和 ForeignKeyConstraint .
autoload¶ -- 默认为 False 除非 Table.autoload_with 在这种情况下默认为 True ； Column 此表的对象应该从数据库中反映出来，可能会扩充显式指定的对象。 Column 其他明确设置在表上的对象将替换相应的反射对象。。已弃用：：1.4 autoload参数已弃用，将在版本2.0中删除。请使用 Table.autoload_with 参数，传递引擎或连接。。另请参见：反映数据库对象
autoload_replace¶ --
默认为 True 当使用时 Table.autoload 与 Table.extend_existing ，表示 Column 存在于已存在的中的对象 Table 对象应替换为从自动加载进程中检索到的同名列。什么时候？ False ，已存在于现有名称下的列将从反射过程中省略。
请注意，此设置不影响 Column 在调用中以编程方式指定的对象 Table 这也是自动加载；那些 Column 当 Table.extend_existing 是 True .
参见
Table.autoload
Table.extend_existing
autoload_with¶ -- 安 Engine 或 Connection 对象，或 Inspector 返回的对象 inspect() 反对一个，用这个 Table 对象将被反射。当设置为非None值时，将针对给定的引擎或连接对此表执行自动加载过程。
extend_existing¶ --
什么时候？ True ，表示如果 Table 已存在于给定的 MetaData ，将构造函数中的其他参数应用于现有的 Table .
如果 Table.extend_existing 或 Table.keep_existing 未设置，并且新的 Table 指的是 Table 已经存在于目标中 MetaData 收藏，还有这个 Table 指定修改表状态的其他列或其他构造或标志，将引发错误。这两个互斥标志的目的是指定当 Table 指定与现有的 Table ，但指定了其他构造。
Table.extend_existing 也将与 Table.autoload 对数据库运行新的反射操作，即使 Table 目标中已存在同名的 MetaData ；新反映 Column 对象和其他选项将添加到 Table ，可能会覆盖同名的现有列和选项。
和往常一样 Table.autoload ， Column 对象可以在同一个 Table 构造函数，优先。下面，现有表格 mytable 将增加 Column 对象既从数据库反映，也从给定的 Column 命名为“Y”：
```
Table("mytable", metadata,
            Column('y', Integer),
            extend_existing=True,
            autoload_with=engine
        )
```
参见
Table.autoload
Table.autoload_replace
Table.keep_existing
implicit_returning¶ -- 默认情况下为True—表示对于支持此操作的后端，默认情况下可以使用RETURNING来获取新插入的主键值。请注意 create_engine() 还提供了 implicit_returning 旗帜。
include_columns¶ -- 一个字符串列表，指示要通过 autoload 操作；不在此列表中的表列将不会显示在结果中 Table 对象。默认为 None 它表示所有列都应该被反射。
resolve_fks¶ -- 是否反映 Table 与此相关的对象通过 ForeignKey 对象时 Table.autoload 或 Table.autoload_with 已指定。默认为true。设置为false以禁用相关表的反射为 ForeignKey 遇到对象；可以用于保存SQL调用，也可以用于避免与无法访问的相关表有关的问题。请注意，如果相关表已存在于 MetaData 收藏，或稍后出现 ForeignKey 与此关联的对象 Table 将正常解析到该表。…版本已添加：：1.3..参阅： MetaData.reflect.resolve_fks
info¶ -- 可选数据字典，将填充到 SchemaItem.info 此对象的属性。
keep_existing¶ -- 什么时候？ True ，指示如果此表已存在于给定的 MetaData ，忽略构造函数中现有的 Table ，并返回 Table 对象与最初创建的对象相同。这是为了允许一个函数定义一个新的 Table 第一次呼叫，但随后的呼叫将返回相同的 Table ，而不会再次应用任何声明（尤其是约束）。如果 Table.extend_existing 或 Table.keep_existing 未设置，并且新的 Table 指的是 Table 已经存在于目标中 MetaData 收藏，还有这个 Table 指定修改表状态的其他列或其他构造或标志，将引发错误。这两个互斥标志的目的是指定当 Table 指定与现有的 Table ，但指定了其他构造。…参阅： Table.extend_existing
listeners¶ -- 窗体的元组列表 (<eventname>, <fn>) 将传递给 listen() 施工时。这个备用挂钩 listen() 允许建立特定于此的侦听器函数 Table 在“自动加载”过程开始之前。从历史上看，这是用于 DDLEvents.column_reflect() 但是请注意，此事件钩子现在可能与 MetaData object directly:：def listen_reflect（table，column_info）：“处理列反射事件”#。。。t=Table（'sometable'，autoload_with=engine，侦听器= [ ('column_reflect', listen_for_reflect) ] ) .. 另请参见： DDLEvents.column_reflect()
must_exist¶ -- 什么时候？ True ，指示此表必须已存在于给定的 MetaData 集合，否则将引发异常。
prefixes¶ -- 在create table语句中创建后要插入的字符串列表。它们将用空格隔开。
quote¶ -- 强制启用或禁用此表的名称引号，对应于 True 或 False 。当保留其缺省值为 None 时，将根据名称是否区分大小写(至少包含一个大写字符的标识符被视为区分大小写)或它是否为保留字来引用列标识符。只有在强制引用SQLAlChemy方言不知道的保留字时，才需要此标志。。。注意：：将此标志设置为 False 将不为表反射提供不区分大小写的行为；表反射将始终以区分大小写的方式搜索大小写混合的名称。SQLAlChemy中不区分大小写的名称只能通过使用全部小写字符声明名称来指定。
quote_schema¶ -- 与“引号”相同，但适用于架构标识符。
schema¶ -- 此表的架构名称，如果该表驻留在引擎数据库连接的默认选定架构之外的架构中，则需要该名称。默认为 None . 如果拥有 MetaData 其中 Table 指定自己的 MetaData.schema 参数，则该架构名称将应用于 Table 如果此处的架构参数设置为 None . 在 Table 否则将使用所属的架构集 MetaData ，指定特殊符号 BLANK_SCHEMA . …版本添加：：1.0.14添加了 BLANK_SCHEMA 符号以允许 Table 即使在父级 MetaData 指定 MetaData.schema . 模式名的引用规则与 name 参数中，引用应用于保留字或区分大小写的名称；若要对架构名称启用无条件引用，请指定标志 quote_schema=True 或使用 quoted_name 构造以指定名称。
comment¶ -- 用于在创建表时呈现SQL注释的可选字符串。…版本添加：：1.2添加了 Table.comment 参数到 Table .
**kw¶ -- 上面未提到的其他关键字参数是特定于方言的，并以形式传递 <dialectname>_<argname> . 有关单个方言的文档，请参见方言有关文档化参数的详细信息。

类签名

class sqlalchemy.schema.Table (sqlalchemy.sql.base.DialectKWArgs, sqlalchemy.schema.SchemaItem, sqlalchemy.sql.expression.TableClause)

method sqlalchemy.schema.Table.__init__(*args, **kw)¶

构造函数 Table .

此方法是不可操作的。有关 Table 对于构造函数参数。

method sqlalchemy.schema.Table.add_is_dependent_on(table)¶

为此表添加“依赖项”。

这是另一个表对象，必须先创建该对象，然后才能创建该对象，或者在此对象之后删除。

通常，表之间的依赖关系是通过foreignkey对象确定的。但是，对于在外键之外创建依赖项的其他情况（规则、继承），此方法可以手动建立这样的链接。

method sqlalchemy.schema.Table.alias(name=None, flat=False)¶

inherited from the FromClause.alias() method of FromClause

返回此的别名 FromClause .

例如。：：

a2 = some_table.alias('a2')

上面的代码创建一个 Alias 对象，可在任何select语句中用作FROM子句。

参见

使用别名和子查询

alias()

method sqlalchemy.schema.Table.append_column(column, replace_existing=False)¶

追加一个 Column 对此 Table .

新增的“钥匙” Column ，即 .key 属性，然后将在 .c 这个的集合 Table ，列定义将包含在由此生成的任何create table、select、update等语句中。 Table 构造。

注意这是 not 更改表的定义，因为它存在于任何基础数据库中，假定该表已在数据库中创建。关系数据库支持使用sql alter命令将列添加到现有表中，这需要为不包含新添加列的现有表发出。

参数: replace_existing¶ -- 什么时候？ True ，允许替换现有列。什么时候？ False ，默认情况下，如果列具有相同的 .key 已经存在。sqlalchemy的未来版本将发出警告。。版本添加：：1.4.0

method sqlalchemy.schema.Table.append_constraint(constraint)¶

追加一个 Constraint 对此 Table .

这是由于约束包含在任何将来的create table语句中，假定特定的DDL创建事件没有与给定的 Constraint 对象。

注意这是 not 为数据库中已存在的表自动在关系数据库中生成约束。若要向现有关系数据库表添加约束，必须使用sql alter命令。SQLAlchemy还提供 AddConstraint 构造，当作为可执行子句调用时可以生成此SQL。

method sqlalchemy.schema.Table.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.Table.bind¶: 返回与此表关联的可连接项。

attribute sqlalchemy.schema.Table.c¶

inherited from the FromClause.c attribute of FromClause

基于命名的集合 ColumnElement 由此维护的对象 FromClause .

这个 FromClause.c 属性是 FromClause.columns 属性。

返回: 一 ColumnCollection

attribute sqlalchemy.schema.Table.columns¶

inherited from the FromClause.columns attribute of FromClause

基于命名的集合 ColumnElement 由此维护的对象 FromClause .

这个 columns 或 c 集合，是使用表绑定或其他可选绑定列构造SQL表达式的网关：：

select(mytable).where(mytable.c.somecolumn == 5)

返回: 一 ColumnCollection 对象。

method sqlalchemy.schema.Table.compare(other, **kw)¶

inherited from the ClauseElement.compare() method of ClauseElement

比较一下 ClauseElement 到给定的 ClauseElement .

子类应该覆盖默认行为，这是一个直接的身份比较。

* *kw是子类消耗的参数 compare() 方法和可用于修改比较标准（请参见 ColumnElement ）

method sqlalchemy.schema.Table.compile(bind=None, dialect=None, **kw)¶

inherited from the ClauseElement.compile() method of ClauseElement

编译此SQL表达式。

参数

bind¶ -- 安 Engine 或 Connection 从哪一个 Compiled 将被收购。此参数优先于此 ClauseElement 如果有绑定的引擎。
column_keys¶ -- 用于insert和update语句，列名称的列表，应出现在编译语句的values子句中。如果 None ，将呈现目标表对象中的所有列。
dialect¶ -- A Dialect 实例，其中 Compiled 将被收购。此参数优先于 bind argument as well as this :class:`_ 子句元素表达式`如果有的话。
compile_kwargs¶ -- 附加参数的可选字典，这些参数将在所有“访问”方法中传递给编译器。例如，这允许将任何自定义标志传递给自定义编译构造。它还用于传递 literal_binds 标志通过：FROM sqlalChemy.sql导入表，列，SELECT t=TABLE(‘t’，COLUMN(‘x’))s=SELECT(T).WHERE(t.c.x==5)print(s.compile(compile_kwargs={“literal_binds”：True}))..添加的版本：：0.9.0

参见

如何将SQL表达式呈现为字符串（可能是内联绑定参数）？

attribute sqlalchemy.schema.Table.constraints = None¶

所有内容的集合 Constraint 与此关联的对象 Table 。

包括 PrimaryKeyConstraint ， ForeignKeyConstraint ， UniqueConstraint ， CheckConstraint 。单独的集合 Table.foreign_key_constraints 是指所有 ForeignKeyConstraint 对象和 Table.primary_key 属性引用单个 PrimaryKeyConstraint 与 Table 。

参见

Table.constraints

Table.primary_key

Table.foreign_key_constraints

Table.indexes

Inspector

method sqlalchemy.schema.Table.corresponding_column(column, require_embedded=False)¶

inherited from the Selectable.corresponding_column() method of Selectable

给出了一个 ColumnElement ，返回导出的 ColumnElement 对象从 Selectable.exported_columns 这个的集合 Selectable 与原件相对应 ColumnElement 通过一个共同的祖先列。

参数

column¶ -- 目标 ColumnElement 相配。
require_embedded¶ -- 仅返回给定的对应列 ColumnElement ，如果给定的 ColumnElement 实际存在于此子元素中 Selectable . 通常情况下，如果该列仅与该列的导出列共享一个共同的祖先，则该列将匹配 Selectable .

参见

Selectable.exported_columns - ColumnCollection 那是用来做手术的。

ColumnCollection.corresponding_column() -实施方法。

method sqlalchemy.schema.Table.create(bind=None, checkfirst=False)¶

发行A CREATE 声明 Table ，使用给定的 Connectable 用于连接。

注解

“bind”参数在SQLAlchemy 2.0中是必需的。

参见

MetaData.create_all() .

method sqlalchemy.schema.Table.delete(whereclause=None, **kwargs)¶

inherited from the TableClause.delete() method of TableClause

生成一个 delete() 在此基础上构建 TableClause .

例如。：：

table.delete().where(table.c.id==7)

见 delete() 获取参数和用法信息。

attribute sqlalchemy.schema.Table.description¶: inherited from the TableClause.description attribute of TableClause

attribute sqlalchemy.schema.Table.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.Table.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.Table.drop(bind=None, checkfirst=False)¶

发行A DROP 声明 Table ，使用给定的 Connectable 用于连接。

注解

“bind”参数在SQLAlchemy 2.0中是必需的。

参见

MetaData.drop_all() .

attribute sqlalchemy.schema.Table.entity_namespace¶

inherited from the FromClause.entity_namespace attribute of FromClause

返回用于SQL表达式中基于名称的访问的命名空间。

这是用于解析“filter_by（）”类型表达式的命名空间，例如：

stmt.filter_by(address='some address')

它默认为 .c 集合，但是在内部可以使用“entity_namespace”注释重写它，以传递其他结果。

method sqlalchemy.schema.Table.exists(bind=None)¶

如果此表存在，则返回true。

1.4 版后已移除: 这个 Table.exists() 方法已弃用，将在将来的版本中删除。请参考 Inspector.has_table() .

attribute sqlalchemy.schema.Table.exported_columns¶

inherited from the FromClause.exported_columns attribute of FromClause

A ColumnCollection 它表示此的“导出”列 Selectable .

的“导出”列 FromClause 对象与 FromClause.columns 收集。

1.4 新版功能.

参见

Selectable.exported_columns

SelectBase.exported_columns

attribute sqlalchemy.schema.Table.foreign_key_constraints¶

ForeignKeyConstraint 此引用的对象 Table .

此列表是从 ForeignKey 当前关联的对象。

参见

Table.constraints

Table.foreign_keys

Table.indexes

attribute sqlalchemy.schema.Table.foreign_keys¶

inherited from the FromClause.foreign_keys attribute of FromClause

返回 ForeignKey 此FromClause引用的标记对象。

每个人 ForeignKey 是一个 Table -宽度 ForeignKeyConstraint 。

参见

Table.foreign_key_constraints

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

inherited from the Traversible.get_children() method of Traversible

返回直接子项 Traversible 其中的要素 Traversible .

用于访问遍历。

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

attribute sqlalchemy.schema.Table.indexes = None¶

所有内容的集合 Index 与此关联的对象 Table 。

参见

Inspector.get_indexes()

attribute sqlalchemy.schema.Table.info¶

inherited from the SchemaItem.info attribute of SchemaItem

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

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

method sqlalchemy.schema.Table.insert(values=None, inline=False, **kwargs)¶

inherited from the TableClause.insert() method of TableClause

生成 insert() 在此基础上构建 TableClause .

例如。：：

table.insert().values(name='foo')

见 insert() 获取参数和用法信息。

method sqlalchemy.schema.Table.is_derived_from(fromclause)¶

inherited from the FromClause.is_derived_from() method of FromClause

返回 True 如果这样 FromClause 是从给定的 FromClause .

例如，表的别名是从该表派生的。

method sqlalchemy.schema.Table.join(right, onclause=None, isouter=False, full=False)¶

inherited from the FromClause.join() method of FromClause

返回A Join 由此 FromClause 对另一个 FromClause .

例如。：：

from sqlalchemy import join

j = user_table.join(address_table,
                user_table.c.id == address_table.c.user_id)
stmt = select(user_table).select_from(j)

将沿着以下行发出SQL:：

SELECT user.id, user.name FROM user
JOIN address ON user.id = address.user_id

参数

right¶ -- 连接的右侧；这是任何 FromClause 对象，如 Table 对象，也可以是可选的兼容对象，如ORM映射类。
onclause¶ -- 表示联接的ON子句的SQL表达式。如果留在 None ， FromClause.join() 将尝试基于外键关系联接两个表。
isouter¶ -- 如果为true，则呈现左侧外部联接，而不是联接。
full¶ -- 如果为true，则呈现完整的外部联接，而不是左外部联接。暗示 FromClause.join.isouter . …添加的版本：1.1

参见

join() -独立函数

Join -生成的对象类型

attribute sqlalchemy.schema.Table.key¶

返回此的“密钥” Table .

此值用作 MetaData.tables 收集。它通常与 Table.name 一张没有的桌子 Table.schema 设置；否则它通常是 schemaname.tablename .

attribute sqlalchemy.schema.Table.kwargs¶

inherited from the DialectKWArgs.kwargs attribute of DialectKWArgs

同义词 DialectKWArgs.dialect_kwargs .

method sqlalchemy.schema.Table.lateral(name=None)¶

inherited from the Selectable.lateral() method of Selectable

返回此的横向别名 Selectable .

返回值是 Lateral 顶层也提供施工 lateral() 功能。

1.1 新版功能.

参见

横向相关 -使用概述。

class memoized_attribute(fget, doc=None)¶: 只读@属性，只计算一次。

method sqlalchemy.schema.Table.classmethod memoized_instancemethod(fn)¶

inherited from the HasMemoized.memoized_instancemethod() method of HasMemoized

装饰一个方法记下它的返回值。

method sqlalchemy.schema.Table.outerjoin(right, onclause=None, full=False)¶

inherited from the FromClause.outerjoin() method of FromClause

返回A Join 由此 FromClause 对另一个 FromClause ，并将“Isouter”标志设置为true。

例如。：：

from sqlalchemy import outerjoin

j = user_table.outerjoin(address_table,
                user_table.c.id == address_table.c.user_id)

以上相当于：

j = user_table.join(
    address_table,
    user_table.c.id == address_table.c.user_id,
    isouter=True)

参数

right¶ -- 连接的右侧；这是任何 FromClause 对象，如 Table 对象，也可以是可选的兼容对象，如ORM映射类。
onclause¶ -- 表示联接的ON子句的SQL表达式。如果留在 None ， FromClause.join() 将尝试基于外键关系联接两个表。
full¶ -- 如果为true，则呈现完整的外部联接，而不是左外部联接。…添加的版本：1.1

参见

FromClause.join()

Join

method sqlalchemy.schema.Table.params(*optionaldict, **kwargs)¶

inherited from the Immutable.params() method of Immutable

用以下方式退还一份副本 bindparam() 已替换元素。

返回此ClauseElement的副本，其中包含 bindparam() 元素替换为从给定字典中获取的值：：

>>> clause = column('x') + bindparam('foo')
>>> print(clause.compile().params)
{'foo':None}
>>> print(clause.params({'foo':7}).compile().params)
{'foo':7}

attribute sqlalchemy.schema.Table.primary_key¶

inherited from the FromClause.primary_key attribute of FromClause

返回的iterable集合 Column 对象，这些对象构成 _selectable.FromClause .

对于一个 Table 对象，此集合由 PrimaryKeyConstraint 它本身就是 Column 物体。

method sqlalchemy.schema.Table.replace_selectable(old, alias)¶

inherited from the Selectable.replace_selectable() method of Selectable

替换所有出现的 FromClause “旧”与给定 Alias 对象，返回此 FromClause .

1.4 版后已移除: 这个 Selectable.replace_selectable() 方法已弃用，将在将来的版本中删除。通过sqlacalchemy.sql.visitors模块可以使用类似的功能。

method sqlalchemy.schema.Table.select(whereclause=None, **kwargs)¶

inherited from the FromClause.select() method of FromClause

返回此选项 FromClause .

例如。：：

stmt = some_table.select().where(some_table.c.id == 5)

参数

whereclause¶ -- 调用子句，相当于调用 Select.where() 方法。。已弃用：：1.4 FromClause.select().whereclause 参数已弃用，将在版本2.0中删除。请利用 Select.where() 方法将WHERE条件添加到SELECT语句。
**kwargs¶ -- 其他关键字参数传递给的旧构造函数 Select 描述在 Select.create_legacy_select() .

参见

select() -允许任意列列表的通用方法。

method sqlalchemy.schema.Table.self_group(against=None)¶

inherited from the ClauseElement.self_group() method of ClauseElement

对此应用“分组” ClauseElement .

底座 self_group() 方法 ClauseElement 只需返回自我。

method sqlalchemy.schema.Table.table_valued()¶

inherited from the FromClause.table_valued() method of FromClause

返回一个 TableValuedColumn 此对象的 FromClause 。

A TableValuedColumn 是一种 ColumnElement 它表示表中的完整行。对此构造的支持依赖于后端，并且由PostgreSQL、Oracle和SQL Server等后端以各种形式支持。

例如。：：

>>> from sqlalchemy import select, column, func, table
>>> a = table("a", column("id"), column("x"), column("y"))
>>> stmt = select(func.row_to_json(a.table_valued()))
>>> print(stmt)
SELECT row_to_json(a) AS row_to_json_1
FROM a

1.4.0b2 新版功能.

参见

使用SQL函数 - in the SQLAlchemy 1.4/2.0教程

method sqlalchemy.schema.Table.tablesample(sampling, name=None, seed=None)¶

inherited from the FromClause.tablesample() method of FromClause

返回此的TableSample别名 FromClause .

返回值是 TableSample 顶层也提供施工 tablesample() 功能。

1.1 新版功能.

参见

tablesample() -使用指南和参数

method sqlalchemy.schema.Table.to_metadata(metadata, schema=symbol('retain_schema'), referred_schema_fn=None, name=None)¶

返回此的副本 Table 与不同的 MetaData .

例如。：：

m1 = MetaData()

user = Table('user', m1, Column('id', Integer, primary_key=True))

m2 = MetaData()
user_copy = user.to_metadata(m2)

在 1.4 版更改: 这个 Table.to_metadata() 函数已从重命名 Table.tometadata() .

参数

metadata¶ -- 靶标 MetaData 对象，新的 Table 将创建对象。
schema¶ -- 指示目标架构的可选字符串名称。默认为特殊符号 RETAIN_SCHEMA 这表示在新的 Table . 如果设置为字符串名称，则 Table 将这个新名称作为 .schema . 如果设置为 None ，该架构将设置为目标上设置的架构的架构。 MetaData ，这通常是 None 同样，除非显式设置：：m2=MetaData（schema='newschema'）#user_copy_one将使用“newschema”作为模式名user_copy_one=user.to_元数据（m2，schema=None）m3=MetaData（）#schema默认为None#user_copy_two将使用None作为架构名称user_copy_two=user.to_元数据（m3，模式=无）
referred_schema_fn¶ -- 可选的可调用文件，可提供该文件以提供应分配给引用表的架构名称。 ForeignKeyConstraint . 可调用对象接受此父对象 Table ，我们要更改的目标模式 ForeignKeyConstraint 对象，以及该约束的现有“目标模式”。函数应返回应应用的字符串架构名称。E、 g.：：def refered_schema_fn（table，to_schema，constraint，refered_schema）：如果referenced_schema=='基_tables'：返回被引用的架构else:返回到u schema new_table=table.to_元数据（m2，schema=“alt峈schema”，referenced_schema_fn=引用的_schema_fn。。版本添加：：0.9.2
name¶ -- 指示目标表名称的可选字符串名称。如果未指定或未指定，则保留表名。这允许 Table 复制到相同的 MetaData 使用新名称作为目标。…版本已添加：：1.0.0

method sqlalchemy.schema.Table.tometadata(metadata, schema=symbol('retain_schema'), referred_schema_fn=None, name=None)¶

返回此的副本 Table 与不同的 MetaData .

1.4 版后已移除: Table.tometadata() is renamed to Table.to_metadata()

见 Table.to_metadata() 完整描述。

method sqlalchemy.schema.Table.unique_params(*optionaldict, **kwargs)¶

inherited from the Immutable.unique_params() method of Immutable

用以下方式退还一份副本 bindparam() 已替换元素。

与以下功能相同的功能 ClauseElement.params() ，除添加 unique=True 绑定受影响的参数，以便可以使用多个语句。

method sqlalchemy.schema.Table.update(whereclause=None, values=None, inline=False, **kwargs)¶

inherited from the TableClause.update() method of TableClause

生成 update() 在此基础上构建 TableClause .

例如。：：

table.update().where(table.c.id==7).values(name='foo')

见 update() 获取参数和用法信息。

class sqlalchemy.schema.ThreadLocalMetaData¶

呈现不同 bind 在每一条线上。

1.4 版后已移除: ThreadLocalMetaData 已弃用，将在将来的版本中删除。

使 bind 元数据的属性是线程本地值，允许将此表集合绑定到不同的 Engine 每个线程中的实现或连接。

线程localmetadata开始绑定到每个线程中的none。必须通过将赋值给 bind 财产或使用 connect() . 每个线程也可以动态地重新绑定多次，就像常规的 MetaData .

类签名

class sqlalchemy.schema.ThreadLocalMetaData (sqlalchemy.schema.MetaData)

method sqlalchemy.schema.ThreadLocalMetaData.__init__()¶: 构造ThreadLocalMetadata。

attribute sqlalchemy.schema.ThreadLocalMetaData.bind¶

此线程的绑定引擎或连接。

此属性可以被分配一个引擎或连接，或者分配一个字符串或url以自动为此绑定创建基本引擎 create_engine() .

method sqlalchemy.schema.ThreadLocalMetaData.dispose()¶: 在所有线程上下文中释放所有绑定引擎。

method sqlalchemy.schema.ThreadLocalMetaData.is_bound()¶: 如果此线程有绑定，则为true。