Oracle cursor 元数据,用元数据描述数据库 - SQLAlchemy 中文文档

本节讨论了

这个

一旦你定义了一些

虽然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中，这只不过是一个与

这个

使用的名称

以上方法都是指在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 = dbapi_connection.cursor()

cursor.execute("ALTER SESSION SET CURRENT_SCHEMA=%s" % schema_name)

cursor.close()

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

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

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

参见

后端特定选项

Object Name

Description

表示数据库表中的列。

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

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

表示数据库中的表。

classsqlalchemy.schema.Column(*args, **kwargs)¶

表示数据库表中的列。

类签名

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

实施 == 操作员。

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

methodsqlalchemy.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 在表上构造。要使用显式名称或包含多列的索引指定索引，请使用 Index 改为构造。

info¶ — 可选数据字典，将填充到 SchemaItem.info 此对象的属性。

nullable¶ — 当设置为 False ，将导致在为列生成DDL时添加“not null”短语。什么时候？ True ，通常不会生成任何内容(在SQL中，默认值为“空”)，除非在某些特定于后端的边缘情况下，“空”可能显式呈现。默认为 True 除非 Column.primary_key 也是 True ，在这种情况下，它默认为 False . 此参数仅在发出create table语句时使用。

onupdate¶ — 标量、python可调用或 ClauseElement 表示要应用于update语句中的列的默认值，如果该列不在update的set子句中，则在更新时调用该值。这是使用的快捷方式 ColumnDefault 作为位置参数 for_update=True . …参阅： 列插入/更新默认值 -关于更新的完整讨论

primary_key¶ — 如果 True ，将此列标记为主键列。多列可以设置此标志以指定复合主键。另一种选择是 Table 可以通过显式 PrimaryKeyConstraint 对象。

server_default¶ — A FetchedValue 实例、str、unicode或 text() 构造，表示列的DDL默认值。字符串类型将按原样发出，由单引号包围：：column(’x’，text，server_default=“val”)x text default“val”a text() 表达式将按原样呈现，不带引号：：列(“y”，日期时间，服务器默认值=文本(“now()”))y日期时间默认值now()字符串和文本()将转换为 DefaultClause 初始化时的对象。使用 FetchedValue 指示已存在的列将在数据库端生成一个默认值，以便SQLAlchemy在插入后提取该值。此构造不指定任何DDL，实现将留给数据库，例如通过触发器。…参阅： 服务器调用了DDL显式默认表达式 -完成服务器端默认值的讨论

server_onupdate¶ — A FetchedValue 实例，该实例表示数据库端的默认生成函数，如触发器。这向SQLAlchemy指示新生成的值将在更新后可用。这个构造实际上并没有在数据库中实现任何类型的生成函数，而是必须单独指定。。警告：：此指令 不 当前生成MySQL的“ON UPDATE CURRENT_TIMESTAMP()”子句。看到了吗 MySQL/MariaDB在更新当前时间戳时呈现的显式“默认值”为“时间戳” 关于如何产生这个条款的背景。。另请参见： 标记隐式生成的值、时间戳和触发的列

quote¶ — 打开或关闭此列名称的强制引用，对应于 True 或 False . 当其违约时 None ，列标识符将根据名称是否区分大小写(具有至少一个大写字符的标识符被视为区分大小写)或是否为保留字来引用。此标志只需要强制引用一个不被SQLAlchemy方言识别的保留字。

unique¶ — 什么时候？ True ，指示此列包含唯一约束，或者如果 index 是 True 同时，表明 Index 应使用唯一标志创建。要在约束/索引中指定多列或指定显式名称，请使用 UniqueConstraint 或 Index 显式构造。

system¶ — 什么时候？ True ，表示这是一个“系统”列，该列由数据库自动提供，不应包含在 CREATE TABLE 语句。对于应该在不同后端有条件地呈现不同列的更详细的场景，请考虑自定义编译规则 CreateColumn .

