使用 MetaData 描述数据库¶
本节讨论基本的 Table， Column
和 MetaData 对象。
另请参阅
使用数据库元数据 - SQLAlchemy Unified 教程中 SQLAlchemy 的数据库元数据概念的教程介绍
元数据实体的集合存储在一个恰当命名的对象中
元数据：
from sqlalchemy import MetaData
metadata_obj = MetaData()MetaData 是一个容器对象，它将所描述的数据库（或多个数据库）的许多不同功能保存在一起。
要表示表，请使用 Table 类。它的两个
primary 参数是表名，那么
MetaData 对象。
其余的位置参数大多是
描述每列的 Column 对象：
from sqlalchemy import Table, Column, Integer, String
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 和
字符串。SQLAlchemy 具有数十种不同特异性级别的类型，以及创建自定义类型的能力。有关类型系统的文档可以在 SQL 数据类型对象中找到。
访问表和列¶
MetaData 对象包含我们与之关联的所有架构构造。它支持几种访问这些 table 对象的方法，例如 sorted_tables 访问器，它按外键依赖关系的顺序返回每个 Table 对象的列表（即，每个 table 前面都有它引用的所有 table）：
>>> for t in metadata_obj.sorted_tables:
... print(t.name)
user
user_preference
invoice
invoice_item
在大多数情况下，单个 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"]
# a tuple of columns may be returned using multiple strings
# (new in 2.0)
emp_id, name, type = employees.c["employee_id", "name", "type"]
# 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 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，它提供了一个类似字典的接口
添加到列的集合中。 名称通常像
属性名称，例如 employees.c.employee_name。 但是对于特殊名称
替换为空格或与字典方法的名称匹配的方法，例如
ColumnCollection.keys（） 或 ColumnCollection.values（） 时，必须使用索引访问权限，例如 employees.c['values'] 或
employees.c[“some column”] 的有关详细信息，请参阅 ColumnCollection。
创建和删除数据库表¶
定义了一些 Table 对象后，假设你正在使用一个全新的数据库，你可能想做的一件事就是为这些表及其相关结构发出 CREATE 语句（顺便说一句，如果你已经有一些首选方法，比如数据库中包含的工具或现有的脚本系统——如果是这样的话，你也很有可能不想这样做。 随意跳过本节 - SQLAlchemy 不要求使用它来创建您的表）。
发出 CREATE 的通常方法是使用
create_all（） 在
MetaData 对象。此方法将发出查询，首先检查每个单独的 table 是否存在，如果未找到，将发出 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)),
)
metadata_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（） 方法。默认情况下，这些方法会发出 CREATE 或 DROP，而不管存在哪个 table：
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")),
)
employees.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（） 方法：
employees.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 构造，通常的做法是使用 Schema 迁移工具自动维护与应用程序代码相关的数据库 Schema。
SQLAlchemy 项目提供了 Alembic
migration 工具。 Alembic 具有高度可定制的
environment 和一种简约的使用模式，支持如下功能
事务性 DDL，自动生成“候选”迁移，“离线”
模式，该模式生成 SQL 脚本，并支持分支解析。
Alembic 取代了 SQLAlchemy-Migrate 项目，后者是 SQLAlchemy 的原始迁移工具，现在被视为旧版工具。
指定 Schema 名称¶
大多数数据库都支持多个“模式”的概念 - 引用备用表集和其他构造的命名空间。“模式”的服务器端几何图形有多种形式，包括特定数据库范围内的“模式”名称（例如 PostgreSQL 模式）、命名的同级数据库（例如，MySQL / MariaDB 对同一服务器上其他数据库的访问）以及其他概念，例如其他用户名拥有的表（Oracle 数据库、SQL Server），甚至是引用备用数据库文件的名称（SQLite ATTACH）或远程服务器（带同义词的 Oracle 数据库 DBLINK）。
上述所有方法（大部分）的共同点是，有一种使用字符串名称引用这组备用表的方法。SQLAlchemy 将此名称称为架构名称。在 SQLAlchemy 中，这只不过是与 Table 关联的字符串名称
对象，然后以适合
target 数据库，以便在其远程 “schema” 中引用该表，
目标数据库上的任何机制。
“schema” 名称可以直接与 Table 关联
使用 Table.schema 参数;当将 ORM 与声明式表配置一起使用时，将使用 __table_args__ 参数字典传递参数。
“schema” 名称也可能与 MetaData 相关联
对象，它将对所有 Table 自动生效
与该 MetaData 关联的对象，这些对象不会指定自己的名称。最后，SQLAlchemy 还支持通常用于多租户应用程序的“动态”模式名称系统，以便一组 Table 元数据可以基于每个连接或每个语句引用一组动态配置的模式名称。
另请参阅
带有声明性表的显式架构名称 - 使用 ORM 时的架构名称规范
声明式表配置
最基本的示例是使用 Core Table 对象的 Table.schema 参数，如下所示：
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 呈现的 SQL（例如下面的 SELECT 语句）将使用 remote_banks 架构名称显式限定 table name financial_info：
>>> print(select(financial_info))
SELECT remote_banks.financial_info.id, remote_banks.financial_info.value
FROM remote_banks.financial_info
当 Table 对象使用显式架构名称声明时，它将使用架构和表名称的组合存储在内部 MetaData 命名空间中。我们可以通过搜索键 'remote_banks.financial_info' 在 MetaData.tables 集合中查看这一点：
>>> 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 等数据库中尤其重要，因为 Microsoft SQL Server 通常有虚线的“数据库/所有者”令牌。令牌可以立即直接放在 name 中，例如：
schema = "dbo.scott"
使用 MetaData 指定默认 Schema 名称¶
MetaData 对象还可以通过传递
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 对象（或与 MetaData 直接关联的 Sequence 对象），如果
Table.schema 参数（默认值为 None）时，其行为就像该参数设置为值“remote_banks”一样。这包括在 MetaData 中对 Table 进行编目
使用 Schema 限定的名称，即：
metadata_obj.tables["remote_banks.financial_info"]
当使用 ForeignKey 或 ForeignKeyConstraint 时
对象来引用此表，则 Schema 限定名称或
非架构限定名称可用于引用 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.schema，一个希望
要指定它不应是架构限定的，可以使用特殊符号
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"
)
另请参阅
应用动态 Schema 命名约定¶
Table.schema 参数使用的名称也可以应用于基于每个连接或每个执行的动态查找，例如，在多租户情况下，每个事务或语句都可以针对一组特定的更改架构名称。架构名称的翻译部分介绍了如何使用此功能。
另请参阅
为新连接设置默认模式¶
上述方法都是指在 SQL 语句中包含显式 schema-name 的方法。数据库连接实际上具有“默认”模式的概念，它是“模式”（或数据库、所有者等）的名称，如果表名没有明确地进行模式限定，则会发生该模式。这些名称通常在登录级别配置，例如连接到 PostgreSQL 数据库时，默认的 “schema” 称为 “public”。
通常情况下，无法通过登录设置默认的 “schema”
本身，而是在每次建立连接时进行有用的配置，
在 PostgreSQL 上使用 “SET SEARCH_PATH” 等语句，或在 PostgreSQL 上使用 “ALTER SESSION” 等语句
Oracle 数据库。 这些方法可以通过使用
PoolEvents.connect（） 事件，该事件允许在首次创建 DBAPI 连接时对其进行访问。例如，要将 Oracle Database CURRENT_SCHEMA 变量设置为备用名称：
from sqlalchemy import event
from sqlalchemy import create_engine
engine = create_engine(
"oracle+oracledb://scott:tiger@localhost:1521?service_name=freepdb1"
)
@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()
在上面，当上述 Engine 首次连接时，set_current_schema（） 事件处理程序将立即发生;由于事件被“插入”到处理程序列表的开头，它也将在 Dialect 自己的事件处理程序运行之前发生，特别是包括将确定连接的“默认模式”的事件处理程序。
对于其他数据库，请查阅数据库和/或方言文档，了解有关如何配置默认架构的特定信息。
在 1.4.0b2 版本发生变更： 上述配方现在无需建立其他事件处理程序即可工作。
另请参阅
在 Connect 上设置备用搜索路径 - 在 PostgreSQL 方言文档中。
模式和反射¶
SQLAlchemy 的 schema 功能与 Reflecting Database Objects 中介绍的表反射功能交互。 请参阅该部分
Reflecting Tables from Other Schemas 了解有关其工作原理的更多详细信息。
后端特定的选项¶
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",
)
其他后端也可能支持 table 级选项 - 这些选项将在每种方言的单独文档部分中进行描述。
列、表、元数据 API¶
对象名称 |
描述 |
|---|---|
|
|
|
|
|
|
|
|
|
|
|
-
属性sqlalchemy.schema.sqlalchemy.schema.sqlalchemy.schema。BLANK_SCHEMA
-
属性sqlalchemy.schema.sqlalchemy.schema.sqlalchemy.schema。RETAIN_SCHEMA
-
类 sqlalchemy.schema 中。列¶
表示数据库表中的列。
成员
__eq__（）， __init__（）， __le__（）， __lt__（）， __ne__（）， all_（）， anon_key_label， anon_label， any_（）， argument_for（）， asc（）， between（）， bitwise_and（）， bitwise_lshift（）， bitwise_not（）、bitwise_or（）、bitwise_rshift（）、bitwise_xor（）、bool_op（）、cast（）、collate（）、compare（）、compile（）、concat（）、contains（）、copy（）、desc（） dialect_kwargs、dialect_options、distinct（）、endswith（）、表达式、foreign_keys、get_children（）、icontains（）、iendswith（）、ilike（）、in_（）、索引、信息、inherit_cache、is_（）、 is_distinct_from（）、 is_not（）、 is_not_distinct_from（）、 isnot（）、 isnot_distinct_from（）、 istartswith（）、 key、 kwargs、 label（）、 like（）、 match（）、 not_ilike（）， not_in（）， not_like（）， notilike（）， notin_（）， notlike（）， nulls_first（）， nulls_last（）， nullsfirst（）， nullslast（）， op（）， operate（）， params（）， proxy_set， references（）， regexp_match（）， regexp_replace（）， reverse_operate（）， self_group（）， shares_lineage（）， startswith（）， timetuple， unique， unique_params（）
类签名
类sqlalchemy.schema.Column（sqlalchemy.sql.base.DialectKWArgs，sqlalchemy.schema.SchemaItem，sqlalchemy.sql.expression.ColumnClause）-
方法sqlalchemy.schema.Column 中。__eq__（其他： Any） 列运算符¶
继承自sqlalchemy.sql.expression.ColumnOperators.__eq__ColumnOperators的方法
实现==运算符。
在列上下文中，生成子句a = b。如果目标是None，则生成IS NULL。
-
方法sqlalchemy.schema.Column 中。__init__（_Column__name_pos：str_TypeEngineArgument[_T]SchemaEventTargetNone=None， _Column__type_pos：_TypeEngineArgument[_T]SchemaEventTargetNone=None， *args： SchemaEventTarget， name：strNone=None， type_：_TypeEngineArgument[_T]None=None， 自动递增： _AutoIncrementType = 'auto'， default：AnyNone=_NoArg.NO_ARG， insert_default：AnyNone=_NoArg.NO_ARG， doc：strNone=None， key：strNone=None， index：boolNone=None， unique：boolNone=None， info：_InfoTypeNone=None， nullable：boolLiteral[SchemaConst.NULL_UNSPECIFIED]None=SchemaConst.NULL_UNSPECIFIED， onupdate：AnyNone=None， primary_key： bool = False， server_default：_ServerDefaultArgumentNone=无， server_onupdate：_ServerOnUpdateArgumentNone=无， quote：boolNone=无， system： bool = False， comment：strNone=无， insert_sentinel：bool = False，_omit_from_statements：bool = False， _proxies：AnyNone=None， **dialect_kwargs： Any）¶
构造一个新的Column对象。
参数
名称¶–
此列的名称，如数据库中所示。此参数可以是第一个位置参数，也可以通过 keyword 指定。
不包含大写字符的名称将被视为不区分大小写的名称，除非它们是保留字，否则不会被引用。包含任意数量的大写字符的名称将被准确引用和发送。请注意，此行为甚至适用于将大写名称标准化为不区分大小写的数据库，例如 Oracle Database。type_¶ –
列的类型，使用子类TypeEngine的实例指示。如果该类型不需要参数，则也可以发送该类型的类，例如：# use a type with arguments Column("data", String(50)) # use no arguments Column("level", Integer)
type参数可以是第二个位置参数，也可以由 keyword 指定。
如果类型为None或被省略，它将首先默认为特殊类型NullType。 如果以及何时此Column用于引用另一个列，使用ForeignKey和/或ForeignKeyConstraint时，远程引用的列的类型也会被复制到该列，此时针对该远程Column对象解析外键。
args¶– 其他位置参数包括各种 将应用的SchemaItem派生结构 作为选项添加到列。 这些实例包括约束、ForeignKey、ColumnDefault、Sequence、ComputedIdentity的 ColumnDefault 和 Sequence 的 Identified 中。在某些情况下，可以使用等效的关键字参数，例如server_default、default和unique。
autoincrement¶–
为 没有外键依赖项的整数主键列 （有关更具体的定义，请参阅此文档字符串后面的内容）。 这可能会影响在表创建期间为此列发出的 DDL，以及在编译和执行 INSERT 语句时如何考虑该列。
默认值为字符串“auto”，它表示 INTEGER 类型的单列（即非复合）主键，没有指示其他客户端或服务器端默认结构，应自动接收自动递增语义。其他值包括True（强制此列也具有复合主键的自增语义）、False（此列不应具有自增语义）和字符串“ignore_fk”（外键列的特殊情况，见下文）。
术语“自动增量语义”是指当MetaData.create_all（）和Table.create（）的调用，以及在编译 INSERT 语句并将其发送到数据库时如何考虑该列：
DDL 渲染（即MetaData.create_all（） ），Table.create（））：当用于具有没有其他 default-generating 结构（例如Sequence或Identity构造）、参数 将暗示特定于数据库的关键字（如 PostgreSQL SQL Server 上的SERIAL、MySQLAUTO_INCREMENT或IDENTITY也应该被渲染。 并非每个数据库后端都有 “隐含”默认生成器可用;例如 Oracle Database backends 始终需要一个显式结构，例如Identity包含在Column中，以便渲染的 DDL 包含也将在数据库中生成的自动生成构造。
INSERT 语义（即当insert（）结构为 编译成 SQL 字符串，然后使用Connection.execute（）或等效项）：单行 INSERT 语句将产生一个新的整数主键 值，该列将可以访问 通过CursorResult.inserted_primary_key属性添加到Result对象。当 ORM 映射的对象持久化到数据库时，这也适用于 ORM 的使用，这表明新的整数主键将可用于成为该对象身份键的一部分。无论 DDL 结构与Column关联什么，都会发生此行为，并且独立于上面说明中讨论的“DDL Rendering”行为。
该参数可以设置为True，以指示作为复合（即多列）主键一部分的列应具有自动增量语义，但请注意，主键中只有一列可能具有此设置。也可以将其设置为True以指示配置了 client-side 或 server-side default 的列上的自动增量语义，但请注意，并非所有方言都可以将所有 default 样式作为“autoincrement”来容纳。也可以在数据类型为 INTEGER 的单列主键上将其设置为False，以便禁用该列的自动增量语义。
该设置仅对以下列有效：
整数派生（即 INT、SMALLINT、BIGINT）。
主键的一部分
不通过ForeignKey引用另一列，除非该值指定为'ignore_fk'：# turn on autoincrement for this column despite # the ForeignKey() Column( "id", ForeignKey("other.id"), primary_key=True, autoincrement="ignore_fk", )
通常不希望在通过外键引用另一个列的列上启用“autoincrement”，因为这样的列需要引用源自其他位置的值。
该设置对满足上述条件的列有以下影响：
DDL （如果列尚未包含 后端支持的默认生成结构，例如Identity将包含特定于数据库的关键字，旨在将此列表示为特定后端的 “autoincrement” 列。主要 SQLAlchemy 方言的行为包括：
MySQL 和 MariaDB 上的 AUTO INCREMENT
PostgreSQL 上的 SERIAL
IDENTITY - 即使没有Identity结构作为Column.autoincrement参数早于此构造。
SQLite - SQLite 整数主键列是隐式的 “自动递增” ，并且不会呈现其他关键字;呈现特殊的 SQLite 关键字AUTOINCREMENT不包括在内，因为这是不必要的，也不推荐 由数据库供应商提供。 请参阅该部分 SQLite 自动递增行为 了解更多背景信息。
Oracle Database - Oracle Database 方言目前没有默认的“自动递增”功能，而是标识construct 来实现此目的（序列 也可以使用 construct）。
第三方方言 - 有关其特定行为的详细信息，请参阅这些方言的文档。
编译并执行单行insert（）结构时，不会设置Insert.inline（）modifier，为此列新生成的主键值 将在语句执行时自动检索 使用特定于正在使用的数据库驱动程序的方法：
MySQL、SQLite - 调用cursor.lastrowid（）（参见 https://www.python.org/dev/peps/pep-0249/#lastrowid）
PostgreSQL、SQL Server、Oracle Database - 在呈现 INSERT 语句时使用 RETURNING 或等效结构，然后在执行后检索新生成的主键值
PostgreSQL、Oracle Database forTable对象将Table.implicit_returning设置为 False — 仅对于Sequence，在 INSERT 语句发生之前显式调用Sequence，以便新生成的主键值可供客户端使用
SQL Server forTable对象将Table.implicit_returning设置为 False - 在调用 INSERT 语句后使用SELECT scope_identity（）构造来检索新生成的主键值。
第三方方言 - 有关其特定行为的详细信息，请参阅这些方言的文档。
对于使用参数列表（即 “executemany” 语义）调用的多行insert（）结构，主键检索行为通常被禁用，但是可能有特殊的 API 可用于检索 “executemany” 的新主键值列表，例如 psycopg2 “fast insertmany” 功能。此类功能非常新，可能尚未在文档中得到充分介绍。
默认¶ –
标量、Python 可调用对象或ColumnElement表达式，表示 此列的默认值，如果未在 insert 的 VALUES 子句中指定此列，则将在 INSERT 时调用该值。这是将ColumnDefault用作位置参数的快捷方式;有关参数结构的完整详细信息，请参阅该类。
将此参数与Column.server_default这会在数据库端创建一个默认生成器。
另请参阅insert_default¶ –
Column.default的别名 以与mapped_column（）兼容。
doc¶ – ORM 或类似可以使用的可选 String 在 Python 端记录属性。 此属性执行 不呈现 SQL 注释;使用列.comment参数。
key¶– 一个可选的字符串标识符，用于标识此Column对象。当提供键时，这是在应用程序中引用Column的唯一标识符，包括 ORM 属性映射;name字段仅在呈现 SQL 时使用。
索引¶ –
如果为 True，则表示Index将为此自动生成 constructColumn，这将导致在调用 DDL 创建作时为Table发出 “CREATE INDEX” 语句。
使用此标志等效于使用Index结构在Table结构本身：Table( "some_table", metadata, Column("x", Integer), Index("ix_some_table_x", "x"), )
要将Index.unique标志添加到索引，将Column.unique和Column.index同时标记为 True，这将具有渲染 “CREATE UNIQUE INDEX” DDL 指令而不是 “CREATE INDEX” 的效果。
索引的名称是使用 默认命名约定 其中的Index构造的格式为ix_<tablename>_<columnname>.
由于此标志仅用于向表定义添加单列默认配置索引的常见情况，因此对于大多数用例，应首选显式使用Index构造，包括包含多个列的组合索引、带有 SQL 表达式或排序的索引、特定于后端的索引配置选项、 以及使用特定名称的索引。
注意
的Column.index属性Column不指示此列是否已编制索引，仅当在此处显式设置了此标志时。要查看列的索引，请查看Table.indexes集合或使用Inspector.get_indexes（）。
info¶– 可选的数据字典，将被填充到SchemaItem.info对象的属性。
可为空¶ –
当设置为False时，将导致 “NOT NULL” phrase （要添加的短语）。 什么时候True，通常不会生成任何内容（在 SQL 中默认为 “NULL”），除非在一些非常具体的特定于后端的边缘情况下，“NULL”可能会显式呈现。默认为True，除非Column.primary_key也是True，或者列指定了Identity，在这种情况下，它默认为False。此参数仅在发出 CREATE TABLE 语句时使用。
注意
当列指定Identity时，DDL 编译器通常会忽略此参数。PostgreSQL 数据库通过将此参数显式设置为True来允许可为 null 的标识列。onupdate¶ –
标量、Python 可调用对象或ClauseElement，表示要应用于 UPDATE 语句中的列的默认值，如果更新的 SET 子句中不存在此列，则将在更新时调用该值。这是将ColumnDefault用作位置参数的快捷方式，其中for_update=True。
另请参阅
列 INSERT/UPDATE 默认值 - onupdate 的完整讨论
primary_key¶– 如果为 True，则将此列标记为主键 列。多个列可以设置此标志以指定 复合主键。作为替代方法，一个Table可以通过显式的PrimaryKeyConstraint对象。server_default¶ –
一个FetchedValue实例、str、Unicode 或text（）结构，表示列的 DDL DEFAULT 值。
String 类型将按原样发出，并用单引号括起来：Column("x", Text, server_default="val")
将渲染：x TEXT DEFAULT 'val'
text（）表达式将按原样呈现，不带引号：Column("y", DateTime, server_default=text("NOW()"))
将渲染：y DATETIME DEFAULT NOW()
Strings 和 text（） 将被转换为DefaultClause对象。
此参数还可以接受上下文有效的 SQLAlchemy 表达式或构造的复杂组合：from sqlalchemy import create_engine from sqlalchemy import Table, Column, MetaData, ARRAY, Text from sqlalchemy.dialects.postgresql import array engine = create_engine( "postgresql+psycopg2://scott:tiger@localhost/mydatabase" ) metadata_obj = MetaData() tbl = Table( "foo", metadata_obj, Column( "bar", ARRAY(Text), server_default=array(["biz", "bang", "bash"]) ), ) metadata_obj.create_all(engine)
以上结果使用以下 SQL 创建表：CREATE TABLE foo ( bar TEXT[] DEFAULT ARRAY['biz', 'bang', 'bash'] )
使用FetchedValue表示已经存在的列将在数据库端生成一个默认值，该值将可用于 SQLAlchemy 在插入后进行后取。此构造不指定任何 DDL，并且 implementation 留给数据库，例如通过触发器。
另请参阅
服务器调用的 DDL-Explicit 默认表达式 - 服务器端默认值的完整讨论server_onupdate¶ –
一个FetchedValue实例，表示数据库端默认生成函数，例如触发器。这向 SQLAlchemy 表明新生成的值在更新后将可用。此构造实际上并未在数据库中实现任何类型的生成函数，而是必须单独指定。
警告
此指令目前不会生成 MySQL 的 “ON UPDATE CURRENT_TIMESTAMP（）” 子句。 看 为 MySQL / MariaDB 的 explicit_defaults_for_timestamp 渲染 ON UPDATE CURRENT TIMESTAMP，以获取有关如何生成此子句的背景信息。
另请参阅
quote¶– 强制引用此列的名称，对应于True或False。当保留为默认值None时，将根据名称是否区分大小写（至少具有一个大写字符的标识符被视为区分大小写）或是否为保留字来引用列标识符。此标志仅用于强制引用 SQLAlchemy 方言不知道的保留字。
唯一¶ –
当true和Column.indexparameter 保留为默认值False，则表示UniqueConstraint将为此自动生成 constructColumn，这将导致在调用Table对象的 DDL 创建作时，引用此列的“UNIQUE CONSTRAINT”子句包含在发出的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;在没有命名约定的情况下 对于封闭的MetaData，UNIQUECONSTRAINT 构造将作为 unnamed 发出，这通常调用特定于数据库的命名约定。
由于此标志仅用于向表定义添加单列、默认配置的唯一约束的常见情况，因此对于大多数用例，应首选显式使用UniqueConstraint构造，包括包含多个列的复合约束、特定于后端的索引配置选项以及使用特定名称的约束。
注意
的Column.unique属性Column不指示此列是否具有唯一约束或 not，仅当此处明确设置了此标志时。 查看 可能涉及此列的索引和唯一约束， 查看Table.indexes和/或Table.constraints集合或使用Inspector.get_indexes（）和/或Inspector.get_unique_constraints()
系统¶ –
如果为 True，则表示这是 “system” 列， 该列由 数据库，并且不应包含在CREATE TABLE语句。
对于列应在不同后端有条件地以不同方式呈现的更详细方案，请考虑CreateColumn的自定义编译规则。
评论¶ –
可选字符串，将在创建表时呈现 SQL 注释。insert_sentinel¶ –
将此列标记为 Insert Sentinel 用于优化 insertmanyValues 功能。
在 2.0.10 版本加入.
-
方法sqlalchemy.schema.Column 中。__le__（other： Any） 列运算符¶
继承自sqlalchemy.sql.expression.ColumnOperators.__le__ColumnOperators的方法
实现<=运算符。
在列上下文中，生成子句a <= b。
-
方法sqlalchemy.schema.Column 中。__lt__（other： Any） 列运算符¶
继承自sqlalchemy.sql.expression.ColumnOperators.__lt__ColumnOperators的方法
实现<运算符。
在列上下文中，生成子句a < b。
-
方法sqlalchemy.schema.Column 中。__ne__（other： Any） ColumnOperators¶
继承自sqlalchemy.sql.expression.ColumnOperators.__ne__ColumnOperators的方法
实现！=运算符。
在列上下文中，生成子句a ！= b。如果目标是None，则生成IS NOT NULL。
-
方法sqlalchemy.schema.Column 中。all_（） 列运算符¶ -
针对父对象生成all_（）子句。
有关示例，请参阅all_（）的文档。
注意
一定不要混淆较新的ColumnOperators.all_（）方法替换为旧版 版本，则 Comparator.all（）方法，它使用不同的调用样式。
-
属性sqlalchemy.schema.Column。anon_key_label¶ -
1.4 版后已移除：ColumnElement.anon_key_label属性现在是 private，而 public 访问器已弃用。
-
属性sqlalchemy.schema.Column。anon_label¶ -
1.4 版后已移除：ColumnElement.anon_label属性现在是 private，而 public 访问器已弃用。
-
方法sqlalchemy.schema.Column 中。any_（） 列运算符¶ -
针对父对象生成any_（）子句。
有关示例，请参阅any_（）的文档。
注意
一定不要混淆较新的ColumnOperators.any_（）方法替换为旧版 版本，则 Comparator.any（）方法，它使用不同的调用样式。
-
类方法sqlalchemy.schema.Column 中。argument_for（dialect_name， argument_name， 默认）¶ -
为此类添加一种新的特定于方言的关键字参数。
例如：Index.argument_for("mydialect", "length", None) some_index = Index("a", "b", mydialect_length=5)
DialectKWArgs.argument_for（）方法是按参数计算的 方式向DefaultDialect.construct_arguments字典。此字典代表方言提供各种架构级构造接受的参数名称列表。
新方言通常应将此字典一次性指定为 dialect 类的数据成员。临时添加参数名称的用例通常用于最终用户代码，这些代码也使用使用额外参数的自定义编译方案。
参数
dialect_name¶ – 方言的名称。方言必须是可定位的，否则会引发NoSuchModuleError。 这 dialect 还必须包含现有的DefaultDialect.construct_argumentscollection，表示它参与关键字参数验证和默认系统，否则会引发ArgumentError。如果 dialect 不包含此集合，则已经可以代表此 dialect 指定任何 keyword 参数。SQLAlchemy 中打包的所有方言都包含此集合，但对于第三方方言，支持可能会有所不同。
argument_name¶ – 参数的名称。
default¶ – 参数的默认值。
-
方法sqlalchemy.schema.Column 中。asc（） 列运算符¶
继承自ColumnOperators的ColumnOperators.asc（）方法
针对父对象生成asc（）子句。
-
方法sqlalchemy.schema.Column 中。between（cleft： 任意， cright： 任意， 对称： bool = False） 列运算符¶ -
在给定下限和上限范围的情况下，针对父对象生成一个between（）子句。
-
方法sqlalchemy.schema.Column 中。bitwise_and（其他： Any） ColumnOperators¶ -
产生一个按位的 AND 运算，通常通过&算子。
2.0.2 新版功能.
另请参阅
-
方法sqlalchemy.schema.Column 中。bitwise_lshift（other： Any） 列运算符¶ -
产生按位 LSHIFT 运算，通常通过<<算子。
2.0.2 新版功能.
另请参阅
-
方法sqlalchemy.schema.Column 中。bitwise_not（） 列运算符¶ -
产生一个按位的 NOT 运算，通常通过~算子。
2.0.2 新版功能.
另请参阅
-
方法sqlalchemy.schema.Column 中。bitwise_or（other： Any） 列运算符¶ -
生成按位 OR 运算，通常通过|算子。
2.0.2 新版功能.
另请参阅
-
方法sqlalchemy.schema.Column 中。bitwise_rshift（other： Any） 列运算符¶ -
生成按位 RSHIFT 运算，通常通过>>算子。
2.0.2 新版功能.
另请参阅
-
方法sqlalchemy.schema.Column 中。bitwise_xor（other： Any） ColumnOperators¶ -
生成按位 XOR 运算，通常通过^运算符，或者#表示 PostgreSQL。
2.0.2 新版功能.
另请参阅
-
方法sqlalchemy.schema.Column 中。bool_op（opstring： str， precedence： int = 0， python_impl：Callable[[...]，Any]None=None） Callable[[Any]， 运算符]¶
继承自Operators的Operators.bool_op（）方法
返回自定义布尔运算符。
此方法是调用Operators.op（）并将Operators.op.is_comparisonflag 替换为 True。 使用Operators.bool_op（）的主要优势 是，当使用列构造时， 返回的 expression 将用于 PEP 484 目的。
另请参阅
-
方法sqlalchemy.schema.Column 中。cast（type_： _TypeEngineArgument[_OPT]） cast[_OPT]¶
继承自ColumnElement的ColumnElement.cast（）方法
生成类型转换，即CAST（<expression> AS <type>）。
这是cast（）函数的快捷方式。
-
方法sqlalchemy.schema.Column 中。collate（collation： str） 列运算符¶ -
给定排序规则字符串，针对父对象生成collate（）子句。
另请参阅
-
方法sqlalchemy.schema.Column 中。compare（other： ClauseElement， **kw： Any） bool¶
继承自ClauseElement的ClauseElement.compare（）方法
将此ClauseElement与给定的ClauseElement进行比较。
子类应覆盖默认行为，即直接的恒等比较。
**kw 是子类compare（）方法使用的参数，可用于修改比较条件（参见ColumnElement）。
-
方法sqlalchemy.schema.Column 中。compile（bind：_HasDialectNone=None， dialect：DialectNone=None， **kw： Any） 已编译¶
继承自CompilerElement的CompilerElement.compile（）方法
编译此 SQL 表达式。
返回值是一个Compiled对象。对返回值调用str（）或unicode（）将产生一个 string 表示形式。这Compiled对象还可以使用params访问器返回绑定参数名称和值的字典。
参数
bind¶– 一个Connection或Engine，可以提供Dialect以生成Compiled对象。如果bind和dialect参数都省略了，而是使用默认的 SQL 编译器。
column_keys¶ – 用于 INSERT 和 UPDATE 语句，编译语句的 VALUES 子句中应存在的列名列表。如果为None，则呈现目标表对象中的所有列。compile_kwargs¶ –
附加参数的可选字典，将在所有 “visit” 方法中传递给编译器。例如，这允许将任何自定义标志传递给自定义编译构造。它还用于传递literal_binds标志的情况：from sqlalchemy.sql import table, column, select t = table("t", column("x")) s = select(t).where(t.c.x == 5) print(s.compile(compile_kwargs={"literal_binds": True}))
-
方法sqlalchemy.schema.Column 中。concat（other： Any） 列运算符¶ -
实现 'concat' 运算符。
在列上下文中，生成子句a || b，或在 MySQL 上使用concat（）运算符。
-
方法sqlalchemy.schema.Column 中。contains（other： Any， **kw： Any） 列运算符¶ -
实现 'contains' 运算符。
生成一个 LIKE 表达式，该表达式针对字符串值中间的匹配项进行测试：column LIKE '%' || <other> || '%'
例如：stmt = select(sometable).where(sometable.c.column.contains("foobar"))
由于运算符使用LIKE、通配符 存在于 <other> 表达式中的“%”和“_”的行为也类似于通配符。对于 Literals 字符串值，可以将ColumnOperators.contains.autoescape该标志设置为True以对出现这些值 字符，以便它们与自身匹配 而不是通配符。 或者，ColumnOperators.contains.escapeparameter 将给定字符建立为转义字符，当目标表达式不是文本字符串时，该字符可能很有用。
参数
other¶ —— 要比较的表达式。这通常是一个纯字符串值，但也可以是任意 SQL 表达式。默认情况下，除非标志ColumnOperators.contains.autoescape设置为 True，否则不会对 LIKE 通配符%和_进行转义。
自动转义¶ –
布尔;当 True 时，建立转义字符 ，然后将其应用于“%”、“_”和比较值中的转义字符本身，该值假定为文本字符串，而不是 SQL 表达式。
表达式，例如：somecolumn.contains("foo%bar", autoescape=True)
将渲染为：somecolumn LIKE '%' || :param || '%' ESCAPE '/'
:p aram的值为“foo/%bar”。
转义¶ –
一个字符，当给定时，它将使用ESCAPE关键字将该字符建立为转义字符。然后，可以将此字符放在%和_的出现之前，以允许它们充当自身，而不是通配符。
表达式，例如：somecolumn.contains("foo/%bar", escape="^")
将渲染为：somecolumn LIKE '%' || :param || '%' ESCAPE '^'
该参数也可以与ColumnOperators.contains.autoescape：somecolumn.contains("foo%bar^bat", escape="^", autoescape=True)
在上面，给定的 literal 参数将被转换为“foo^%bar^^bat”在传递到数据库之前。
-
方法sqlalchemy.schema.Column 中。copy（**kw： Any） Column[Any]¶
1.4 版后已移除：Column.copy（）方法已弃用，并将在将来的版本中删除。
-
方法sqlalchemy.schema.Column 中。desc（） 列运算符¶ -
针对父对象生成desc（）子句。
-
属性sqlalchemy.schema.Column。dialect_kwargs¶ -
指定为此构造的特定于方言的选项的关键字参数的集合。
这些论点以原始的<dialect>_<kwarg>显示 格式。 仅包含实际传递的参数; 与DialectKWArgs.dialect_options集合不同，后者包含此方言已知的所有选项，包括 defaults。
该集合也是可写的;接受<dialect>_<kwarg>形式的键，其中值将组合到选项列表中。
另请参阅DialectKWArgs.dialect_options- 嵌套词典形式
-
属性sqlalchemy.schema.Column。dialect_options¶ -
指定为此构造的特定于方言的选项的关键字参数的集合。
这是一个两级嵌套注册表，键为<dialect_name>和<argument_name>。例如，postgresql_where参数将定位为：arg = my_object.dialect_options["postgresql"]["where"]
在 0.9.2 版本加入.
另请参阅DialectKWArgs.dialect_kwargs- 平面词典形式
-
方法sqlalchemy.schema.Column 中。distinct（）列运算符¶ -
针对父对象生成distinct（）子句。
-
方法sqlalchemy.schema.Column 中。endswith（other： Any， escape：strNone=None， autoescape： bool = False）列运算符¶ -
实现 'endswith' 运算符。
生成一个 LIKE 表达式，该表达式针对字符串值末尾的匹配项进行测试：column LIKE '%' || <other>
例如：stmt = select(sometable).where(sometable.c.column.endswith("foobar"))
由于运算符使用LIKE、通配符 存在于 <other> 表达式中的“%”和“_”的行为也类似于通配符。对于 Literals 字符串值，可以将ColumnOperators.endswith.autoescape该标志设置为True以对出现这些值 字符，以便它们与自身匹配 而不是通配符。 或者，ColumnOperators.endswith.escapeparameter 将给定字符建立为转义字符，当目标表达式不是文本字符串时，该字符可能很有用。
参数
other¶ —— 要比较的表达式。这通常是一个纯字符串值，但也可以是任意 SQL 表达式。默认情况下，除非标志ColumnOperators.endswith.autoescape设置为 True，否则不会对 LIKE 通配符%和_进行转义。
自动转义¶ –
布尔;当 True 时，建立转义字符 ，然后将其应用于“%”、“_”和比较值中的转义字符本身，该值假定为文本字符串，而不是 SQL 表达式。
表达式，例如：somecolumn.endswith("foo%bar", autoescape=True)
将渲染为：somecolumn LIKE '%' || :param ESCAPE '/'
:p aram的值为“foo/%bar”。
转义¶ –
一个字符，当给定时，它将使用ESCAPE关键字将该字符建立为转义字符。然后，可以将此字符放在%和_的出现之前，以允许它们充当自身，而不是通配符。
表达式，例如：somecolumn.endswith("foo/%bar", escape="^")
将渲染为：somecolumn LIKE '%' || :param ESCAPE '^'
该参数也可以与ColumnOperators.endswith.autoescape：somecolumn.endswith("foo%bar^bat", escape="^", autoescape=True)
在上面，给定的 literal 参数将被转换为“foo^%bar^^bat”在传递到数据库之前。
-
属性sqlalchemy.schema.Column。表达式¶ -
返回列表达式。
部分检查界面;返回 self。
-
属性sqlalchemy.schema.Column。foreign_keys： Set[ForeignKey] = frozenset（{}）¶ -
与此Column关联的所有ForeignKey标记对象的集合。
每个对象都是表范围的成员ForeignKeyConstraint 的 Constraint对象。
另请参阅
-
方法sqlalchemy.schema.Column 中。get_children（*， column_tables=False， **kw）¶ -
返回紧接的子HasTraverseInternals元素中。
这用于访问遍历。
kw 可能包含更改返回的集合的标志，例如，返回项的子集以减少较大的遍历，或从不同的上下文返回子项（例如架构级集合而不是子句级集合）。
-
方法sqlalchemy.schema.Column 中。icontains（other： Any， **kw： Any） 列运算符¶ -
实现icontains运算符，例如ColumnOperators.contains（）的不区分大小写版本。
生成一个 LIKE 表达式，该表达式针对字符串值中间的不敏感匹配项进行测试：lower(column) LIKE '%' || lower(<other>) || '%'
例如：stmt = select(sometable).where(sometable.c.column.icontains("foobar"))
由于运算符使用LIKE、通配符 存在于 <other> 表达式中的“%”和“_”的行为也类似于通配符。对于 Literals 字符串值，可以将ColumnOperators.icontains.autoescape该标志设置为True以对出现这些值 字符，以便它们与自身匹配 而不是通配符。 或者，ColumnOperators.icontains.escapeparameter 将给定字符建立为转义字符，当目标表达式不是文本字符串时，该字符可能很有用。
参数
other¶ —— 要比较的表达式。这通常是一个纯字符串值，但也可以是任意 SQL 表达式。默认情况下，除非标志ColumnOperators.icontains.autoescape设置为 True，否则不会对 LIKE 通配符%和_进行转义。
自动转义¶ –
布尔;当 True 时，建立转义字符 ，然后将其应用于“%”、“_”和比较值中的转义字符本身，该值假定为文本字符串，而不是 SQL 表达式。
表达式，例如：somecolumn.icontains("foo%bar", autoescape=True)
将渲染为：lower(somecolumn) LIKE '%' || lower(:param) || '%' ESCAPE '/'
:p aram的值为“foo/%bar”。
转义¶ –
一个字符，当给定时，它将使用ESCAPE关键字将该字符建立为转义字符。然后，可以将此字符放在%和_的出现之前，以允许它们充当自身，而不是通配符。
表达式，例如：somecolumn.icontains("foo/%bar", escape="^")
将渲染为：lower(somecolumn) LIKE '%' || lower(:param) || '%' ESCAPE '^'
该参数也可以与ColumnOperators.contains.autoescape：somecolumn.icontains("foo%bar^bat", escape="^", autoescape=True)
在上面，给定的 literal 参数将被转换为“foo^%bar^^bat”在传递到数据库之前。
-
方法sqlalchemy.schema.Column 中。iendswith（other： Any， escape：strNone=None， autoescape： bool = False） 列运算符¶ -
实现iendswith运算符，例如ColumnOperators.endswith（）的不区分大小写版本。
生成一个 LIKE 表达式，该表达式针对字符串值末尾的不敏感匹配项进行测试：lower(column) LIKE '%' || lower(<other>)
例如：stmt = select(sometable).where(sometable.c.column.iendswith("foobar"))
由于运算符使用LIKE、通配符 存在于 <other> 表达式中的“%”和“_”的行为也类似于通配符。对于 Literals 字符串值，可以将ColumnOperators.iendswith.autoescape该标志设置为True以对出现这些值 字符，以便它们与自身匹配 而不是通配符。 或者，ColumnOperators.iendswith.escapeparameter 将给定字符建立为转义字符，当目标表达式不是文本字符串时，该字符可能很有用。
参数
other¶ —— 要比较的表达式。这通常是一个纯字符串值，但也可以是任意 SQL 表达式。默认情况下，除非标志ColumnOperators.iendswith.autoescape设置为 True，否则不会对 LIKE 通配符%和_进行转义。
自动转义¶ –
布尔;当 True 时，建立转义字符 ，然后将其应用于“%”、“_”和比较值中的转义字符本身，该值假定为文本字符串，而不是 SQL 表达式。
表达式，例如：somecolumn.iendswith("foo%bar", autoescape=True)
将渲染为：lower(somecolumn) LIKE '%' || lower(:param) ESCAPE '/'
:p aram的值为“foo/%bar”。
转义¶ –
一个字符，当给定时，它将使用ESCAPE关键字将该字符建立为转义字符。然后，可以将此字符放在%和_的出现之前，以允许它们充当自身，而不是通配符。
表达式，例如：somecolumn.iendswith("foo/%bar", escape="^")
将渲染为：lower(somecolumn) LIKE '%' || lower(:param) ESCAPE '^'
该参数也可以与ColumnOperators.iendswith.autoescape：somecolumn.endswith("foo%bar^bat", escape="^", autoescape=True)
在上面，给定的 literal 参数将被转换为“foo^%bar^^bat”在传递到数据库之前。
-
方法sqlalchemy.schema.Column 中。ilike（other： Any， escape：strNone=None） 列运算符¶ -
实现ilike运算符，例如不区分大小写的 LIKE。
在列上下文中，生成以下任一形式的表达式：lower(a) LIKE lower(other)
或者在支持 ILIKE 运算符的后端上：a ILIKE other
例如：stmt = select(sometable).where(sometable.c.column.ilike("%foobar%"))
-
方法sqlalchemy.schema.Column 中。in_（other： Any） 列运算符¶
继承自ColumnOperators的ColumnOperators.in_（）方法
实现in运算符。
在列上下文中，生成子句列 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_([]))
在此调用形式中，表达式呈现 “empty set” 表达式。这些表达式是针对各个后端量身定制的，通常尝试获取空的 SELECT 语句作为子查询。例如在 SQLite 上，表达式为：WHERE col IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1)
在 1.4 版本发生变更： 空的 IN 表达式现在在所有情况下都使用执行时生成的 SELECT 子查询。
如果绑定参数包含bindparam.expanding标志，则可以使用该参数，例如bindparam（）：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 版本加入： 添加了 “expanding” 绑定参数
如果传递了空列表，则会呈现特定于正在使用的数据库的特殊“空列表”表达式。在 SQLite 上，这将是：WHERE COL IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1)
在 1.3 版本加入： “expanding” 绑定参数现在支持空列表select（）结构，通常是相关的标量 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¶ —— 一个字面值列表，一个 select（）构造，或者包含bindparam.expanding标志设置为 True。
-
属性sqlalchemy.schema.Column。index：boolNone¶ Column.index参数的值。
不指示此Column是否实际已编制索引;使用Table.indexes。
另请参阅
-
属性sqlalchemy.schema.Column。信息¶
继承自SchemaItem的SchemaItem.info属性
与对象关联的 Info 字典，允许用户定义的数据与此SchemaItem相关联。
-
属性sqlalchemy.schema.Column。inherit_cache：boolNone = 真¶
指示此HasCacheKey实例是否应使用其直接超类使用的缓存键生成方案。
该属性默认为None，这表示构造尚未考虑是否适合参与缓存;这在功能上等效于将值设置为False，但还会发出警告。
如果与对象对应的 SQL 不基于此类的本地属性而不是其超类而更改，则可以在特定类上将此标志设置为True。
另请参阅
启用对自定义构造的缓存支持 - 设置HasCacheKey.inherit_cache第三方或用户定义的 SQL 构造的属性。
-
方法sqlalchemy.schema.Column 中。is_（other： Any） 列运算符¶
继承自ColumnOperators的ColumnOperators.is_（）方法
实现IS运算符。
通常，在与值None进行比较时，会自动生成IS，该值解析为NULL。但是，如果与某些平台上的布尔值进行比较，则显式使用IS可能是可取的。
-
方法sqlalchemy.schema.Column 中。is_distinct_from（other： Any） 列运算符¶ -
实现IS DISTINCT FROM运算符。
在大多数平台上呈现 “a IS DISTINCT FROM b”;在某些（例如 SQLite）上可能会呈现“a IS NOT b”。
-
方法sqlalchemy.schema.Column 中。is_not（other： Any） 列运算符¶ -
实现IS NOT运算符。
通常，在与值None进行比较时，会自动生成IS NOT，该值解析为NULL。但是，如果与某些平台上的布尔值进行比较，则显式使用IS NOT可能是可取的。
在 1.4 版本发生变更：is_not（）运算符已从isnot（） 的 API中。以前的名称仍然可用于向后兼容。
-
方法sqlalchemy.schema.Column 中。is_not_distinct_from（其他： Any） 列运算符¶ -
实现IS NOT DISTINCT FROM运算符。
在大多数平台上呈现 “a IS NOT DISTINCT WITH b”;在某些（例如 SQLite）上可能会呈现“a IS b”。
在 1.4 版本发生变更：is_not_distinct_from（）运算符已从早期版本中的isnot_distinct_from（）重命名。以前的名称仍然可用于向后兼容。
-
方法sqlalchemy.schema.Column 中。isnot（other： Any） 列运算符¶ -
实现IS NOT运算符。
通常，在与值None进行比较时，会自动生成IS NOT，该值解析为NULL。但是，如果与某些平台上的布尔值进行比较，则显式使用IS NOT可能是可取的。
在 1.4 版本发生变更：is_not（）运算符已从isnot（） 的 API中。以前的名称仍然可用于向后兼容。
-
方法sqlalchemy.schema.Column 中。isnot_distinct_from（other： Any） 列运算符¶ -
实现IS NOT DISTINCT FROM运算符。
在大多数平台上呈现 “a IS NOT DISTINCT WITH b”;在某些（例如 SQLite）上可能会呈现“a IS b”。
在 1.4 版本发生变更：is_not_distinct_from（）运算符已从早期版本中的isnot_distinct_from（）重命名。以前的名称仍然可用于向后兼容。
-
方法sqlalchemy.schema.Column 中。istartswith（other： Any， escape：strNone=None， autoescape： bool = False） 列运算符¶ -
实现istartswith运算符，例如ColumnOperators.startswith（）的不区分大小写版本。
生成一个 LIKE 表达式，该表达式针对字符串值开头的不敏感匹配项进行测试：lower(column) LIKE lower(<other>) || '%'
例如：stmt = select(sometable).where(sometable.c.column.istartswith("foobar"))
由于运算符使用LIKE、通配符 存在于 <other> 表达式中的“%”和“_”的行为也类似于通配符。对于 Literals 字符串值，可以将ColumnOperators.istartswith.autoescape该标志设置为True以对出现这些值 字符，以便它们与自身匹配 而不是通配符。 或者，ColumnOperators.istartswith.escapeparameter 将给定字符建立为转义字符，当目标表达式不是文本字符串时，该字符可能很有用。
参数
other¶ —— 要比较的表达式。这通常是一个纯字符串值，但也可以是任意 SQL 表达式。默认情况下，除非标志ColumnOperators.istartswith.autoescape设置为 True，否则不会对 LIKE 通配符%和_进行转义。
自动转义¶ –
布尔;当 True 时，建立转义字符 ，然后将其应用于“%”、“_”和比较值中的转义字符本身，该值假定为文本字符串，而不是 SQL 表达式。
表达式，例如：somecolumn.istartswith("foo%bar", autoescape=True)
将渲染为：lower(somecolumn) LIKE lower(:param) || '%' ESCAPE '/'
:p aram的值为“foo/%bar”。
转义¶ –
一个字符，当给定时，它将使用ESCAPE关键字将该字符建立为转义字符。然后，可以将此字符放在%和_的出现之前，以允许它们充当自身，而不是通配符。
表达式，例如：somecolumn.istartswith("foo/%bar", escape="^")
将渲染为：lower(somecolumn) LIKE lower(:param) || '%' ESCAPE '^'
该参数也可以与ColumnOperators.istartswith.autoescape：somecolumn.istartswith("foo%bar^bat", escape="^", autoescape=True)
在上面，给定的 literal 参数将被转换为“foo^%bar^^bat”在传递到数据库之前。
-
属性sqlalchemy.schema.Column。键： str = None¶
继承自ColumnElement的ColumnElement.key属性
在某些情况下，在 Python 命名空间中引用此对象的 'key' 。
这通常是指列的 “key”.c集合，例如sometable.c[“somekey”]将返回一个 .key为 “somekey” 的Column。
-
属性sqlalchemy.schema.Column。kwargs¶
-
方法sqlalchemy.schema.Column 中。label（name：strNone） 标签[_T]¶
继承自ColumnElement的ColumnElement.label（）方法
生成列标签，即<columnname> AS <name>。
这是label（）函数的快捷方式。
如果 'name' 为None，则将生成匿名标签名称。
-
方法sqlalchemy.schema.Column 中。like（other： Any， escape：strNone=None）列运算符¶ -
实现like运算符。
在列上下文中，生成表达式：a LIKE other
例如：stmt = select(sometable).where(sometable.c.column.like("%foobar%"))
-
方法sqlalchemy.schema.Column 中。match（other： Any， **kwargs： Any） 列运算符¶ -
实现特定于数据库的 'match' 运算符。ColumnOperators.match（）尝试解析为后端提供的类似 MATCH 的函数或运算符。示例包括：
PostgreSQL - 渲染x @@ plainto_tsquery（y）
在 2.0 版本发生变更： PostgreSQL 现在使用plainto_tsquery（）而不是to_tsquery（）;有关与其他表单的兼容性，请参阅全文搜索。
MySQL - 渲染MATCH (x) AGAINST (y IN BOOLEAN MODE)
另请参阅match- 具有附加功能的 MySQL 特定构造。
Oracle 数据库 - 呈现CONTAINS（x， y）
其他后端可能会提供特殊的实现。
没有任何特殊实现的后端会将运算符发出为 “MATCH”。例如，这与 SQLite 兼容。
-
方法sqlalchemy.schema.Column 中。not_ilike（other： Any， escape：strNone=None） ColumnOperators¶ -
实现NOT ILIKE运算符。
这相当于使用ColumnOperators.ilike（）的 ColumnOperators.ilike（）中，即~x.ilike（y）。
在 1.4 版本发生变更：not_ilike（）运算符已从notilike（）的 intent 函数。以前的名称仍然可用于向后兼容。
-
方法sqlalchemy.schema.Column 中。not_in（other： Any） 列运算符¶ -
实现NOT IN运算符。
这相当于使用ColumnOperators.in_（），即~x.in_（y）。
如果other是空序列，则编译器 生成 “empty not in” 表达式。 这默认为 表达式 “1 = 1” 在所有情况下都生成 true。 这create_engine.empty_in_strategy可用于更改此行为。
在 1.4 版本发生变更：not_in（）运算符从notin_（）中。以前的名称仍然可用于向后兼容。
在 1.2 版本发生变更：ColumnOperators.in_（）和ColumnOperators.not_in（）运算符现在默认为空 IN 序列生成 “static” 表达式。
-
方法sqlalchemy.schema.Column 中。not_like（other： Any， escape：strNone=None） 列运算符¶ -
实现NOT LIKE运算符。
这相当于使用ColumnOperators.like（）的 ColumnOperators.like（）中，即~x.like（y）。
在 1.4 版本发生变更：not_like（）运算符已从notlike（）的以前的名称仍然可用于向后兼容。
-
方法sqlalchemy.schema.Column 中。notilike（other： Any， escape：strNone=None） 列运算符¶ -
实现NOT ILIKE运算符。
这相当于使用ColumnOperators.ilike（）的 ColumnOperators.ilike（）中，即~x.ilike（y）。
在 1.4 版本发生变更：not_ilike（）运算符已从notilike（）的 intent 函数。以前的名称仍然可用于向后兼容。
-
方法sqlalchemy.schema.Column 中。notin_（其他： Any） 列运算符¶ -
实现NOT IN运算符。
这相当于使用ColumnOperators.in_（），即~x.in_（y）。
如果other是空序列，则编译器 生成 “empty not in” 表达式。 这默认为 表达式 “1 = 1” 在所有情况下都生成 true。 这create_engine.empty_in_strategy可用于更改此行为。
在 1.4 版本发生变更：not_in（）运算符从notin_（）中。以前的名称仍然可用于向后兼容。
在 1.2 版本发生变更：ColumnOperators.in_（）和ColumnOperators.not_in（）运算符现在默认为空 IN 序列生成 “static” 表达式。
-
方法sqlalchemy.schema.Column 中。notlike（other： Any， escape：strNone=None） 列运算符¶ -
实现NOT LIKE运算符。
这相当于使用ColumnOperators.like（）的 ColumnOperators.like（）中，即~x.like（y）。
在 1.4 版本发生变更：not_like（）运算符已从notlike（）的以前的名称仍然可用于向后兼容。
-
方法sqlalchemy.schema.Column 中。nulls_first（） 列运算符¶ -
针对父对象生成nulls_first（）子句。
在 1.4 版本发生变更：nulls_first（）运算符已从以前版本中的nullsfirst（）重命名。以前的名称仍然可用于向后兼容。
-
方法sqlalchemy.schema.Column 中。nulls_last（） 列运算符¶ -
针对父对象生成nulls_last（）子句。
在 1.4 版本发生变更：nulls_last（）运算符已从以前版本中的nullslast（）重命名。以前的名称仍然可用于向后兼容。
-
方法sqlalchemy.schema.Column 中。nullsfirst（） 列运算符¶ -
针对父对象生成nulls_first（）子句。
在 1.4 版本发生变更：nulls_first（）运算符已从以前版本中的nullsfirst（）重命名。以前的名称仍然可用于向后兼容。
-
方法sqlalchemy.schema.Column 中。nullslast（）列运算符¶ -
针对父对象生成nulls_last（）子句。
在 1.4 版本发生变更：nulls_last（）运算符已从以前版本中的nullslast（）重命名。以前的名称仍然可用于向后兼容。
-
方法sqlalchemy.schema.Column 中。op（opstring： str， 优先级： int = 0， is_comparison： bool = false， return_type：Type[TypeEngine[any]]TypeEngine[any]None=None， python_impl：Callable[...，Any]None=None） Callable[[Any]， 运算符]¶
继承自Operators的Operators.op（）方法
生成泛型运算符函数。
例如：somecolumn.op("*")(5)
生产：somecolumn * 5
此函数还可用于使按位运算符显式。例如：somecolumn.op("&")(0xFF)
是somecolumn中值的按位 AND。
参数
opstring¶ – 一个字符串，将作为此元素和传递给生成函数的表达式之间的中缀运算符输出。
优先级¶ –
优先级，数据库应应用于 SQL 表达式中的运算符。此整数值充当 SQL 编译器的提示，以了解何时应在特定作周围呈现显式括号。较小的数字将导致表达式在应用于另一个优先级较高的运算符时被括起来。默认值0低于除逗号 （，） 和AS运算符之外的所有运算符。值 100 将高于或等于所有运算符，而 -100 将小于或等于所有运算符。
另请参阅
我正在使用 op（） 生成自定义运算符，但我的括号没有正确显示 - SQLAlchemy SQL 编译器如何呈现括号的详细说明is_comparison¶ –
遗产;如果为 True，则该运算符将被视为 “比较” 运算符，即计算结果为布尔值 true/false 值，如==、>等。提供此标志是为了让 ORM 关系可以确定该运算符在自定义连接条件中使用时是比较运算符。
使用is_comparison参数将被使用Operators.bool_op（）方法;这个更简洁的运算符会自动设置此参数，但也提供正确的 PEP 484 类型支持，因为返回的对象将表示“布尔”数据类型，即BinaryExpression[bool]。
return_type¶——TypeEngine类或对象，它将 force 此运算符生成的表达式的返回类型 属于该类型。 默认情况下，指定Operators.op.is_comparison将解析为Boolean 的 Boolean和那些不 boolean 的 Boolean 将与左侧作数的类型相同。python_impl¶ –
一个可选的 Python 函数，该函数可以计算两个 Python 值，其工作方式与此运算符在数据库服务器上运行时的工作方式相同。对于 Python 内部 SQL 表达式评估函数（例如 ORM 混合属性）以及用于在多行更新或删除后匹配会话中的对象的 ORM“评估器”非常有用。
例如：>>> expr = column("x").op("+", python_impl=lambda a, b: a + b)("y")
上述表达式的运算符也适用于非 SQL 的 left 和 right 对象：>>> expr.operator(5, 10) 15
2.0 版的新Function。
-
方法sqlalchemy.schema.Column 中。operate（op： OperatorType， *other： Any， **kwargs： Any） ColumnElement[任意]¶
继承自ColumnElement的ColumnElement.operate（）方法
对参数进行作。
这是最低级别的作，加注NotImplementedError 的 MethodS错误。
在子类上覆盖 this 可以允许将通用行为应用于所有作。例如，重写ColumnOperators要将func.lower（）应用于左侧和右侧：class MyComparator(ColumnOperators): def operate(self, op, other, **kwargs): return op(func.lower(self), func.lower(other), **kwargs)
-
方法sqlalchemy.schema.Column 中。params（*optionaldict， **kwargs）¶
继承自Immutable的Immutable.params（）方法
返回替换了bindparam（）元素的副本。
返回此 ClauseElement 的副本，其中包含bindparam（）元素替换为从给定字典中获取的值：>>> clause = column("x") + bindparam("foo") >>> print(clause.compile().params) {'foo':None} >>> print(clause.params({"foo": 7}).compile().params) {'foo':7}
-
属性sqlalchemy.schema.Column。proxy_set： util.generic_fn_descriptor[FrozenSet[Any]]¶ -
我们代理的所有列的集合
从 2.0 开始，这是显式取消注释的列。以前，它实际上是取消注释的列，但并未强制执行。如果可能的话，带 Comments 的列基本上不应该进入 SETS，因为它们的哈希行为非常不稳定。
-
方法sqlalchemy.schema.Column 中。references（column： Column[Any]） bool¶
如果此 Column 通过外键引用给定的列，则返回 True。
-
方法sqlalchemy.schema.Column 中。regexp_match（pattern： Any， flags：strNone=None） 列运算符¶ -
实现特定于数据库的 '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占位符运算符并调用 Pythonre.match（）内置函数。
其他后端可能会提供特殊的实现。
没有任何特殊实现的后端会将运算符发出为 “REGEXP” 或 “NOT REGEXP”。例如，这与 SQLite 和 MySQL 兼容。
目前已为 Oracle Database、PostgreSQL、MySQL 和 MariaDB 实施正则表达式支持。SQLite 提供部分支持。第三方方言之间的支持可能会有所不同。
参数
在 1.4 版本加入.
在 1.4.48 版本发生变更： 2.0.18 请注意，由于实现错误，除了纯 Python 字符串之外，“flags”参数以前还接受 SQL 表达式对象，例如列表达式。此实现无法正确使用缓存，因此已被删除;只应为 “flags” 参数传递字符串，因为这些标志在 SQL 表达式中呈现为文本内联值。
-
方法sqlalchemy.schema.Column 中。regexp_replace（pattern： Any， replacement： Any， flags：strNone=None） 列运算符¶ -
实现特定于数据库的 'regexp replace' 运算符。
例如：stmt = select( table.c.some_column.regexp_replace("b(..)", "XY", flags="g") )
ColumnOperators.regexp_replace()尝试解析为后端提供的类似 REGEXP_REPLACE 的函数，该函数通常会发出函数REGEXP_REPLACE（）。然而 可用的特定正则表达式语法和标志包括 不是后端不可知的。
目前为 Oracle Database、PostgreSQL、MySQL 8 或更高版本以及 MariaDB 实施了正则表达式替换支持。第三方方言之间的支持可能会有所不同。
参数
在 1.4 版本加入.
在 1.4.48 版本发生变更： 2.0.18 请注意，由于实现错误，除了纯 Python 字符串之外，“flags”参数以前还接受 SQL 表达式对象，例如列表达式。此实现无法正确使用缓存，因此已被删除;只应为 “flags” 参数传递字符串，因为这些标志在 SQL 表达式中呈现为文本内联值。
-
方法sqlalchemy.schema.Column 中。reverse_operate（op： OperatorType， other： Any， **kwargs： Any） ColumnElement[Any]¶ -
Reverse 对参数进行作。
用法与operate（）相同。
-
方法sqlalchemy.schema.Column 中。self_group（反对：OperatorTypeNone=None） ColumnElement[Any]¶ -
将 'grouping' 应用于此ClauseElement。
此方法被 subclasses 覆盖以返回 “grouping” 结构，即括号。特别是，当它被 “binary” 表达式用于在放入更大的表达式时提供围绕自身的分组，以及select（）构造select（）的（请注意，子查询通常应使用Select.alias（）方法创建，因为许多平台需要命名嵌套的 SELECT 语句）。
由于表达式是组合在一起的，因此self_group（）是自动的 - 最终用户代码永远不需要直接使用此方法。请注意，SQLAlchemy 的子句构造考虑了运算符优先级 - 因此可能不需要括号，例如，在像x OR （y AND z）这样的表达式中 - AND 优先于 OR。
的base self_group（）方法子句元素只返回 self。
-
如果给定的ColumnElement具有此ColumnElement的共同上级。
-
方法sqlalchemy.schema.Column 中。startswith（other： Any， escape：strNone=None， autoescape： bool = False） 列运算符¶ -
实现startswith运算符。
生成一个 LIKE 表达式，该表达式针对字符串值开头的匹配项进行测试：column LIKE <other> || '%'
例如：stmt = select(sometable).where(sometable.c.column.startswith("foobar"))
由于运算符使用LIKE、通配符 存在于 <other> 表达式中的“%”和“_”的行为也类似于通配符。对于 Literals 字符串值，可以将ColumnOperators.startswith.autoescape该标志设置为True以对出现这些值 字符，以便它们与自身匹配 而不是通配符。 或者，ColumnOperators.startswith.escapeparameter 将给定字符建立为转义字符，当目标表达式不是文本字符串时，该字符可能很有用。
参数
other¶ —— 要比较的表达式。这通常是一个纯字符串值，但也可以是任意 SQL 表达式。默认情况下，除非标志ColumnOperators.startswith.autoescape设置为 True，否则不会对 LIKE 通配符%和_进行转义。
自动转义¶ –
布尔;当 True 时，建立转义字符 ，然后将其应用于“%”、“_”和比较值中的转义字符本身，该值假定为文本字符串，而不是 SQL 表达式。
表达式，例如：somecolumn.startswith("foo%bar", autoescape=True)
将渲染为：somecolumn LIKE :param || '%' ESCAPE '/'
:p aram的值为“foo/%bar”。
转义¶ –
一个字符，当给定时，它将使用ESCAPE关键字将该字符建立为转义字符。然后，可以将此字符放在%和_的出现之前，以允许它们充当自身，而不是通配符。
表达式，例如：somecolumn.startswith("foo/%bar", escape="^")
将渲染为：somecolumn LIKE :param || '%' ESCAPE '^'
该参数也可以与ColumnOperators.startswith.autoescape：somecolumn.startswith("foo%bar^bat", escape="^", autoescape=True)
在上面，给定的 literal 参数将被转换为“foo^%bar^^bat”在传递到数据库之前。
-
属性sqlalchemy.schema.Column。timetuple： 字面量[无] = 无¶ -
Hack 允许在 LHS 上比较日期时间对象。
-
属性sqlalchemy.schema.Column。unique：boolNone¶ Column.unique参数的值。
不指示此Column是否实际受唯一约束的约束;使用Table.indexes和Table.constraints中。
-
方法sqlalchemy.schema.Column 中。unique_params（*optionaldict， **kwargs）¶
继承自Immutable的Immutable.unique_params（）方法
返回替换了bindparam（）元素的副本。
与ClauseElement.params（）功能相同，但添加了 unique=True 添加到受影响的绑定参数中，以便多个语句可以 使用。
-
-
类 sqlalchemy.schema 中。元数据¶ Table的集合 对象及其关联的架构 构建。
保存Table对象的集合以及到Engine或连接。如果绑定，则集合中的Table对象及其列可以参与隐式 SQL 执行。Table对象本身存储在MetaData.tables字典。MetaData是用于读取作的线程安全对象。在单个MetaData中构建新表 对象 无论是显式的还是通过反射的，都不是完全线程安全的。
另请参阅
使用元数据描述数据库 - 数据库元数据简介
类签名
类sqlalchemy.schema.MetaData（）sqlalchemy.schema.HasSchemaAttr-
方法sqlalchemy.schema.MetaData 中。__init__（schema：strNone=无， quote_schema：boolNone=无， naming_convention：_NamingSchemaParameterNone=无， info：_InfoTypeNone=无） 无¶
创建新的 MetaData 对象。
参数
架构¶ –
quote_schema¶ – 为这些Table设置quote_schema标志，Sequence和其他使用本地模式名称的对象。
info¶– 可选的数据字典，将被填充到SchemaItem.info对象的属性。naming_convention¶ –
引用值的字典，它将为Constraint建立默认命名约定 和Index对象，用于未明确指定名称的对象。
此字典的键可以是：
constraint 或 Index 类，例如UniqueConstraint，ForeignKeyConstraint类中，索引类
已知约束类之一的字符串助记词;“fk”、“pk”、“ix”、“ck”、“uq”分别用于外键、主键、索引、检查和唯一约束。
用户定义的 “token” 的字符串名称，可用于定义新的命名标记。
与每个 “constraint class” 或 “constraint mnemonic“键是字符串命名模板，例如"uq_%(table_name)s_%(column_0_name)s"，它们描述了名称的组成方式。与用户定义的 “token” 键关联的值应该是fn（constraint， table）形式的可调用对象，它接受 constraint/index 对象和Table作为参数，返回字符串结果。
内置名称如下，其中一些名称可能仅适用于某些类型的约束：%（table_name）s-表的名称 对象 与 constraint 相关联。%（referred_table_name）s- 的名称桌子对象ForeignKeyConstraint 的 Constraint对象。%（column_0_name）s-列的名称 在 约束内的索引位置 “0”。%（column_0N_name）s- 所有列的名称 对象在约束内按顺序排列，在没有 分隔符。%（column_0_N_name）s- 所有列对象，用 下划线作为分隔符。%（column_0_label 个、%（column_0N_label 个）、%（column_0_N_label）s- 第 0 个的标签列或所有列，分隔带或不带下划线%（column_0_key） 个，%（column_0N_key）个，%（column_0_N_key）s- 第 0 个的键列或所有列，分隔带或不带下划线%（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） 个，...column tokens 渲染ForeignKeyConstraint引用的列的名称/键/标签。%（constraint_name）s - 一个特殊键，指的是为约束指定的现有名称。当此键存在时，Constraint对象的现有名称将替换为由使用此令牌的模板字符串组成的名称。当存在此令牌时，需要提前为Constraint指定一个显式名称。
用户定义：可以通过将其与可调用的fn（constraint， table）一起传递给 naming_convention 字典来实现任何其他令牌。
1.3.0 版本中的新功能： - 添加了新的%（column_0N_name）s，%（column_0_N_name）s 和相关标记，这些标记为给定约束引用的所有列生成名称、键或标签的串联。
另请参阅
配置约束命名约定 - 有关详细使用示例。
-
方法sqlalchemy.schema.MetaData 中。clear（） 无¶
从此 MetaData 中清除所有 Table 对象。
-
方法sqlalchemy.schema.MetaData 中。create_all（bind： _CreateDropBind， tables：_typing_Sequence[Table]None=None， checkfirst： bool = True） 无¶
创建存储在此元数据中的所有表。
默认情况下，Conditional 不会尝试重新创建目标数据库中已存在的表。
参数
bind¶- 用于访问数据库的Connection或Engine。
tables –Table 对象的可选列表，它是MetaData中总表的子集（其他的将被忽略）。
checkfirst¶– 默认为 True，不要为目标数据库中已经存在的表发出 CREATE。
-
方法sqlalchemy.schema.MetaData 中。drop_all（bind： _CreateDropBind， tables：_typing_Sequence[Table]None=None， checkfirst： bool = True） 无¶
删除此元数据中存储的所有表。
默认情况下，Conditional 不会尝试删除目标数据库中不存在的表。
参数
bind¶- 用于访问数据库的Connection或Engine。
tables –Table 对象的可选列表，它是MetaData中总表的子集（其他的将被忽略）。
checkfirst¶– 默认为 True，仅对确认存在于目标数据库中的表发出 DROP。
-
方法sqlalchemy.schema.MetaData 中。reflect（bind：EngineConnection， schema：strNone=None， views： bool = False， only：_typing_Sequence[str]Callable[[str，MetaData]，bool]None=None， extend_existing： bool =False， autoload_replace： bool = True， resolve_fks： bool = True， **dialect_kwargs： Any） None¶
从数据库中加载所有可用的表定义。
在此MetaData中自动为任何表在数据库中可用，但尚未存在于元数据。可以多次调用以选取最近添加到数据库的表，但是如果此MetaData中的表不再存在于数据库中，则不会执行任何特殊作。
参数
bind¶- 用于访问数据库的Connection或Engine。
views¶– 如果为 True，则还反映视图（具体化和普通）。
仅¶ –
自选。仅加载可用命名表的子集。可以指定为名称序列或可调用对象。
如果提供了 name 序列，则只会反映这些 table。如果请求了表但不可用，则会引发错误。此MetaData中已存在的命名表将被忽略。
如果提供了可调用对象，则它将用作布尔谓词来筛选可能的表名列表。调用可调用对象时，使用表名和此MetaData实例作为位置参数，并且应返回 true 值供任何表反映。
extend_existing¶ – 作为Table.extend_existing。
autoload_replace¶ – 传递给每个Table如Table.autoload_replace。resolve_fks¶ –
如果为 True，则反映Table已链接的对象添加到位于每个表。对于MetaData.reflect（），这具有反射的效果 可能不在表列表中的相关表 被反射，例如，如果引用的表位于 different schema 或通过MetaData.reflect.only参数。 当为 False 时，ForeignKey对象不会跟随桌子其中，如果相关表也是 在任何情况下都会反映的表列表，则ForeignKey对象仍将解析为其相关的MetaData.reflect（）之后的表格operation 为 完成。 默认为 True。
1.3.0 版本的新Function。
另请参阅
**dialect_kwargs¶– 未提及的其他关键字参数 以上是特定于方言的，并以<dialectname>_<argname>.有关记录的参数的详细信息，请参阅 Dialects 中有关单个方言的文档。
另请参阅DDLEvents.column_reflect（）- 用于自定义的事件 反射的列。通常用于使用TypeEngine.as_generic（）
使用数据库不可知类型进行反射 - 介绍如何使用常规类型反映表。
-
方法sqlalchemy.schema.MetaData 中。remove（table： Table） 无¶
从此 MetaData 中删除给定的 Table 对象。
-
属性sqlalchemy.schema.MetaData 中。sorted_tables¶
返回按外键依赖关系顺序排序的Table对象列表。
排序会将Table具有依赖项的对象 首先，在依赖项本身之前，表示 可以按照其创建顺序进行创建。 要获取 表格将被删除，请使用reversed（）Python 内置。
警告MetaData.sorted_tables属性本身无法容纳 table 之间依赖关系循环的自动解析，这通常是由相互依赖的外键约束引起的。当检测到这些循环时，这些表的外键将在排序中被忽略。发生这种情况时，会发出警告，这将是将来版本中的异常引发。不属于 cycle 的 table 仍将按依赖关系 Sequences 返回。
为了解决这些循环，ForeignKeyConstraint.use_alterparameter 可以应用于那些创建循环的约束。或者，当检测到周期时，sort_tables_and_constraints（）函数将自动在单独的集合中返回外键约束，以便它们可以单独应用于架构。
在 1.3.17 版本发生变更： - 当由于循环依赖关系，MetaData.sorted_tables 无法执行正确的排序。这将是未来版本中的例外。此外，排序将继续按依赖关系 Sequences 返回周期中不涉及的其他 table，这在以前是不是这种情况。
-
属性sqlalchemy.schema.MetaData 中。表：util。FacadeDict[str， 表]¶ Table的字典 对象键控其名称或 “table key”。
确切的键是由Table.key 确定的属性; 对于没有Table.schema属性的表，这与Table.name相同。对于具有架构的表，它通常采用schemaname.tablename格式。
-
-
类 sqlalchemy.schema 中。SchemaConst 模式常量¶
一个枚举。
类签名
类sqlalchemy.schema.SchemaConst（enum.枚举）-
属性sqlalchemy.schema.SchemaConst.BLANK_SCHEMA = 2¶
指示Table或Sequence的符号 其架构应为 'None'，即使父级MetaData已指定 schema。
-
属性sqlalchemy.schema.SchemaConst.NULL_UNSPECIFIED = 3¶
指示 “nullable” 关键字未传递给 Column 的符号。
这用于区分传递nullable=None设置为Column，这在某些后端（如 SQL Server）上具有特殊含义。
-
属性sqlalchemy.schema.SchemaConst.RETAIN_SCHEMA = 1¶
表示Table的Sequence或者在某些情况下是ForeignKey对象，在对象被复制以进行Table.to_metadata（）的情况下 作，则应保留它已有的架构名称。
-
-
类 sqlalchemy.schema 中。SchemaItem¶
定义数据库架构的项的基类。
成员
类签名
类sqlalchemy.schema.SchemaItem（sqlalchemy.sql.expression.SchemaEventTarget，sqlalchemy.sql.visitors.Visitable）-
属性sqlalchemy.schema.SchemaItem 的 SchemaItem 中。信息¶
与对象关联的 Info 字典，允许用户定义的数据与此SchemaItem相关联。
-
-
函数 sqlalchemy.schema。insert_sentinel（name：strNone=None， type_：_TypeEngineArgument[_T]None=None， *， default：AnyNone=None， omit_from_statements： bool = True） 列[Any]¶
提供代理列，该列将充当专用的插入 sentinel 列，允许对没有合格主键配置的表进行高效的批量插入和确定性的 RETURNING 排序。
将此列添加到Table对象需要相应的数据库表实际存在此列，因此，如果将其添加到现有模型，则需要迁移现有数据库表（例如使用 ALTER TABLE 或类似工具）以包含此列。
有关如何使用此对象的背景信息，请参阅该部分 将 Sentinel 列配置为 INSERT 语句的“插入多个值”行为部分的一部分。
默认情况下，返回的Column将是可为 null 的整数列，并使用仅在“insertmanyvalues”作中使用的特定于 Sentinel 的默认生成器。
在 2.0.10 版本加入.
-
类 sqlalchemy.schema 中。表格¶
表示数据库中的表。
例如：mytable = Table( "mytable", metadata, Column("mytable_id", Integer, primary_key=True), Column("value", String(50)), )
桌子object 会基于 在其名称和可选 schema name 中MetaData对象。调用牌桌具有相同名称和相同MetaData参数的 constructor 第二次将返回相同的Tableobject - 以这种方式Table构造函数充当注册表函数。
另请参阅
使用元数据描述数据库 - 数据库元数据简介
成员
__init__（）， add_is_dependent_on（）， 别名（）， append_column（）， append_constraint（）， argument_for（）， autoincrement_column， c， 列， compare（）， 编译（）， 约束， corresponding_column（）， create（）， delete（）， 描述， dialect_kwargs， dialect_options， drop（）， entity_namespace， exported_columns， foreign_key_constraints， foreign_keys， get_children（）， implicit_returning， 索引， info， inherit_cache， insert（）， is_derived_from（）， join（）， key， kwargs， lateral（）， outerjoin（）， params（）， primary_key， replace_selectable（）， schema， select（）， self_group（）， table_valued（）， tablesample（）， to_metadata（）， tometadata（）， unique_params（）， update（）
类签名
类sqlalchemy.schema.Table（sqlalchemy.sql.base.DialectKWArgs，sqlalchemy.schema.HasSchemaAttr，sqlalchemy.sql.expression.TableClausesqlalchemy.inspection.Inspectable， ， ）-
方法sqlalchemy.schema.Table 中。__init__（name： str， metadata： MetaData， *args： SchemaItem， schema：strLiteral[SchemaConst.BLANK_SCHEMA]None=None， quote：boolNone=None， quote_schema：boolNone=None， autoload_with：EngineConnectionNone=None， autoload_replace： bool = True， keep_existing： bool = False， extend_existing： bool = False， resolve_fks： bool = True， include_columns：Collection[str]None=None，implicit_returning： bool = True， comment：strNone=None， info：Dict[Any，Any]None=None， listeners：_typing_Sequence[Tuple[str，Callable[...，Any]]]None=None， prefixes：_typing_Sequence[str]None=None， _extend_on：Set[Table]None=None， _no_init： bool = True， **kw： Any） 无¶ Table的构造函数。
参数
名称¶–
此表在数据库中表示的名称。
表名以及schema参数的值构成唯一标识此Table的键 在 拥有的MetaData集合。对具有相同名称、元数据和架构名称的Table的其他调用将返回相同的Table对象。
不包含大写字符的名称将被视为不区分大小写的名称，并且不会被引用，除非它们是保留字或包含特殊字符。包含任意数量的大写字符的名称被视为区分大小写，并将按引号发送。
要为表名启用无条件引用，请指定标志quote=True添加到构造函数中，或使用quoted_nameconstruct 指定名称。
元数据¶ –一个 MetaData对象，它将包含 this 桌子。 元数据用作此表的关联点 替换为通过外键引用的其他表。 它还 可用于将此表与特定的连接或引擎。
args¶– 额外的位置参数主要用于添加Column的列表 此 桌子。与 CREATE TABLE 语句的样式类似，其他SchemaItem结构，包括PrimaryKeyConstraint和ForeignKeyConstraint 的 Constraint对象。autoload_replace¶ –
默认为true;使用Table.autoload_with与Table.extend_existing结合使用，指示Column对象存在于已存在的桌子object 应该替换为具有相同 从 autoload 进程中检索到的名称。 当False时，反射过程中将省略现有名称下已存在的列。
请注意，此设置不会影响在对Table的调用中以编程方式指定的Column对象 那 也是自动加载;这些Column对象将始终 在以下情况下替换同名的现有列Table.extend_existing是真的。autoload_with¶ –
一个 Engine或Connection对象或Inspector对象（由检查（）针对一个，此表与 对象将被反射。 当设置为非 None 值时，将进行自动加载过程 对于此表，针对给定的引擎或连接。extend_existing¶ –
如果为 True，则表示如果此Table已经存在于给定的元数据/ 将构造函数中的更多参数应用于现有的表。
如果Table.extend_existing或Table.keep_existing未设置，并且新Table的给定名称引用Table那是 已存在于目标MetaData集合中，并且此Table指定其他列或其他构造 或修改表状态的标志，则 错误。 这两个互斥标志的用途 是指定在桌子指定与现有Table匹配，但指定其他构造。Table.extend_existing也将协同工作 替换为Table.autoload_with对数据库运行新的反射作，即使Table的目标中已存在元数据;新反射的列对象 和其他选项将添加到表，可能会覆盖现有列和同名选项。
与Table.autoload_with一样，列对象可以在同一桌子constructor 的 API API 的 下面，现有的 tablemytable将使用Column进行扩充 对象 两者都反映在数据库中，以及给定的列命名为 “y”：Table( "mytable", metadata, Column("y", Integer), extend_existing=True, autoload_with=engine, )
implicit_returning¶ –
默认为 True - 表示 ORM 通常可以使用 RETURNING，以便在支持 RETURNING 的后端上获取服务器生成的值，例如主键值和服务器端默认值。
在现代 SQLAlchemy 中，通常没有理由更改此设置，除了某些后端特定情况（有关此类示例，请参阅 SQL Server 方言文档中的触发器）。
include_columns¶ – 一个字符串列表，指示要通过autoload作加载的列子集;表列谁 不存在在此列表中，则不会在生成的Table对象。默认为None，表示应反映所有列。resolve_fks¶ –
是否反映表对象 通过ForeignKey对象与此相关，当Table.autoload_with默认为 True。设置为 False 以禁用相关表作为ForeignKey的反射 遇到物体;可能 用于保存 SQL 调用或避免相关表的问题 无法访问。请注意，如果 related table 已存在 在MetaData集合中，或者稍后出现， 一个ForeignKey对象Table将正常解析为该表。
在 1.3 版本加入.
info¶– 可选的数据字典，将被填充到SchemaItem.info对象的属性。keep_existing¶ –
如果为 True，则指示如果此 Table 已存在于给定的 MetaData中，则忽略 将更多参数添加到现有的Table的 API 中，并返回Tableobject 指定为 最初创建。这是为了允许一个希望 在第一次调用时定义一个新的Table，但在后续调用中将返回相同的Table，而不会第二次应用任何声明（特别是 constraints）。
如果Table.extend_existing或Table.keep_existing未设置，并且新Table的给定名称引用Table那是 已存在于目标MetaData集合中，并且此Table指定其他列或其他构造 或修改表状态的标志，则 错误。 这两个互斥标志的用途 是指定在桌子指定与现有Table匹配，但指定其他构造。
侦听器¶–
格式为（<eventname>， <fn>）的元组列表 它将在构造时传递给listen（）。listen（）的这个替代钩子允许在 “autoload” 过程开始之前建立特定于此Table的侦听器函数。但是，从历史上看，这一直旨在与DDLEvents.column_reflect（）事件一起使用 请注意，此事件钩子现在可能与MetaData对象：def listen_for_reflect(table, column_info): "handle the column reflection event" # ... t = Table( "sometable", autoload_with=engine, listeners=[("column_reflect", listen_for_reflect)], )
must_exist¶– 当True时，表示此 Table 必须已存在于给定的MetaData集合中，否则将引发异常。
prefixes¶– 在 CREATE TABLE 语句中，要在 CREATE 之后插入的字符串列表。它们将用空格分隔。
引用¶ –
强制引用此表的名称 on 或 off，对应于True或False。当保留为默认值None时，将根据名称是否区分大小写（至少具有一个大写字符的标识符被视为区分大小写）或是否为保留字来引用列标识符。此标志仅用于强制引用 SQLAlchemy 方言不知道的保留字。
注意
将此标志设置为False不会为 table 反射提供不区分大小写的行为;Table Reflection 将始终以区分大小写的方式搜索大小写混合的名称。在 SQLAlchemy 中，仅通过用全部小写字符声明名称来指定不区分大小写的名称。
quote_schema¶ – 与 'quote' 相同，但适用于 schema 标识符。
架构¶ –
此表的架构名称，如果该表驻留在引擎数据库连接的默认选定架构以外的架构中，则此名称是必需的。默认为None。
如果此Table的拥有MetaData指定其 own的 MetaData.schema参数，则该 schema 名称将应用于此Table如果此处的 schema 参数已设置 设置为None。在Table上设置空白架构名称 那 否则，将使用在拥有的MetaData中，指定特殊符号BLANK_SCHEMA。
Schema 名称的引用规则与name参数，因为引号适用于保留字或区分大小写的名称;要为架构名称启用无条件引用，请为构造函数指定标志quote_schema=True，或使用quoted_name构造指定名称。
评论¶ –
可选字符串，将在创建表时呈现 SQL 注释。
1.2 版本中的新功能： 添加了Table.comment参数 到Table。
**kw¶– 上面未提及的其他关键字参数是特定于方言的，并以<dialectname>_<argname>的形式传递。 有关单个方言的文档，请访问 Dialects 了解记录在案的论点的详细信息。
-
方法sqlalchemy.schema.Table 中。add_is_dependent_on（table： Table） 无¶
为此 Table 添加 'dependency'。
这是另一个 Table 对象，必须先创建该对象，然后才能创建该对象，或者在此对象之后删除该对象。
通常，表之间的依赖关系是通过 ForeignKey 对象确定的。但是，对于在外键之外创建依赖项的其他情况（rules、inheriting），此方法可以手动建立此类链接。
-
方法sqlalchemy.schema.Table 中。alias（name：strNone=None， flat： bool = False） NamedFromClause¶
继承自FromClause的FromClause.alias（）方法
返回此FromClause的别名。
例如：a2 = some_table.alias("a2")
上面的代码创建了一个别名可以使用 作为任何 SELECT 语句中的 FROM 子句。
-
方法sqlalchemy.schema.Table 中。append_column（column： ColumnClause[Any]， replace_existing： bool = False） 无¶ -
然后，新添加的Column的 “键” ，即其.key属性的值，将在此Table的.c集合中可用，并且列定义将包含在从此Table生成的任何 CREATE TABLE、SELECT、UPDATE 等语句中 构建。
请注意，这不会更改表的定义，因为它存在于任何基础数据库中，假设该表已在数据库中创建。关系数据库支持使用 SQL ALTER 命令向现有表添加列，对于不包含新添加列的现有表，需要发出该命令。
参数replace_existing¶ –
如果为 True，则允许替换现有列。如果False为默认值，则如果已存在具有相同.key的列，则会引发警告。sqlalchemy 的未来版本将改为出现警告。
1.4.0 新版功能.
-
方法sqlalchemy.schema.Table 中。append_constraint（constraint：IndexConstraint） 无¶
将Constraint附加到此表。
这具有约束包含在任何 future CREATE TABLE 语句（假设创建了特定的 DDL） 事件尚未与给定的Constraint对象。
请注意，这不会在 关系数据库，对于已存在的表 在数据库中。 要向 现有关系数据库表，则 SQL ALTER 命令必须 被使用。 SQLAlchemy 还提供了AddConstraint构造，该构造在作为可执行子句调用时可以生成此 SQL。
-
类方法sqlalchemy.schema.Table 中。argument_for（dialect_name， argument_name， 默认）¶ -
为此类添加一种新的特定于方言的关键字参数。
例如：Index.argument_for("mydialect", "length", None) some_index = Index("a", "b", mydialect_length=5)
DialectKWArgs.argument_for（）方法是按参数计算的 方式向DefaultDialect.construct_arguments字典。此字典代表方言提供各种架构级构造接受的参数名称列表。
新方言通常应将此字典一次性指定为 dialect 类的数据成员。临时添加参数名称的用例通常用于最终用户代码，这些代码也使用使用额外参数的自定义编译方案。
参数
dialect_name¶ – 方言的名称。方言必须是可定位的，否则会引发NoSuchModuleError。 这 dialect 还必须包含现有的DefaultDialect.construct_argumentscollection，表示它参与关键字参数验证和默认系统，否则会引发ArgumentError。如果 dialect 不包含此集合，则已经可以代表此 dialect 指定任何 keyword 参数。SQLAlchemy 中打包的所有方言都包含此集合，但对于第三方方言，支持可能会有所不同。
argument_name¶ – 参数的名称。
default¶ – 参数的默认值。
-
属性sqlalchemy.schema.Table 的 Schema 中。autoincrement_column¶
返回当前表示 “auto increment” 列的Column对象（如果有），否则返回 None。
这是基于Column定义的规则Column.autoincrement参数，这通常表示单个整数列主键约束中不受外键约束的列。如果表没有这样的主键约束，则没有 “autoincrement” 列。一个 Table只能有一列定义为 “autoincrement” 列。
2.0.4 新版功能.
另请参阅
-
属性sqlalchemy.schema.Table 的 Schema 中。c¶
继承自FromClause的FromClause.c属性FromClause.columns的同义词
结果
-
属性sqlalchemy.schema.Table 的 Schema 中。列¶
继承自FromClause的FromClause.columns属性ColumnElement的基于命名的集合 对象。列或c集合是使用表绑定列或其他可选绑定列构造 SQL 表达式的网关：select(mytable).where(mytable.c.somecolumn == 5)
结果
-
方法sqlalchemy.schema.Table 中。compare（other： ClauseElement， **kw： Any） bool¶
继承自ClauseElement的ClauseElement.compare（）方法
将此ClauseElement与给定的ClauseElement进行比较。
子类应覆盖默认行为，即直接的恒等比较。
**kw 是子类compare（）方法使用的参数，可用于修改比较条件（参见ColumnElement）。
-
方法sqlalchemy.schema.Table 中。compile（bind：_HasDialectNone=None， dialect：DialectNone=None， **kw： Any） 已编译¶
继承自CompilerElement的CompilerElement.compile（）方法
编译此 SQL 表达式。
返回值是一个Compiled对象。对返回值调用str（）或unicode（）将产生一个 string 表示形式。这Compiled对象还可以使用params访问器返回绑定参数名称和值的字典。
参数
bind¶– 一个Connection或Engine，可以提供Dialect以生成Compiled对象。如果bind和dialect参数都省略了，而是使用默认的 SQL 编译器。
column_keys¶ – 用于 INSERT 和 UPDATE 语句，编译语句的 VALUES 子句中应存在的列名列表。如果为None，则呈现目标表对象中的所有列。compile_kwargs¶ –
附加参数的可选字典，将在所有 “visit” 方法中传递给编译器。例如，这允许将任何自定义标志传递给自定义编译构造。它还用于传递literal_binds标志的情况：from sqlalchemy.sql import table, column, select t = table("t", column("x")) s = select(t).where(t.c.x == 5) print(s.compile(compile_kwargs={"literal_binds": True}))
-
属性sqlalchemy.schema.Table 的 Schema 中。constraints： Set[Constraint]¶
与此Table关联的所有Constraint对象的集合。
包括PrimaryKeyConstraint、ForeignKeyConstraint、UniqueConstraint、CheckConstraint 的 Constraint实例。 单独的集合Table.foreign_key_constraints引用所有ForeignKeyConstraint对象的集合，而Table.primary_key属性是指单个PrimaryKeyConstraint与表。
-
方法sqlalchemy.schema.Table 中。corresponding_column（column： KeyedColumnElement[Any]， require_embedded： bool = False）→KeyedColumnElement[Any]无¶ -
给定一个ColumnElement，返回导出的ColumnElement对象Selectable.exported_columnscollection 的 这与 原始ColumnElement通过公共上级列。
参数
column¶—— 目标ColumnElement进行匹配。
require_embedded¶ —— 如果给定的ColumnElementColumnElement （列元素）实际上存在于子元素中 的这个Selectable。通常，如果该列仅与此Selectable的导出列之一共享一个共同的祖先，则该列将匹配。
另请参阅Selectable.exported_columns- 的ColumnCollection系列 用于作。
-
方法sqlalchemy.schema.Table 中。create（bind： _CreateDropBind， checkfirst： bool = False） 无¶
为此发出CREATE语句Table中，使用给定的连接或引擎用于连接。
另请参阅
-
方法sqlalchemy.schema.Table 中。delete（） 删除¶
继承自TableClause的TableClause.delete（）方法
针对 this 生成delete（）构造TableClause的
例如：table.delete().where(table.c.id == 7)
有关参数和使用信息，请参阅delete（）。
-
属性sqlalchemy.schema.Table 的 Schema 中。dialect_kwargs¶ -
指定为此构造的特定于方言的选项的关键字参数的集合。
这些论点以原始的<dialect>_<kwarg>显示 格式。 仅包含实际传递的参数; 与DialectKWArgs.dialect_options集合不同，后者包含此方言已知的所有选项，包括 defaults。
该集合也是可写的;接受<dialect>_<kwarg>形式的键，其中值将组合到选项列表中。
另请参阅DialectKWArgs.dialect_options- 嵌套词典形式
-
属性sqlalchemy.schema.Table 的 Schema 中。dialect_options¶ -
指定为此构造的特定于方言的选项的关键字参数的集合。
这是一个两级嵌套注册表，键为<dialect_name>和<argument_name>。例如，postgresql_where参数将定位为：arg = my_object.dialect_options["postgresql"]["where"]
在 0.9.2 版本加入.
另请参阅DialectKWArgs.dialect_kwargs- 平面词典形式
-
方法sqlalchemy.schema.Table 中。drop（bind： _CreateDropBind， checkfirst： bool = False） 无¶
为此发出DROP语句Table中，使用给定的Connection或Engine用于连接。
另请参阅
-
属性sqlalchemy.schema.Table 的 Schema 中。entity_namespace¶ -
返回用于 SQL 表达式中基于名称的访问的命名空间。
这是用于解析 “filter_by（）” 类型表达式的命名空间，例如：stmt.filter_by(address="some address")
它默认为.c集合，但在内部可以使用 “entity_namespace” 注释覆盖它以提供替代结果。
-
属性sqlalchemy.schema.Table 的 Schema 中。exported_columns¶ -
一个ColumnCollection表示 “exported”列。FromClause的 “exported” 列 object 是同义词 替换为FromClause.columns集合。
在 1.4 版本加入.
-
属性sqlalchemy.schema.Table 的 Schema 中。foreign_key_constraints¶ -
此列表由外键当前关联的对象。
-
属性sqlalchemy.schema.Table 的 Schema 中。foreign_keys¶ -
返回此 FromClause 引用的ForeignKey标记对象的集合。
每个ForeignKey都是表范围ForeignKeyConstraint 的 Constraint对象。
-
方法sqlalchemy.schema.Table 中。get_children（*， omit_attrs： 元组[str， ...] = （）， **kw： Any） Iterable[HasTraverseInternals]¶
继承自HasTraverseInternals.get_children()HasTraverseInternals的方法
返回紧接的子HasTraverseInternals元素中。
这用于访问遍历。
kw 可能包含更改返回的集合的标志，例如，返回项的子集以减少较大的遍历，或从不同的上下文返回子项（例如架构级集合而不是子句级集合）。
-
属性sqlalchemy.schema.Table 的 Schema 中。implicit_returning = False¶ -
TableClause不支持使用主键或列 -level 默认值，因此隐式返回不适用。
-
属性sqlalchemy.schema.Table 的 Schema 中。indexes： Set[Index]¶
-
属性sqlalchemy.schema.Table 的 Schema 中。信息¶
继承自SchemaItem的SchemaItem.info属性
与对象关联的 Info 字典，允许用户定义的数据与此SchemaItem相关联。
-
属性sqlalchemy.schema.Table 的 Schema 中。inherit_cache：boolNone = 无¶
继承自HasCacheKey的HasCacheKey.inherit_cache属性
指示此HasCacheKey实例是否应使用其直接超类使用的缓存键生成方案。
该属性默认为None，这表示构造尚未考虑是否适合参与缓存;这在功能上等效于将值设置为False，但还会发出警告。
如果与对象对应的 SQL 不基于此类的本地属性而不是其超类而更改，则可以在特定类上将此标志设置为True。
另请参阅
启用对自定义构造的缓存支持 - 设置HasCacheKey.inherit_cache第三方或用户定义的 SQL 构造的属性。
-
方法sqlalchemy.schema.Table 中。insert（） 插入¶
继承自TableClause的TableClause.insert（）方法
针对此生成Insert构造TableClause的
例如：table.insert().values(name="foo")
有关参数和使用信息，请参阅insert（）。
-
方法sqlalchemy.schema.Table 中。is_derived_from（fromclause：FromClauseNone） bool¶ -
如果此FromClause是从给定的FromClause“派生”的，则返回True。
例如，Table 的别名是从该 Table 派生的。
-
方法sqlalchemy.schema.Table 中。join（right： _FromClauseArgument， onclause：_ColumnExpressionArgument[bool]None=无， isouter： bool = False， full： bool = false）加入¶
继承自FromClause的FromClause.join（）方法
从此返回JoinFrom子句转换为另一个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 映射的类。
on子句¶– 表示联接的 ON 子句的 SQL 表达式。如果保留为None，则FromClause.join（）将尝试 根据外键关系联接两个表。
isouter¶——如果为 True，则渲染 LEFT OUTER JOIN，而不是 JOIN。
full¶ – 如果为 True，则渲染 FULL OUTER JOIN，而不是 LEFT OUTER JOIN。隐含FromClause.join.isouter。
-
属性sqlalchemy.schema.Table 的 Schema 中。键¶
返回此表的 'key'。
此值用作MetaData.tables集合。它通常与Table.name相同，对于没有Table.schema设置;否则，它通常采用以下形式schemaname.tablename的
-
属性sqlalchemy.schema.Table 的 Schema 中。kwargs¶
-
方法sqlalchemy.schema.Table 中。lateral（name：strNone=None） LateralFrom子句¶
继承自Selectable的Selectable.lateral（）方法
返回此Selectable的 LATERAL 别名。
返回值是Lateral结构，也由顶级lateral（）函数提供。
另请参阅
LATERAL correlation - 用法概述。
-
方法sqlalchemy.schema.Table 中。outerjoin（right： _FromClauseArgument， onclause：_ColumnExpressionArgument[bool]None=None， full： bool = False） 加入¶
继承自FromClause的FromClause.outerjoin（）方法
从此返回JoinFrom子句添加到另一个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 映射的类。
on子句¶– 表示联接的 ON 子句的 SQL 表达式。如果保留为None，则FromClause.join（）将尝试 根据外键关系联接两个表。
full¶ – 如果为 True，则渲染 FULL OUTER JOIN，而不是 LEFT OUTER JOIN。
-
方法sqlalchemy.schema.Table 中。params（*optionaldict， **kwargs）¶
继承自Immutable的Immutable.params（）方法
返回替换了bindparam（）元素的副本。
返回此 ClauseElement 的副本，其中包含bindparam（）元素替换为从给定字典中获取的值：>>> clause = column("x") + bindparam("foo") >>> print(clause.compile().params) {'foo':None} >>> print(clause.params({"foo": 7}).compile().params) {'foo':7}
-
属性sqlalchemy.schema.Table 的 Schema 中。primary_key¶
继承自FromClause的FromClause.primary_key属性
返回构成此_selectable的主键的Column对象的可迭代集合。From子句。
对于Table对象，此集合由PrimaryKeyConstraint表示，它本身是Column对象的可迭代集合。
-
方法sqlalchemy.schema.Table 中。replace_selectable（旧： FromClause， 别名： Alias） 自身¶ -
替换FromClause的所有匹配项 'old' 替换为给定的别名object，返回此FromClause的副本。
1.4 版后已移除： 该方法Selectable.replace_selectable()已弃用，并将在未来发行版中删除。可通过 sqlalchemy.sql.visitors 模块使用类似的功能。
-
属性sqlalchemy.schema.Table 的 Schema 中。schema：strNone = 无¶
继承自FromClause的FromClause.schema属性
定义此FromClause的 'schema' 属性。
对于大多数对象，这通常为None，但Table中，它被视为Table.schema参数。
-
方法sqlalchemy.schema.Table 中。select（） Select¶
继承自FromClause的FromClause.select（）方法
返回此FromClause的 SELECT。
例如：stmt = some_table.select().where(some_table.c.id == 5)
另请参阅select（）- 允许任意列列表的通用方法。
-
方法sqlalchemy.schema.Table 中。self_group（against：OperatorTypeNone=None） ClauseElement¶ -
将 'grouping' 应用于此ClauseElement。
此方法被 subclasses 覆盖以返回 “grouping” 结构，即括号。特别是，当它被 “binary” 表达式用于在放入更大的表达式时提供围绕自身的分组，以及select（）构造select（）的（请注意，子查询通常应使用Select.alias（）方法创建，因为许多平台需要命名嵌套的 SELECT 语句）。
由于表达式是组合在一起的，因此self_group（）是自动的 - 最终用户代码永远不需要直接使用此方法。请注意，SQLAlchemy 的子句构造考虑了运算符优先级 - 因此可能不需要括号，例如，在像x OR （y AND z）这样的表达式中 - AND 优先于 OR。
的base self_group（）方法子句元素只返回 self。
-
方法sqlalchemy.schema.Table 中。table_valued（） TableValuedColumn[Any]¶
继承自NamedFromClause.table_valued()NamedFromClause的方法
为此返回一个TableValuedColumn对象From子句。TableValuedColumn是表示表中完整行的ColumnElement。对此结构的支持取决于后端，并且 PostgreSQL、Oracle Database 和 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 版本的新Function。
另请参阅
-
方法sqlalchemy.schema.Table 中。tablesample（sampling：floatFunction[Any]， name：strNone=None， seed：roles.ExpressionElementRole[Any]None=None） TableSample（表样本）¶ -
返回此FromClause 的 TABLESAMPLE别名。
返回值为TableSample还构建 由顶级tablesample（）函数提供。
另请参阅tablesample（）- 使用指南和参数
-
方法sqlalchemy.schema.Table 中。to_metadata（metadata： MetaData， schema：strLiteral[SchemaConst.RETAIN_SCHEMA]=SchemaConst.RETAIN_SCHEMA， referred_schema_fn：Callable[[Table，strNone，ForeignKeyConstraint，strNone]，strNone]None=None，name：strNone=None） 表¶
返回与其他MetaData关联的此Table的副本。
例如：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（）重命名。
参数
架构¶ –
指示目标架构的可选字符串名称。默认为特殊符号RETAIN_SCHEMA，表示 不应在新的表。 如果设置为字符串名称，则新的桌子将这个新名称作为.schema。如果设置为None，则 schema 将设置为目标上设置的 schema 的MetaData的 Metadata，通常也是None，除非显式设置：m2 = MetaData(schema="newschema") # user_copy_one will have "newschema" as the schema name user_copy_one = user.to_metadata(m2, schema=None) m3 = MetaData() # schema defaults to None # user_copy_two will have None as the schema name user_copy_two = user.to_metadata(m3, schema=None)
referred_schema_fn¶ –
可选的可调用对象，可以提供该 schema 名称，该 schema name 应该分配给ForeignKeyConstraint的引用表。可调用对象接受这个父Table， 目标架构，则ForeignKeyConstraint对象，以及该约束的现有 “target schema” 来执行。该函数应返回应应用的字符串架构名称。要将架构重置为“none”，请返回符号BLANK_SCHEMA。要不进行任何更改，请返回None或RETAIN_SCHEMA。
在 1.4.33 版本发生变更：referred_schema_fn函数可能会返回BLANK_SCHEMA或RETAIN_SCHEMA符号。
例如：def referred_schema_fn(table, to_schema, constraint, referred_schema): if referred_schema == "base_tables": return referred_schema else: return to_schema new_table = table.to_metadata( m2, schema="alt_schema", referred_schema_fn=referred_schema_fn )
name¶ – 可选的字符串名称，表示目标表名。如果未指定或 None，则保留表名。这允许将Table复制到相同的MetaData目标替换为新名称。
-
方法sqlalchemy.schema.Table 中。tometadata（metadata： MetaData， schema：strLiteral[SchemaConst.RETAIN_SCHEMA]=SchemaConst.RETAIN_SCHEMA， referred_schema_fn：Callable[[Table，strNone，ForeignKeyConstraint，strNone]，strNone=None=None） 表¶ -
1.4 版后已移除：Table.tometadata（）已重命名为Table.to_metadata（）
有关完整描述，请参阅Table.to_metadata（）。
-
方法sqlalchemy.schema.Table 中。unique_params（*optionaldict， **kwargs）¶
继承自Immutable的Immutable.unique_params（）方法
返回替换了bindparam（）元素的副本。
与ClauseElement.params（）功能相同，但添加了 unique=True 添加到受影响的绑定参数中，以便多个语句可以 使用。
-
方法sqlalchemy.schema.Table 中。update（） 更新¶
继承自TableClause的TableClause.update（）方法
针对此生成update（）构造TableClause的
例如：table.update().where(table.c.id == 7).values(name="foo")
有关参数和使用信息，请参见update（）。
-