comment¶ — 用于在创建表时呈现SQL注释的可选字符串。…版本添加：：1.2添加了 Column.comment 参数到 Column .

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

实施 <= 操作员。

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

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

实施 < 操作员。

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

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

实施 != 操作员。

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

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

此运算符仅适用于标量子查询对象，或某些后端的列表达式适用于数组类型，例如：：

# postgresql '5 = ALL (somearray)'

expr = 5 == mytable.c.somearray.all_()

# mysql '5 = ALL (SELECT value FROM table)'

expr = 5 == select(table.c.value).scalar_subquery().all_()

参见

any_() -任何操作符

1.1 新版功能.

为此ColumnElement提供常量“匿名标签”。

这是一个label()表达式，将在编译时命名。每次都返回相同的label() anon_label 调用以便表达式可以引用 anon_label 多次，在编译时生成相同的标签名。

编译器在编译时自动将此函数用于已知为“未命名”的表达式，如二进制表达式和函数调用。

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

此运算符仅适用于标量子查询对象，或某些后端的列表达式适用于数组类型，例如：：

# postgresql '5 = ANY (somearray)'

expr = 5 == mytable.c.somearray.any_()

# mysql '5 = ANY (SELECT value FROM table)'

expr = 5 == select(table.c.value).scalar_subquery().any_()

参见

all_() -所有操作符

1.1 新版功能.

methodsqlalchemy.schema.Column.classmethodargument_for(dialect_name, argument_name, default)¶

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

例如。：：

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

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

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

参数

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

argument_name¶ — 参数的名称。

default¶ — 参数的默认值。

0.9.4 新版功能.

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

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

生成类型转换，即 CAST( AS ) .

这是到 cast() 功能。

参见

1.0.7 新版功能.

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

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

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

编译此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 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}))

0.9.0 新版功能.

参见

实现“concat”运算符。

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

methodsqlalchemy.schema.Column.contains(other, **kwargs)¶

实现“contains”运算符。

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

column LIKE '%' || || '%'

例如。：：

stmt = select(sometable).\

where(sometable.c.column.contains("foobar"))

因为操作员使用 LIKE ，通配符 "%" 和 "_" 存在于表达式中的也将表现为通配符。对于文本字符串值， 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" 在被传递到数据库之前。

参见

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

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

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

0.9.2 新版功能.

参见

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

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

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

0.9.2 新版功能.

参见

methodsqlalchemy.schema.Column.endswith(other, **kwargs)¶

实现“endswith”运算符。

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

column LIKE '%' ||

例如。：：

stmt = select(sometable).\

where(sometable.c.column.endswith("foobar"))

因为操作员使用 LIKE ，通配符 "%" 和 "_" 存在于表达式中的也将表现为通配符。对于文本字符串值， 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" 在被传递到数据库之前。

参见

返回列表达式。

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

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

用于访问遍历。

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

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

实施 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=“/”)

参见

实施 in 操作员。

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

给定参数 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子查询的执行时间。

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)

)

)

WHERE COL IN (SELECT othertable.y

FROM othertable WHERE othertable.x = table.x)

inherited from the SchemaItem.info attribute of SchemaItem

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

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

实施 IS 操作员。

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

参见

methodsqlalchemy.schema.Column.is_distinct_from(other)¶

实施 IS DISTINCT FROM 操作员。

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

1.1 新版功能.

实施 IS NOT 操作员。

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

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

参见

methodsqlalchemy.schema.Column.is_not_distinct_from(other)¶

实施 IS NOT DISTINCT FROM 操作员。

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

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

1.1 新版功能.

实施 IS NOT 操作员。

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

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

参见

methodsqlalchemy.schema.Column.isnot_distinct_from(other)¶

实施 IS NOT DISTINCT FROM 操作员。

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

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

1.1 新版功能.

生成列标签，即 AS .

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

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

实施 like 操作员。

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

a LIKE other

例如。：：

stmt = select(sometable).\

where(sometable.c.column.like("%foobar%"))

参数

other¶ — 要比较的表达式

escape¶ — 可选转义符，呈现 ESCAPE 关键字，例如：somecolumn.like(“foo/%bar”，escape=“/”)

参见

methodsqlalchemy.schema.Column.match(other, **kwargs)¶

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

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

PostgreSQL-呈现 x @@ to_tsquery(y)

MySQL -渲染器 MATCH (x) AGAINST (y IN BOOLEAN MODE)

Oracle-呈现 CONTAINS(x, y)

其他后端可能提供特殊的实现。

没有任何特殊实现的后端将发出“match”操作符。例如，这与sqlite兼容。

classmemoized_attribute(fget, doc=None)¶

只读@属性，只计算一次。

methodsqlalchemy.schema.Column.classmethodmemoized_instancemethod(fn)¶

inherited from the HasMemoized.memoized_instancemethod() method of HasMemoized

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

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

实施 NOT ILIKE 操作员。

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

参见

实施 NOT IN 操作员。

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

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

参见

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

实施 NOT LIKE 操作员。

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

参见

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

实施 NOT ILIKE 操作员。

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

参见

实施 NOT IN 操作员。

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

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

参见

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

实施 NOT LIKE 操作员。

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

参见

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

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

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

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

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

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

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

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

methodsqlalchemy.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 ，而那些不属于左侧操作数的类型。

参见

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

对参数进行运算。

这是最低级别的操作，提升 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() .

如果此列通过外键引用给定列，则返回true。

methodsqlalchemy.schema.Column.regexp_match(pattern, flags=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 占位符运算符和对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 新版功能.

参见

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

实现特定于数据库的“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 新版功能.

参见

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

methodsqlalchemy.schema.Column.self_group(against=None)¶

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

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

methodsqlalchemy.schema.Column.startswith(other, **kwargs)¶

实施 startswith 操作员。

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

column LIKE || '%'

例如。：：

stmt = select(sometable).\

where(sometable.c.column.startswith("foobar"))

因为操作员使用 LIKE ，通配符 "%" 和 "_" 存在于表达式中的也将表现为通配符。对于文本字符串值， 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" 在被传递到数据库之前。

参见

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

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

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

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

参见

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

类签名

methodsqlalchemy.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中删除。

reflect¶ — 可选，自动从绑定数据库加载所有表。默认为false。 MetaData.bind 设置此选项时需要。

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 ，以及为给定约束引用的所有列生成名称、键或标签串联的相关标记。…参阅： 配置约束命名约定 -有关详细的用法示例。

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

engine = create_engine("someurl://")

metadata.bind = engine

参见

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

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

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

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

参数

bind¶ — A Connectable 用于访问数据库；如果没有，则对此使用现有绑定 MetaData ，如果有的话。。注意：SQLAlchemy 2.0中需要“bind”参数。

tables¶ — 可选列表 Table 对象，它是 MetaData (其他被忽略)。

checkfirst¶ — 默认为true，不为目标数据库中已存在的表发出creates。

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

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

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

参数

bind¶ — A Connectable 用于访问数据库；如果没有，则对此使用现有绑定 MetaData ，如果有的话。。注意：SQLAlchemy 2.0中需要“bind”参数。

tables¶ — 可选列表 Table 对象，它是 MetaData (其他被忽略)。

checkfirst¶ — 默认值为true，仅对确认存在于目标数据库中的表发出drops。

如果此元数据绑定到引擎或连接，则为true。

methodsqlalchemy.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¶ — 上面未提到的其他关键字参数是特定于方言的，并以形式传递 _ . 有关单个方言的文档，请参见 方言 有关文档化参数的详细信息。…版本已添加：：0.9.2-已添加 MetaData.reflect.**dialect_kwargs 为所有用户支持方言级反射选项 Table 反射的对象。

从此元数据中删除给定的表对象。

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

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

警告

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

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

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

参见

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

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

参见

classsqlalchemy.schema.SchemaItem¶

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

类签名

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

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

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

参见

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.autoload ， Column 对象可以在同一个 Table 构造函数，优先。下面，现有表格 mytable 将增加 Column 对象既从数据库反映，也从给定的 Column 命名为“Y”：

Table("mytable", metadata,

Column('y', Integer),

extend_existing=True,

autoload_with=engine

)

参见

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¶ — 窗体的元组列表 (, ) 将传递给 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方言识别的保留字。

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¶ — 上面未提到的其他关键字参数是特定于方言的，并以形式传递 _ . 有关单个方言的文档，请参见 方言 有关文档化参数的详细信息。

类签名

methodsqlalchemy.schema.Table.__init__(*args, **kw)¶

构造函数 Table .

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

methodsqlalchemy.schema.Table.add_is_dependent_on(table)¶

为此表添加“依赖项”。

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

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

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

例如。：：

a2 = some_table.alias('a2')

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

参见

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

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

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

参数

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

methodsqlalchemy.schema.Table.append_constraint(constraint)¶

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

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

methodsqlalchemy.schema.Table.classmethodargument_for(dialect_name, argument_name, default)¶

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

例如。：：

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

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

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

参数

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

argument_name¶ — 参数的名称。

default¶ — 参数的默认值。

0.9.4 新版功能.

返回与此表关联的可连接项。

inherited from the FromClause.columns attribute of FromClause

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

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

methodsqlalchemy.schema.Table.compare(other, **kw)¶

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

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

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

编译此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 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}))

0.9.0 新版功能.

参见

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

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

注解

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

参见

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

例如。：：

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

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

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

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

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

0.9.2 新版功能.

参见

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

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

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

0.9.2 新版功能.

参见

methodsqlalchemy.schema.Table.drop(bind=None, checkfirst=False)¶

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

注解

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

参见

attributesqlalchemy.schema.Table.entity_namespace¶

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

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

stmt.filter_by(address='some address')

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

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

attributesqlalchemy.schema.Table.foreign_key_constraints¶

返回的集合 ForeignKey 此FromClause引用的对象。

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

用于访问遍历。

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

inherited from the SchemaItem.info attribute of SchemaItem

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

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

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

例如。：：

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

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

methodsqlalchemy.schema.Table.is_derived_from(fromclause)¶

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

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

methodsqlalchemy.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 -生成的对象类型

返回此的“密钥” Table .

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

1.1 新版功能.

参见

横向相关 -使用概述。

classmemoized_attribute(fget, doc=None)¶

只读@属性，只计算一次。

methodsqlalchemy.schema.Table.classmethodmemoized_instancemethod(fn)¶

inherited from the HasMemoized.memoized_instancemethod() method of HasMemoized

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

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

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

参见

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

methodsqlalchemy.schema.Table.replace_selectable(old, alias)¶

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

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

例如。：：

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

参数

whereclause¶ — 调用子句，相当于调用 Select.where() 方法。。已弃用：：1.4 FromClause.select().whereclause 参数已弃用，将在版本2.0中删除。请利用 Select.where() 方法将WHERE条件添加到SELECT语句。

参见

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

methodsqlalchemy.schema.Table.self_group(against=None)¶

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

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

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

methodsqlalchemy.schema.Table.to_metadata(metadata, schema=symbol(‘retain_schema’), referred_schema_fn=None, name=None)¶

例如。：：

m1 = MetaData()

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

m2 = MetaData()

user_copy = user.to_metadata(m2)

参数

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

methodsqlalchemy.schema.Table.tometadata(metadata, schema=symbol(‘retain_schema’), referred_schema_fn=None, name=None)¶

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

例如。：：

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

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

classsqlalchemy.schema.ThreadLocalMetaData¶

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

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

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

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

类签名

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

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