本节讨论了 Table
, Column
和 MetaData
对象。
元数据实体的集合存储在适当命名的对象中。 MetaData
::
from sqlalchemy import *
metadata = MetaData()
MetaData
是一个容器对象,它将描述的数据库(或多个数据库)的许多不同功能放在一起。
要表示表,请使用 Table
班级。它的两个主要参数是表名,然后是 MetaData
它将与之关联的对象。其余的位置参数主要是 Column
描述每列的对象:
user = Table('user', metadata,
Column('user_id', Integer, primary_key=True),
Column('user_name', String(16), nullable=False),
Column('email_address', String(60)),
Column('nickname', String(50), nullable=False)
)
上面是一张叫做 user
描述,其中包含四列。表的主键由 user_id
列。可以为多个列分配 primary_key=True
表示多列主键的标志,称为 混合成的 主键。
还要注意,每一列都使用与泛型类型相对应的对象来描述其数据类型,例如 Integer
和 String
. SQLAlchemy具有数十种不同类型的特殊性以及创建自定义类型的能力。有关类型系统的文档,请访问 列和数据类型 .
这个 MetaData
对象包含我们与之关联的所有架构构造。它支持一些访问这些表对象的方法,例如 sorted_tables
访问器,返回每个访问器的列表 Table
按外键依赖项的顺序排列的对象(即,每个表前面都有它引用的所有表)::
>>> for t in metadata.sorted_tables:
... print(t.name)
user
user_preference
invoice
invoice_item
在大多数情况下,个人 Table
对象已显式声明,这些对象通常作为应用程序中的模块级变量直接访问。曾经一次 Table
它有一整套访问器,允许检查其属性。给出以下内容 Table
定义:
employees = Table('employees', metadata,
Column('employee_id', Integer, primary_key=True),
Column('employee_name', String(60), nullable=False),
Column('employee_dept', Integer, ForeignKey("departments.department_id"))
)
注意 ForeignKey
此表中使用的对象-此构造定义对远程表的引用,并在 定义外键 . 访问此表信息的方法包括:
# access the column "EMPLOYEE_ID":
employees.columns.employee_id
# or just
employees.c.employee_id
# via string
employees.c['employee_id']
# iterate through all columns
for c in employees.c:
print(c)
# get the table's primary key columns
for primary_key in employees.primary_key:
print(primary_key)
# get the table's foreign key objects:
for fkey in employees.foreign_keys:
print(fkey)
# access the table's MetaData:
employees.metadata
# access the table's bound Engine or Connection, if its MetaData is bound:
employees.bind
# access a column's name, type, nullable, primary key, foreign key
employees.c.employee_id.name
employees.c.employee_id.type
employees.c.employee_id.nullable
employees.c.employee_id.primary_key
employees.c.employee_dept.foreign_keys
# get the "key" of a column, which defaults to its name, but can
# be any user-defined string:
employees.c.employee_name.key
# access a column's table:
employees.c.employee_id.table is employees
# get the table related by a foreign key
list(employees.c.employee_dept.foreign_keys)[0].column.table
一旦你定义了一些 Table
对象,假设您正在使用一个全新的数据库,您可能要做的一件事是为这些表及其相关构造发出create语句(顺便说一句,也很可能是 不要 要做到这一点,如果您已经有了一些首选的方法,例如数据库或现有脚本系统中包含的工具(如果是这样的话,请随意跳过这一部分)-SQLAlchemy不要求使用它来创建表)。
发布create的通常方法是使用 create_all()
上 MetaData
对象。此方法将发出查询,首先检查每个单独表的存在性,如果未找到,将发出create语句:
engine = create_engine('sqlite:///:memory:') metadata = MetaData() user = Table('user', metadata, 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, Column('pref_id', Integer, primary_key=True), Column('user_id', Integer, ForeignKey("user.user_id"), nullable=False), Column('pref_name', String(40), nullable=False), Column('pref_value', String(100)) ) sqlmetadata.create_all(engine)PRAGMA table_info(user){} CREATE TABLE user( user_id INTEGER NOT NULL PRIMARY KEY, user_name VARCHAR(16) NOT NULL, email_address VARCHAR(60), nickname VARCHAR(50) NOT NULL ) PRAGMA table_info(user_prefs){} CREATE TABLE user_prefs( pref_id INTEGER NOT NULL PRIMARY KEY, user_id INTEGER NOT NULL REFERENCES user(user_id), pref_name VARCHAR(40) NOT NULL, pref_value VARCHAR(100) )
create_all()
在通常与表定义本身内联的表之间创建外键约束,因此,它还按照表的依赖关系的顺序生成表。可以选择更改此行为,以便 ALTER TABLE
而是使用。
使用 drop_all()
方法。这个方法与 create_all()
-首先检查每个表的存在情况,然后按依赖关系的相反顺序删除表。
创建和删除单个表可以通过 create()
和 drop()
方法 Table
. 默认情况下,无论表是否存在,这些方法都会发出create或drop:
engine = create_engine('sqlite:///:memory:')
meta = MetaData()
employees = Table('employees', meta,
Column('employee_id', Integer, primary_key=True),
Column('employee_name', String(60), nullable=False, key='name'),
Column('employee_dept', Integer, ForeignKey("departments.department_id"))
)
sqlemployees.create(engine)
CREATE TABLE employees(
employee_id SERIAL NOT NULL PRIMARY KEY,
employee_name VARCHAR(60) NOT NULL,
employee_dept INTEGER REFERENCES departments(department_id)
)
{}
drop()
方法:
sqlemployees.drop(engine)
DROP TABLE employees
{}
要启用“先检查现有表”逻辑,请添加 checkfirst=True
参数 create()
或 drop()
::
employees.create(engine, checkfirst=True)
employees.drop(engine, checkfirst=False)
虽然sqlAlchemy直接支持为模式构造发出create和drop语句,但是通常通过alter语句以及其他特定于数据库的构造来更改这些构造的能力超出了sqlAlchemy本身的范围。虽然很容易发出alter语句和手工类似的语句,例如通过将字符串传递给 Connection.execute()
或通过使用 DDL
构造,使用模式迁移工具自动维护与应用程序代码相关的数据库模式是一种常见的实践。
有两种主要的迁移工具可用于SQLAlchemy:
Alembic -Alembic由SQLAlchemy的作者编写,它具有高度可定制的环境和最低使用模式,支持事务性DDL、自动生成“候选”迁移、“脱机”模式(生成SQL脚本)以及支持分支解析。
SQLAlchemy-Migrate -最初用于sqlachemy的迁移工具sqlachemy migrate仍由OpenStack等项目使用,但正被alembic取代。
一些数据库支持多个模式的概念。一 Table
可以通过指定 schema
关键字参数:
financial_info = Table('financial_info', meta,
Column('id', Integer, primary_key=True),
Column('value', String(100), nullable=False),
schema='remote_banks'
)
内 MetaData
集合,此表将由 financial_info
和 remote_banks
. 如果另一个表调用 financial_info
引用时没有 remote_banks
模式,它将引用另一个 Table
. ForeignKey
对象可以使用表单指定对此表中列的引用 remote_banks.financial_info.id
.
这个 schema
参数应用于所需的任何名称限定符,包括Oracle的“owner”属性和类似属性。它还可以为较长的方案提供虚线名称:
schema="dbo.scott"
Table
支持特定于数据库的选项。例如,mysql有不同的表后端类型,包括“myisam”和“innodb”。这可以用 Table
使用 mysql_engine
::
addresses = Table('engine_email_addresses', meta,
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'
)
其他后端也可能支持表级选项——这些将在每个方言的单独文档部分中描述。
sqlalchemy.schema.
BLANK_SCHEMA
¶表示a的符号 Table
或 Sequence
其架构应为“none”,即使父级 MetaData
已指定架构。
1.0.14 新版功能.
sqlalchemy.schema.
Column
(*args, **kwargs)¶基地: sqlalchemy.sql.base.DialectKWArgs
, sqlalchemy.schema.SchemaItem
, sqlalchemy.sql.expression.ColumnClause
表示数据库表中的列。
__eq__
(other)¶继承 __eq__()
方法 ColumnOperators
实施 ==
操作符。
在列上下文中,生成子句 a = b
. 如果目标是 None
生产 a IS NULL
.
__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
. 在某些情况下,可以使用等效的关键字参数,例如 server_default
, default
和 unique
.
autoincrement¶ -- 为整数主键列设置“自动递增”语义。默认值是字符串 "auto"
这表示一个整型的、没有指定客户端或Python端默认值的单列主键应该自动接收自动递增语义;所有其他类型的主键列都不会。这包括那个 DDL 例如,在创建表的过程中,会为该列发出postgresql-serial或mysql-auto-increment,并且假定该列在调用insert语句时生成新的整数主键值,该语句将由方言检索。标志可以设置为 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
除非 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指示更新后新生成的值将可用。此构造实际上不实现数据库中的任何类型的生成函数,而必须单独指定。…参阅: 标记隐式生成的值、时间戳和触发的列
quote¶ -- 打开或关闭此列名称的强制引用,对应于 True
或 False
. 当其违约时 None
,列标识符将根据名称是否区分大小写(具有至少一个大写字符的标识符被视为区分大小写)或是否为保留字来引用。此标志只需要强制引用一个不被SQLAlchemy方言识别的保留字。
unique¶ -- 什么时候? True
,指示此列包含唯一约束,或者如果 index
是 True
同时,表明 Index
应使用唯一标志创建。要在约束/索引中指定多列或指定显式名称,请使用 UniqueConstraint
或 Index
显式构造。
system¶ -- 什么时候? True
,表示这是一个“系统”列,该列由数据库自动提供,不应包含在 CREATE TABLE
语句。对于应该在不同后端有条件地呈现不同列的更详细的场景,请考虑自定义编译规则 CreateColumn
.
comment¶ -- 用于在创建表时呈现SQL注释的可选字符串。…版本添加::1.2添加了 Column.comment
参数到 Column
.
__le__
(other)¶继承 __le__()
方法 ColumnOperators
实施 <=
操作符。
在列上下文中,生成子句 a <= b
.
__lt__
(other)¶继承 __lt__()
方法 ColumnOperators
实施 <
操作符。
在列上下文中,生成子句 a < b
.
__ne__
(other)¶继承 __ne__()
方法 ColumnOperators
实施 !=
操作符。
在列上下文中,生成子句 a != b
. 如果目标是 None
生产 a IS NOT NULL
.
all_
()¶继承 all_()
方法 ColumnOperators
产生一个 all_()
针对父对象的子句。
此运算符仅适用于标量子查询对象,或某些后端的列表达式适用于数组类型,例如::
# postgresql '5 = ALL (somearray)'
expr = 5 == mytable.c.somearray.all_()
# mysql '5 = ALL (SELECT value FROM table)'
expr = 5 == select([table.c.value]).as_scalar().all_()
1.1 新版功能.
anon_label
¶继承 anon_label
属性 ColumnElement
为此ColumnElement提供常量“匿名标签”。
这是一个label()表达式,将在编译时命名。每次调用anon_标签时都返回相同的label(),这样表达式可以多次引用anon_标签,从而在编译时生成相同的标签名称。
编译器在编译时自动将此函数用于已知为“未命名”的表达式,如二进制表达式和函数调用。
any_
()¶继承 any_()
方法 ColumnOperators
产生一个 any_()
针对父对象的子句。
此运算符仅适用于标量子查询对象,或某些后端的列表达式适用于数组类型,例如::
# postgresql '5 = ANY (somearray)'
expr = 5 == mytable.c.somearray.any_()
# mysql '5 = ANY (SELECT value FROM table)'
expr = 5 == select([table.c.value]).as_scalar().any_()
1.1 新版功能.
argument_for
(dialect_name, argument_name, default)¶继承 argument_for()
方法 DialectKWArgs
为此类添加一种新的方言特定关键字参数。
例如。::
Index.argument_for("mydialect", "length", None)
some_index = Index('a', 'b', mydialect_length=5)
这个 DialectKWArgs.argument_for()
方法是按参数向 DefaultDialect.construct_arguments
字典。此字典提供了各种模式级构造代表方言接受的参数名列表。
新方言通常应同时将此字典指定为方言类的数据成员。临时添加参数名的用例通常用于最终用户代码,该代码也使用自定义编译方案,该方案使用附加参数。
dialect_name¶ -- 方言的名称。方言必须可定位,否则 NoSuchModuleError
提高了。方言还必须包括现有的 DefaultDialect.construct_arguments
集合,指示它参与关键字参数验证和默认系统,否则 ArgumentError
提高了。如果方言不包含此集合,则可以代表此方言指定任何关键字参数。包含在sqlAlchemy中的所有方言都包含此集合,但是对于第三方方言,支持可能有所不同。
argument_name¶ -- 参数的名称。
default¶ -- 参数的默认值。
0.9.4 新版功能.
asc
()¶继承 asc()
方法 ColumnOperators
产生一个 asc()
针对父对象的子句。
between
(cleft, cright, symmetric=False)¶继承 between()
方法 ColumnOperators
产生一个 between()
在给定上下限的情况下,针对父对象的子句。
bool_op
(opstring, precedence=0)¶返回自定义布尔运算符。
这个方法是调用 Operators.op()
并通过 Operators.op.is_comparison
标记为真。
1.2.0b3 新版功能.
cast
(type_)¶继承 cast()
方法 ColumnElement
生成类型转换,即 CAST(<expression> AS <type>)
.
这是到 cast()
功能。
1.0.7 新版功能.
collate
(collation)¶继承 collate()
方法 ColumnOperators
产生一个 collate()
在给定排序规则字符串的情况下,对父对象执行子句。
参见
compare
(other, use_proxies=False, equivalents=None, **kw)¶继承 compare()
方法 ColumnElement
将此ColumnElement与其他ColumnElement进行比较。
理解特殊论点:
compile
(default, bind=None, dialect=None, **kw)¶继承 compile()
方法 ClauseElement
编译此SQL表达式。
返回值为 Compiled
对象。调用 str()
或 unicode()
返回的值将生成结果的字符串表示形式。这个 Compiled
对象还可以返回绑定参数名称和值的字典,方法是 params
访问器。
bind¶ -- 安 Engine
或 Connection
从哪一个 Compiled
将被收购。此参数优先于此 ClauseElement
如果有绑定的引擎。
column_keys¶ -- 用于insert和update语句,列名称的列表,应出现在编译语句的values子句中。如果 None
,将呈现目标表对象中的所有列。
dialect¶ -- A Dialect
实例,其中 Compiled
将被收购。此参数优先于 bind 还有这个论点 ClauseElement
如果有绑定的引擎。
inline¶ -- 用于insert语句,对于不支持对新生成的主键列进行内联检索的方言,将强制用于创建新主键值的表达式在insert语句的value s子句中进行内联呈现。这通常指序列执行,但也可能指与主键关联的任何服务器端默认生成函数。 Column .
compile_kwargs¶ -- 在所有“访问”方法中传递给编译器的附加参数的可选字典。例如,这允许将任何自定义标志传递给自定义编译构造。它还用于通过 literal_binds
通过::从sqlachemy.sql导入表、列,选择t=table('t',column('x'))s=select( [t] .where(t.c.x==5)print s.compile(compile“literal_binds”:true)。添加的版本:0.9.0
concat
(other)¶继承 concat()
方法 ColumnOperators
实现“concat”运算符。
在列上下文中,生成子句 a || b
或使用 concat()
mysql上的操作符。
contains
(other, **kwargs)¶继承 contains()
方法 ColumnOperators
实现“contains”运算符。
生成一个类似表达式,该表达式根据字符串值中间的匹配项进行测试:
column LIKE '%' || <other> || '%'
例如。::
stmt = select([sometable]).\
where(sometable.c.column.contains("foobar"))
因为操作符使用 LIKE
,通配符 "%"
和 "_"
存在于<other>表达式中的也将表现为通配符。对于文本字符串值, ColumnOperators.contains.autoescape
标志可以设置为 True
将转义应用于字符串值中出现的这些字符,以便它们与自身匹配,而不是作为通配符匹配。或者, ColumnOperators.contains.escape
参数将建立一个给定字符作为转义字符,当目标表达式不是文本字符串时可以使用该字符。
other¶ -- 要比较的表达式。这通常是一个纯字符串值,但也可以是任意的SQL表达式。类似通配符 %
和 _
默认情况下不转义,除非 ColumnOperators.contains.autoescape
标志设置为真。
autoescape¶ -- 布尔值;如果为true,则在like表达式中建立转义符,然后将其应用于 "%"
, "_"
以及转义符本身在比较值中,该值被假定为文本字符串而不是SQL表达式。表达式如::somecolumn.contains(“foo%bar”,autoescape=true)将呈现为::somecolumn,如“%”。|| :param || '%' ESCAPE '/' With the value of :param as "foo/%bar"
. .. versionadded:: 1.2 .. versionchanged:: 1.2.0 The ColumnOperators.contains.autoescape
参数现在是一个简单的布尔值而不是一个字符;转义字符本身也被转义,并默认为正斜杠,可以使用 ColumnOperators.contains.escape
参数。
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"
在被传递到数据库之前。
copy
(**kw)¶创建此的副本 Column
,未初始化。
这是用在 Table.tometadata
.
desc
()¶继承 desc()
方法 ColumnOperators
产生一个 desc()
针对父对象的子句。
dialect_kwargs
¶继承 dialect_kwargs
属性 DialectKWArgs
指定为此构造的方言特定选项的关键字参数集合。
这些论据以原版呈现在这里。 <dialect>_<kwarg>
格式。只包括实际传递的参数;与 DialectKWArgs.dialect_options
集合,其中包含此方言已知的所有选项,包括默认值。
集合也是可写的;接受窗体的键 <dialect>_<kwarg>
值将组合到选项列表中。
0.9.2 新版功能.
在 0.9.4 版更改: 这个 DialectKWArgs.dialect_kwargs
集合现在可写。
参见
DialectKWArgs.dialect_options
-嵌套字典窗体
dialect_options
¶继承 dialect_options
属性 DialectKWArgs
指定为此构造的方言特定选项的关键字参数集合。
这是一个两级嵌套注册表,键控为 <dialect_name>
和 <argument_name>
. 例如, postgresql_where
参数可定位为:
arg = my_object.dialect_options['postgresql']['where']
0.9.2 新版功能.
参见
DialectKWArgs.dialect_kwargs
-平字典形式
distinct
()¶继承 distinct()
方法 ColumnOperators
产生一个 distinct()
针对父对象的子句。
endswith
(other, **kwargs)¶继承 endswith()
方法 ColumnOperators
实现“endswith”运算符。
生成一个类似表达式,该表达式根据字符串值末尾的匹配项进行测试:
column LIKE '%' || <other>
例如。::
stmt = select([sometable]).\
where(sometable.c.column.endswith("foobar"))
因为操作符使用 LIKE
,通配符 "%"
和 "_"
存在于<other>表达式中的也将表现为通配符。对于文本字符串值, ColumnOperators.endswith.autoescape
标志可以设置为 True
将转义应用于字符串值中出现的这些字符,以便它们与自身匹配,而不是作为通配符匹配。或者, ColumnOperators.endswith.escape
参数将建立一个给定字符作为转义字符,当目标表达式不是文本字符串时可以使用该字符。
other¶ -- 要比较的表达式。这通常是一个纯字符串值,但也可以是任意的SQL表达式。类似通配符 %
和 _
默认情况下不转义,除非 ColumnOperators.endswith.autoescape
标志设置为真。
autoescape¶ -- 布尔值;如果为true,则在like表达式中建立转义符,然后将其应用于 "%"
, "_"
以及转义符本身在比较值中,该值被假定为文本字符串而不是SQL表达式。表达式如::somecolumn.endswith(“foo%bar”,autoescape=true)将呈现为::somecolumn,如“%”。|| :param ESCAPE '/' With the value of :param as "foo/%bar"
. .. versionadded:: 1.2 .. versionchanged:: 1.2.0 The ColumnOperators.endswith.autoescape
参数现在是一个简单的布尔值而不是一个字符;转义字符本身也被转义,并默认为正斜杠,可以使用 ColumnOperators.endswith.escape
参数。
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"
在被传递到数据库之前。
expression
¶继承 expression
属性 ColumnElement
返回列表达式。
检查界面的一部分;返回自身。
get_children
(schema_visitor=False, **kwargs)¶用于允许架构访问者访问
ilike
(other, escape=None)¶继承 ilike()
方法 ColumnOperators
实施 ilike
运算符,例如不区分大小写的like。
在列上下文中,生成以下任一形式的表达式:
lower(a) LIKE lower(other)
或者在支持ilike运算符的后端:
a ILIKE other
例如。::
stmt = select([sometable]).\
where(sometable.c.column.ilike("%foobar%"))
in_
(other)¶继承 in_()
方法 ColumnOperators
实施 in
操作符。
在列上下文中,生成子句 column IN <other>
.
给定参数 other
可能是:
文字值列表,例如:
stmt.where(column.in_([1, 2, 3]))
在此调用表单中,项目列表将转换为一组与给定列表长度相同的绑定参数:
WHERE COL IN (?, ?, ?)
空列表,例如:
stmt.where(column.in_([]))
在此调用形式中,表达式呈现“false”表达式,例如:
WHERE 1 != 1
这个“假”表达式在旧的sqlAlchemy版本中历史上有不同的行为,请参见 create_engine.empty_in_strategy
对于行为选项。
在 1.2 版更改: 简化了“空入”表达式的行为
绑定参数,例如 bindparam()
,如果包含 bindparam.expanding
标志:
stmt.where(column.in_(bindparam('value', expanding=True)))
在此调用表单中,表达式呈现一个特殊的非SQL占位符表达式,其外观如下:
WHERE COL IN ([EXPANDING_value])
此占位符表达式在语句执行时被截取,以便转换为前面所示的绑定参数表单的变量号。如果语句的执行方式为:
connection.execute(stmt, {"value": [1, 2, 3]})
将为数据库传递每个值的绑定参数:
WHERE COL IN (?, ?, ?)
1.2 新版功能: 添加了“扩展”绑定参数
如果传递空列表,将呈现一个特定于正在使用的数据库的特殊“空列表”表达式。在sqlite上:
WHERE COL IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1)
1.3 新版功能: “expanding”绑定参数现在支持空列表
一 select()
构造,通常是相关的标量选择:
stmt.where(
column.in_(
select([othertable.c.y]).
where(table.c.x == othertable.c.x)
)
)
在这个调用表单中, ColumnOperators.in_()
按给定呈现:
WHERE COL IN (SELECT othertable.y
FROM othertable WHERE othertable.x = table.x)
other¶ -- 文字列表,a select()
构造,或 bindparam()
构造,包括 bindparam.expanding
标志设置为真。
info
¶继承 info
属性 SchemaItem
与对象关联的信息字典,允许用户定义的数据与此关联 SchemaItem
.
is_
(other)¶继承 is_()
方法 ColumnOperators
实施 IS
操作符。
通常情况下, IS
与以下值比较时自动生成 None
,决定 NULL
. 但是,明确使用 IS
如果与某些平台上的布尔值进行比较,可能是可取的。
is_distinct_from
(other)¶实施 IS DISTINCT FROM
操作符。
在大多数平台上呈现“a与b不同”;在某些平台上,例如sqlite可能呈现“a不是b”。
1.1 新版功能.
isnot
(other)¶继承 isnot()
方法 ColumnOperators
实施 IS NOT
操作符。
通常情况下, IS NOT
与以下值比较时自动生成 None
,决定 NULL
. 但是,明确使用 IS NOT
如果与某些平台上的布尔值进行比较,可能是可取的。
isnot_distinct_from
(other)¶实施 IS NOT DISTINCT FROM
操作符。
在大多数平台上呈现“a与b不同”;在某些平台上,例如sqlite可能呈现“a是b”。
1.1 新版功能.
kwargs
¶继承 kwargs
属性 DialectKWArgs
label
(name)¶继承 label()
方法 ColumnElement
生成列标签,即 <columnname> AS <name>
.
这是到 label()
功能。
如果“name”为“none”,则将生成匿名标签名。
like
(other, escape=None)¶继承 like()
方法 ColumnOperators
实施 like
操作符。
在列上下文中,生成表达式::
a LIKE other
例如。::
stmt = select([sometable]).\
where(sometable.c.column.like("%foobar%"))
match
(other, **kwargs)¶继承 match()
方法 ColumnOperators
实现特定于数据库的“match”运算符。
match()
尝试解析为后端提供的类似匹配的函数或运算符。示例包括:
PostgreSQL-呈现 x @@ to_tsquery(y)
MySQL -渲染器 MATCH (x) AGAINST (y IN BOOLEAN MODE)
Oracle-呈现 CONTAINS(x, y)
其他后端可能提供特殊的实现。
没有任何特殊实现的后端将发出“match”操作符。例如,这与sqlite兼容。
notilike
(other, escape=None)¶继承 notilike()
方法 ColumnOperators
实施 NOT ILIKE
操作符。
这相当于使用否定 ColumnOperators.ilike()
,即 ~x.ilike(y)
.
notin_
(other)¶继承 notin_()
方法 ColumnOperators
实施 NOT IN
操作符。
这相当于使用否定 ColumnOperators.in_()
,即 ~x.in_(y)
.
在这种情况下 other
是一个空序列,编译器生成一个“empty not in”表达式。这将默认表达式“1=1”在所有情况下都生成“真”。这个 create_engine.empty_in_strategy
可用于更改此行为。
在 1.2 版更改: 这个 ColumnOperators.in_()
和 ColumnOperators.notin_()
现在,默认情况下,运算符为空序列生成一个“静态”表达式。
notlike
(other, escape=None)¶继承 notlike()
方法 ColumnOperators
实施 NOT LIKE
操作符。
这相当于使用否定 ColumnOperators.like()
,即 ~x.like(y)
.
nullsfirst
()¶继承 nullsfirst()
方法 ColumnOperators
产生一个 nullsfirst()
针对父对象的子句。
nullslast
()¶继承 nullslast()
方法 ColumnOperators
产生一个 nullslast()
针对父对象的子句。
op
(opstring, precedence=0, is_comparison=False, return_type=None)¶生成通用运算符函数。
例如。::
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
,而那些不属于左侧操作数的类型。…versionAdded::1.2.0b3-添加了 Operators.op.return_type
争论。
operate
(op, *other, **kwargs)¶继承 operate()
方法 ColumnElement
对参数进行运算。
这是最低级别的操作,提升 NotImplementedError
默认情况下。
在子类上覆盖此项可以允许将公共行为应用于所有操作。例如,重写 ColumnOperators
申请 func.lower()
左右两侧:
class MyComparator(ColumnOperators):
def operate(self, op, other):
return op(func.lower(self), func.lower(other))
quote
¶继承 quote
属性 SchemaItem
返回的值 quote
传递给此架构对象的标志,用于具有 name
字段。
0.9 版后已移除: 这个 SchemaItem.quote
属性已弃用,将在将来的版本中删除。使用 quoted_name.quote
属性 name
要检索引用状态的目标架构项的字段。
references
(column)¶如果此列通过外键引用给定列,则返回true。
self_group
(against=None)¶继承 self_group()
方法 ColumnElement
对此应用“分组” ClauseElement
.
此方法被子类重写以返回“grouping”构造,即括号。尤其是“binary”表达式使用它在放入更大的表达式时提供围绕其自身的分组,以及 select()
当放入另一个的FROM子句时构造 select()
. (请注意,通常应使用 Select.alias()
方法,因为许多平台都需要命名嵌套的select语句)。
当表达式组合在一起时,应用 self_group()
是自动的-最终用户代码不需要直接使用这个方法。请注意,sqlachemy的子句构造将运算符优先考虑在内,因此可能不需要括号,例如,在类似这样的表达式中 x OR (y AND z)
-优先于或。
底座 self_group()
方法 ClauseElement
只需返回自我。
如果给定 ColumnElement
有着共同的祖先 ColumnElement
.
startswith
(other, **kwargs)¶继承 startswith()
方法 ColumnOperators
实施 startswith
操作符。
生成一个类似表达式,该表达式根据字符串值开头的匹配项进行测试:
column LIKE <other> || '%'
例如。::
stmt = select([sometable]).\
where(sometable.c.column.startswith("foobar"))
因为操作符使用 LIKE
,通配符 "%"
和 "_"
存在于<other>表达式中的也将表现为通配符。对于文本字符串值, ColumnOperators.startswith.autoescape
标志可以设置为 True
将转义应用于字符串值中出现的这些字符,以便它们与自身匹配,而不是作为通配符匹配。或者, ColumnOperators.startswith.escape
参数将建立一个给定字符作为转义字符,当目标表达式不是文本字符串时可以使用该字符。
other¶ -- 要比较的表达式。这通常是一个纯字符串值,但也可以是任意的SQL表达式。类似通配符 %
和 _
默认情况下不转义,除非 ColumnOperators.startswith.autoescape
标志设置为真。
autoescape¶ -- 布尔值;如果为true,则在like表达式中建立转义符,然后将其应用于 "%"
, "_"
以及转义符本身在比较值中,该值被假定为文本字符串而不是SQL表达式。表达式如::somecolumn.startswith(“foo%bar”,autoescape=true)将呈现为::somecolumn-like :param || '%' ESCAPE '/' With the value of :param as "foo/%bar"
. .. versionadded:: 1.2 .. versionchanged:: 1.2.0 The ColumnOperators.startswith.autoescape
参数现在是一个简单的布尔值而不是一个字符;转义字符本身也被转义,并默认为正斜杠,可以使用 ColumnOperators.startswith.escape
参数。
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"
在被传递到数据库之前。
sqlalchemy.schema.
MetaData
(bind=None, reflect=False, schema=None, quote_schema=None, naming_convention=None, info=None)¶基地: sqlalchemy.schema.SchemaItem
收藏 Table
对象及其关联的架构构造。
持有的集合 Table
对象以及到 Engine
或 Connection
. 如果绑定,则 Table
集合中的对象及其列可能参与隐式SQL执行。
这个 Table
对象本身存储在 MetaData.tables
字典。
MetaData
是用于读取操作的线程安全对象。在单个表中构建新表 MetaData
对象(显式或通过反射)可能不是完全线程安全的。
参见
用元数据描述数据库 -数据库元数据简介
__init__
(bind=None, reflect=False, schema=None, quote_schema=None, naming_convention=None, info=None)¶创建新的元数据对象。
bind¶ -- 要绑定到的引擎或连接。也可以是一个字符串或URL实例,这些实例被传递给create_engine(),并且此元数据将绑定到结果引擎。
reflect¶ -- 可选,自动从绑定数据库加载所有表。默认为false。 bind
设置此选项时需要。…已弃用::0.8 MetaData.reflect
标志已弃用,将在将来的版本中删除。请使用 MetaData.reflect()
方法。
schema¶ -- 用于的默认架构 Table
, Sequence
以及可能与此关联的其他对象 MetaData
.默认为 None
. 设置此值时,任何 Table
或 Sequence
其中指定 None
对于schema参数,将改为定义此架构名称。建立一个 Table
或 Sequence
那仍然有 None
对于模式,即使存在此参数,也要使用 BLANK_SCHEMA
符号。…注:如上所述, MetaData.schema
参数仅指 默认值 这将应用于 Table.schema
传入的参数 Table
对象。它不涉及 Table
目录在 MetaData
,与A相比保持一致 MetaData
未定义此参数的集合。这个 Table
内 MetaData
仍将根据其模式限定名进行键控,例如 my_metadata.tables["some_schema.my_table"]
. 当前的行为 ForeignKey
对象将绕过此限制,在该限制下,它可以仅在给定表名的情况下定位一个表,在该限制下,架构将被假定为根据所属对象上指定的该值存在。 MetaData
收集。但是,这意味着当前不能通过字符串名称引用具有空模式限定的表。 ForeignKey
. SQLAlchemy的其他部分(如声明性)可能没有内置类似的行为,但是在未来的版本中可能会这样做,以及引用空白模式中表的一致方法。…参阅: Table.schema
Sequence.schema
quote_schema¶ -- 设置 quote_schema
那些标志 Table
, Sequence
以及其他使用本地 schema
姓名。
info¶ -- 可选数据字典,将填充到 SchemaItem.info
此对象的属性。…添加的版本:1.0.0
naming_convention¶ -- 一个引用值的字典,该值将为 Constraint
和 Index
对象,对于那些未显式给定名称的对象。本词典的关键字可能是: * a constraint or Index class, e.g. the UniqueConstraint
, ForeignKeyConstraint
class, the Index
class * 已知约束类之一的字符串助记符; "fk"
, "pk"
, "ix"
, "ck"
, "uq"
分别用于外键、主键、索引、检查和唯一约束。 * the string name of a user-defined "token" that can be used to define new naming tokens. The values associated with each "constraint class" or "constraint mnemonic" key are string naming templates, such as "uq_%(table_name)s_%(column_0_name)s"
, which describe how the name should be composed. The values associated with user-defined "token" keys should be callables of the form fn(constraint, table)
, which accepts the constraint/index object and Table
as arguments, returning a string result. The built-in names are as follows, some of which may only be available for certain types of constraint: * %(table_name)s
-的名称 Table
与约束关联的对象。 * %(referred_table_name)s
- the name of the Table
object associated with the referencing target of a ForeignKeyConstraint
. * %(column_0_name)s
-的名称 Column
在约束内的索引位置“0”处。 * %(column_0N_name)s
- the name of all Column
objects in order within the constraint, joined without a separator. * %(column_0_N_name)s
-所有人的名字 Column
对象在约束内按顺序排列,并用下划线作为分隔符联接。 * %(column_0_label)s
, %(column_0N_label)s
, %(column_0_N_label)s
- the label of either the zeroth Column
or all Columns
, separated with or without an underscore * %(column_0_key)s
, %(column_0N_key)s
, %(column_0_N_key)s
-零的键 Column
或全部 Columns
,用下划线或不带下划线分隔 * %(referred_column_0_name)s
, %(referred_column_0N_name)s
%(referred_column_0_N_name)s
, %(referred_column_0_key)s
, %(referred_column_0N_key)s
, ... column tokens which render the names/keys/labels of columns that are referenced by a ForeignKeyConstraint
. * %(constraint_name)s
-引用给定给约束的现有名称的特殊键。当此密钥存在时, Constraint
对象的现有名称将替换为由使用此标记的模板字符串组成的名称。当此令牌存在时,需要 Constraint
提前给出一个明确的名称。*用户定义的:任何附加令牌都可以通过将其与 fn(constraint, table)
可调用命名约定字典。…版本已添加::1.3.0-已添加新版本 %(column_0N_name)s
, %(column_0_N_name)s
,以及为给定约束引用的所有列生成名称、键或标签串联的相关标记。…参阅: 配置约束命名约定 -有关详细的用法示例。
append_ddl_listener
(event_name, listener)¶将DDL事件侦听器附加到此 MetaData
.
0.7 版后已移除: 这个 MetaData.append_ddl_listener()
方法已弃用,将在将来的版本中删除。请参考 DDLEvents
.
bind
¶安 Engine
或 Connection
对此 MetaData
是绑定的。
典型地,A Engine
分配给该属性,以便可以使用“隐式执行”,或者作为向ORM提供引擎绑定信息的方法。 Session
对象:
engine = create_engine("someurl://")
metadata.bind = engine
参见
无连接执行,隐式执行 -“绑定元数据”的背景
clear
()¶清除此元数据中的所有表对象。
create_all
(bind=None, tables=None, checkfirst=True)¶创建存储在此元数据中的所有表。
默认情况下,将不会尝试重新创建目标数据库中已存在的表。
bind¶ -- A Connectable
用于访问数据库;如果没有,则对此使用现有绑定 MetaData
,如果有的话。
tables¶ -- 可选列表 Table
对象,它是 MetaData
(其他被忽略)。
checkfirst¶ -- 默认为true,不为目标数据库中已存在的表发出creates。
drop_all
(bind=None, tables=None, checkfirst=True)¶删除此元数据中存储的所有表。
条件默认情况下,不会尝试删除目标数据库中不存在的表。
bind¶ -- A Connectable
用于访问数据库;如果没有,则对此使用现有绑定 MetaData
,如果有的话。
tables¶ -- 可选列表 Table
对象,它是 MetaData
(其他被忽略)。
checkfirst¶ -- 默认值为true,仅对确认存在于目标数据库中的表发出drops。
is_bound
()¶如果此元数据绑定到引擎或连接,则为true。
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
,如果有的话。
views¶ -- 如果为真,也反映观点。
only¶ -- 可选的。仅加载可用命名表的子集。可以指定为名称序列或可调用。如果提供了一系列名称,则只会反映这些表。如果请求表但不可用,则会引发错误。此中已存在命名表 MetaData
被忽略。如果提供了可调用的,它将用作布尔谓词来筛选潜在表名的列表。使用表名调用可调用文件,并且 MetaData
实例作为位置参数,应为要反映的任何表返回一个真值。
extend_existing¶ -- 传给每个人 Table
作为 Table.extend_existing
. …添加的版本:0.9.1
autoload_replace¶ -- 传给每个人 Table
作为 Table.autoload_replace
. …添加的版本:0.9.1
resolve_fks¶ -- 如果为真,请反映 Table
链接到的对象 ForeignKey
位于每个 Table
. 为了 MetaData.reflect()
,这具有反射相关表的效果,否则这些表可能不在要反射的表列表中,例如,如果引用的表位于不同的架构中或通过 MetaData.reflect.only
参数。当错误时, ForeignKey
对象不跟随到 Table
但是,如果相关表也是在任何情况下都会反映的表列表的一部分,那么 ForeignKey
对象仍将解析为其相关的 Table
后 MetaData.reflect()
操作完成。默认为true。…版本已添加::1.3.0..参阅: Table.resolve_fks
**dialect_kwargs¶ -- 上面未提到的其他关键字参数是特定于方言的,并以形式传递 <dialectname>_<argname>
. 有关单个方言的文档,请参见 方言 有关文档化参数的详细信息。…版本已添加::0.9.2-已添加 MetaData.reflect.**dialect_kwargs
为所有用户支持方言级反射选项 Table
反射的对象。
remove
(table)¶从此元数据中删除给定的表对象。
sorted_tables
¶返回的列表 Table
按外键依赖项的顺序排序的对象。
将进行排序 Table
首先具有依赖项的对象,在依赖项本身之前,表示它们的创建顺序。要获取表的删除顺序,请使用 reversed()
python内置。
警告
这个 sorted_tables
访问器本身不能自动解析表之间的依赖循环,这通常是由相互依赖的外键约束引起的。为了解决这些循环,要么 ForeignKeyConstraint.use_alter
参数可以应用于这些约束,或者使用 schema.sort_tables_and_constraints()
函数,它将分别打破循环中涉及的外键约束。
sqlalchemy.schema.
SchemaItem
¶基地: sqlalchemy.sql.expression.SchemaEventTarget
, sqlalchemy.sql.visitors.Visitable
定义数据库架构的项的基类。
get_children
(**kwargs)¶用于允许架构访问者访问
info
¶与对象关联的信息字典,允许用户定义的数据与此关联 SchemaItem
.
quote
¶返回的值 quote
传递给此架构对象的标志,用于具有 name
字段。
0.9 版后已移除: 这个 SchemaItem.quote
属性已弃用,将在将来的版本中删除。使用 quoted_name.quote
属性 name
要检索引用状态的目标架构项的字段。
sqlalchemy.schema.
Table
(*args, **kw)¶基地: sqlalchemy.sql.base.DialectKWArgs
, sqlalchemy.schema.SchemaItem
, sqlalchemy.sql.expression.TableClause
表示数据库中的表。
例如。::
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¶ -- 默认为假,除非 Table.autoload_with
在这种情况下,它默认为true; Column
此表的对象应反映在数据库中,可能会增加或替换现有的 Column
显式指定的对象。…versionChanged::1.0.0设置 Table.autoload_with
参数意味着 Table.autoload
将默认为true。…参阅: 反映数据库对象
autoload_replace¶ -- 默认为 True
当使用时 Table.autoload
与 Table.extend_existing
,表示 Column
存在于已存在的中的对象 Table
对象应替换为从自动加载进程中检索到的同名列。什么时候? False
,已存在于现有名称下的列将从反射过程中省略。请注意,此设置不影响 Column
在调用中以编程方式指定的对象 Table
这也是自动加载;那些 Column
当 Table.extend_existing
是 True
. …参阅: Table.autoload
Table.extend_existing
autoload_with¶ -- 安 Engine
或 Connection
对象 Table
对象将被反射;当设置为非“无”值时,它意味着 Table.autoload
是 True
. 如果未设置,但 Table.autoload
显式设置为 True
,自动加载操作将尝试通过定位 Engine
或 Connection
绑定到基础 MetaData
对象。…参阅: Table.autoload
extend_existing¶ -- 什么时候? True
,表示如果 Table
已存在于给定的 MetaData
,将构造函数中的其他参数应用于现有的 Table
. 如果 Table.extend_existing
或 Table.keep_existing
未设置,并且新的 Table
指的是 Table
已经存在于目标中 MetaData
收藏,还有这个 Table
指定修改表状态的其他列或其他构造或标志,将引发错误。这两个互斥标志的目的是指定当 Table
指定与现有的 Table
,但指定了其他构造。 Table.extend_existing
也将与 Table.autoload
对数据库运行新的反射操作,即使 Table
目标中已存在同名的 MetaData
;新反映 Column
对象和其他选项将添加到 Table
,可能会覆盖同名的现有列和选项。和往常一样 Table.autoload
, Column
对象可以在同一个 Table
构造函数,优先。下面,现有表格 mytable
将增加 Column
对象既从数据库反映,也从给定的 Column
命名为“y”::table(“mytable”,元数据,列(“y”,整数),extend_existing=true,autoload=true,autoload_with=engine)。参阅: Table.autoload
Table.autoload_replace
Table.keep_existing
implicit_returning¶ -- 默认情况下为true-表示默认情况下,对于支持此操作的后端,可以使用返回来获取新插入的主键值。注意,create_engine()还提供了一个隐式的_返回标志。
include_columns¶ -- 一个字符串列表,指示要通过 autoload
操作;不在此列表中的表列将不会显示在结果中 Table
对象。默认为 None
它表示所有列都应该被反射。
resolve_fks¶ -- 是否反映 Table
与此相关的对象通过 ForeignKey
对象时 Table.autoload
或 Table.autoload_with
已指定。默认为true。设置为false以禁用相关表的反射为 ForeignKey
遇到对象;可以用于保存SQL调用,也可以用于避免与无法访问的相关表有关的问题。请注意,如果相关表已存在于 MetaData
收藏,或稍后出现 ForeignKey
与此关联的对象 Table
将正常解析到该表。…版本已添加::1.3..参阅: MetaData.reflect.resolve_fks
info¶ -- 可选数据字典,将填充到 SchemaItem.info
此对象的属性。
keep_existing¶ -- 什么时候? True
,指示如果此表已存在于给定的 MetaData
,忽略构造函数中现有的 Table
,并返回 Table
对象与最初创建的对象相同。这是为了允许一个函数定义一个新的 Table
第一次调用,但随后的调用将返回相同的 Table
,而不会再次应用任何声明(尤其是约束)。如果 Table.extend_existing
或 Table.keep_existing
未设置,并且新的 Table
指的是 Table
已经存在于目标中 MetaData
收藏,还有这个 Table
指定修改表状态的其他列或其他构造或标志,将引发错误。这两个互斥标志的目的是指定当 Table
指定与现有的 Table
,但指定了其他构造。…参阅: Table.extend_existing
listeners¶ -- 窗体的元组列表 (<eventname>, <fn>)
将传递给 event.listen()
施工时。这个备用挂钩 event.listen()
允许建立特定于此的侦听器函数 Table
在“自动加载”过程开始之前。特别适用于 DDLEvents.column_reflect()
事件::def listen_for_reflect(table,column_info):“处理列反射事件”…t=table(“sometable”,autoload=true,侦听器= [ ('column_reflect', listen_for_reflect) ] )
mustexist¶ -- 什么时候? 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
构造以指定名称。
useexisting¶ -- 一样 Table.extend_existing
.
comment¶ -- 用于在创建表时呈现SQL注释的可选字符串。…版本添加::1.2添加了 Table.comment
参数到 Table
.
**kw¶ -- 上面未提到的其他关键字参数是特定于方言的,并以形式传递 <dialectname>_<argname>
. 有关单个方言的文档,请参见 方言 有关文档化参数的详细信息。
__eq__
¶继承 __eq__
属性 object
返回self==值。
__le__
¶继承 __le__
属性 object
返回self<=value。
__lt__
¶继承 __lt__
属性 object
返回self<value。
__ne__
¶继承 __ne__
属性 object
回归自我!=值。
add_is_dependent_on
(table)¶为此表添加“依赖项”。
这是另一个表对象,必须先创建该对象,然后才能创建该对象,或者在此对象之后删除。
通常,表之间的依赖关系是通过foreignkey对象确定的。但是,对于在外键之外创建依赖项的其他情况(规则、继承),此方法可以手动建立这样的链接。
alias
(name=None, flat=False)¶继承 alias()
方法 FromClause
返回此的别名 FromClause
.
这是调用的简写:
from sqlalchemy import alias
a = alias(self, name=name)
见 alias()
有关详细信息。
append_column
(column)¶新增的"key" Column
,即 .key
属性,然后将在 .c
这个的集合 Table
,列定义将包含在由此生成的任何create table、select、update等语句中。 Table
构造。
注意这是 not 更改表的定义,因为它存在于任何基础数据库中,假定该表已在数据库中创建。关系数据库支持使用sql alter命令将列添加到现有表中,这需要为不包含新添加列的现有表发出。
append_constraint
(constraint)¶追加一个 Constraint
对此 Table
.
这是由于约束包含在任何将来的create table语句中,假定特定的DDL创建事件没有与给定的 Constraint
对象。
注意这是 not 为数据库中已存在的表自动在关系数据库中生成约束。若要向现有关系数据库表添加约束,必须使用sql alter命令。SQLAlchemy还提供 AddConstraint
构造,当作为可执行子句调用时可以生成此SQL。
append_ddl_listener
(event_name, listener)¶将DDL事件侦听器附加到此 Table
.
0.7 版后已移除: 这个 Table.append_ddl_listener()
方法已弃用,将在将来的版本中删除。请参考 DDLEvents
.
argument_for
(dialect_name, argument_name, default)¶继承 argument_for()
方法 DialectKWArgs
为此类添加一种新的方言特定关键字参数。
例如。::
Index.argument_for("mydialect", "length", None)
some_index = Index('a', 'b', mydialect_length=5)
这个 DialectKWArgs.argument_for()
方法是按参数向 DefaultDialect.construct_arguments
字典。此字典提供了各种模式级构造代表方言接受的参数名列表。
新方言通常应同时将此字典指定为方言类的数据成员。临时添加参数名的用例通常用于最终用户代码,该代码也使用自定义编译方案,该方案使用附加参数。
dialect_name¶ -- 方言的名称。方言必须可定位,否则 NoSuchModuleError
提高了。方言还必须包括现有的 DefaultDialect.construct_arguments
集合,指示它参与关键字参数验证和默认系统,否则 ArgumentError
提高了。如果方言不包含此集合,则可以代表此方言指定任何关键字参数。包含在sqlAlchemy中的所有方言都包含此集合,但是对于第三方方言,支持可能有所不同。
argument_name¶ -- 参数的名称。
default¶ -- 参数的默认值。
0.9.4 新版功能.
bind
¶返回与此表关联的可连接项。
c
¶继承 c
属性 FromClause
的别名 columns
属性。
columns
¶继承 columns
属性 FromClause
基于命名的集合 ColumnElement
由此维护的对象 FromClause
.
这个 columns
或 c
集合,是使用表绑定或其他可选绑定列构造SQL表达式的网关::
select([mytable]).where(mytable.c.somecolumn == 5)
compare
(other, **kw)¶继承 compare()
方法 ClauseElement
将这一条款与给定的条款进行比较。
子类应该覆盖默认行为,这是一个直接的身份比较。
* *kw是子类compare()方法使用的参数,可用于修改比较条件。(见 ColumnElement
)
compile
(default, bind=None, dialect=None, **kw)¶继承 compile()
方法 ClauseElement
编译此SQL表达式。
返回值为 Compiled
对象。调用 str()
或 unicode()
返回的值将生成结果的字符串表示形式。这个 Compiled
对象还可以返回绑定参数名称和值的字典,方法是 params
访问器。
bind¶ -- 安 Engine
或 Connection
从哪一个 Compiled
将被收购。此参数优先于此 ClauseElement
如果有绑定的引擎。
column_keys¶ -- 用于insert和update语句,列名称的列表,应出现在编译语句的values子句中。如果 None
,将呈现目标表对象中的所有列。
dialect¶ -- A Dialect
实例,其中 Compiled
将被收购。此参数优先于 bind 还有这个论点 ClauseElement
如果有绑定的引擎。
inline¶ -- 用于insert语句,对于不支持对新生成的主键列进行内联检索的方言,将强制用于创建新主键值的表达式在insert语句的value s子句中进行内联呈现。这通常指序列执行,但也可能指与主键关联的任何服务器端默认生成函数。 Column .
compile_kwargs¶ -- 在所有“访问”方法中传递给编译器的附加参数的可选字典。例如,这允许将任何自定义标志传递给自定义编译构造。它还用于通过 literal_binds
通过::从sqlachemy.sql导入表、列,选择t=table('t',column('x'))s=select( [t] .where(t.c.x==5)print s.compile(compile“literal_binds”:true)。添加的版本:0.9.0
correspond_on_equivalents
(column, equivalents)¶返回给定列的对应列,或者如果没有,则在给定字典中搜索匹配项。
corresponding_column
(column, require_embedded=False)¶给出了一个 ColumnElement
,返回导出的 ColumnElement
来自此的对象 Selectable
与原件相对应 Column
通过一个共同的祖先列。
column¶ -- 目标 ColumnElement
相配
require_embedded¶ -- 仅返回给定的对应列 ColumnElement
,如果给定的 ColumnElement
实际存在于此子元素中 FromClause
. 通常情况下,如果该列只与该列的某个导出列共享一个共同的祖先,则该列将匹配。 FromClause
.
count
(functions, whereclause=None, **params)¶继承 count()
方法 FromClause
返回为此生成的选择计数 FromClause
.
1.1 版后已移除: 这个 FromClause.count()
方法已弃用,将在将来的版本中删除。请使用 functions.count
功能可从 func
命名空间。
create
(bind=None, checkfirst=False)¶发行A CREATE
声明 Table
,使用给定的 Connectable
用于连接。
delete
(dml, whereclause=None, **kwargs)¶继承 delete()
方法 TableClause
生成一个 delete()
在此基础上构建 TableClause
.
例如。::
table.delete().where(table.c.id==7)
见 delete()
获取参数和用法信息。
dialect_kwargs
¶继承 dialect_kwargs
属性 DialectKWArgs
指定为此构造的方言特定选项的关键字参数集合。
这些论据以原版呈现在这里。 <dialect>_<kwarg>
格式。只包括实际传递的参数;与 DialectKWArgs.dialect_options
集合,其中包含此方言已知的所有选项,包括默认值。
集合也是可写的;接受窗体的键 <dialect>_<kwarg>
值将组合到选项列表中。
0.9.2 新版功能.
在 0.9.4 版更改: 这个 DialectKWArgs.dialect_kwargs
集合现在可写。
参见
DialectKWArgs.dialect_options
-嵌套字典窗体
dialect_options
¶继承 dialect_options
属性 DialectKWArgs
指定为此构造的方言特定选项的关键字参数集合。
这是一个两级嵌套注册表,键控为 <dialect_name>
和 <argument_name>
. 例如, postgresql_where
参数可定位为:
arg = my_object.dialect_options['postgresql']['where']
0.9.2 新版功能.
参见
DialectKWArgs.dialect_kwargs
-平字典形式
drop
(bind=None, checkfirst=False)¶发行A DROP
声明 Table
,使用给定的 Connectable
用于连接。
参见
exists
(bind=None)¶如果此表存在,则返回true。
foreign_key_constraints
¶ForeignKeyConstraint
此引用的对象 Table
.
此列表是从 ForeignKey
当前关联的对象。
1.0.0 新版功能.
foreign_keys
¶继承 foreign_keys
属性 FromClause
返回此FromClause引用的ForeignKey对象的集合。
get_children
(column_collections=True, schema_visitor=False, **kw)¶用于允许架构访问者访问
info
¶继承 info
属性 SchemaItem
与对象关联的信息字典,允许用户定义的数据与此关联 SchemaItem
.
insert
(dml, values=None, inline=False, **kwargs)¶继承 insert()
方法 TableClause
生成 insert()
在此基础上构建 TableClause
.
例如。::
table.insert().values(name='foo')
见 insert()
获取参数和用法信息。
is_derived_from
(fromclause)¶继承 is_derived_from()
方法 FromClause
如果此FromClause是从给定FromClause“派生”的,则返回true。
例如,表的别名是从该表派生的。
join
(right, onclause=None, isouter=False, full=False)¶继承 join()
方法 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
key
¶返回此的“密钥” Table
.
此值用作 MetaData.tables
收集。它通常与 Table.name
一张没有的表格 Table.schema
设置;否则它通常是 schemaname.tablename
.
kwargs
¶继承 kwargs
属性 DialectKWArgs
lateral
(name=None)¶继承 lateral()
方法 FromClause
返回此的横向别名 FromClause
.
返回值是 Lateral
顶层也提供施工 lateral()
功能。
1.1 新版功能.
参见
横向相关 -使用概述。
outerjoin
(right, onclause=None, full=False)¶继承 outerjoin()
方法 FromClause
返回A Join
由此 FromClause
对另一个 FromClause
,并将“Isouter”标志设置为true。
例如。::
from sqlalchemy import outerjoin
j = user_table.outerjoin(address_table,
user_table.c.id == address_table.c.user_id)
以上相当于:
j = user_table.join(
address_table,
user_table.c.id == address_table.c.user_id,
isouter=True)
right¶ -- 连接的右侧;这是任何 FromClause
对象,如 Table
对象,也可以是可选的兼容对象,如ORM映射类。
onclause¶ -- 表示联接的ON子句的SQL表达式。如果留在 None
, FromClause.join()
将尝试基于外键关系联接两个表。
full¶ -- 如果为true,则呈现完整的外部联接,而不是左外部联接。…添加的版本:1.1
primary_key
¶继承 primary_key
属性 FromClause
返回包含此FromClause的主键的列对象集合。
quote
¶继承 quote
属性 SchemaItem
返回的值 quote
传递给此架构对象的标志,用于具有 name
字段。
0.9 版后已移除: 这个 SchemaItem.quote
属性已弃用,将在将来的版本中删除。使用 quoted_name.quote
属性 name
要检索引用状态的目标架构项的字段。
quote_schema
¶返回的值 quote_schema
传递给此的标志 Table
.
0.9 版后已移除: 这个 SchemaItem.quote()
方法已弃用,将在将来的版本中删除。使用 quoted_name.quote
属性 schema
用于检索引用状态的目标架构项的字段。
replace_selectable
(sqlutil, old, alias)¶将所有出现的fromClause“old”替换为给定的别名对象,并返回此对象的副本 FromClause
.
select
(whereclause=None, **params)¶继承 select()
方法 FromClause
返回所选内容 FromClause
.
参见
select()
-允许任意列列表的通用方法。
self_group
(against=None)¶继承 self_group()
方法 ClauseElement
对此应用“分组” ClauseElement
.
此方法被子类重写以返回“grouping”构造,即括号。尤其是“binary”表达式使用它在放入更大的表达式时提供围绕其自身的分组,以及 select()
当放入另一个的FROM子句时构造 select()
. (请注意,通常应使用 Select.alias()
方法,因为许多平台都需要命名嵌套的select语句)。
当表达式组合在一起时,应用 self_group()
是自动的-最终用户代码不需要直接使用这个方法。请注意,sqlachemy的子句构造将运算符优先考虑在内,因此可能不需要括号,例如,在类似这样的表达式中 x OR (y AND z)
-优先于或。
底座 self_group()
方法 ClauseElement
只需返回自我。
tablesample
(sampling, name=None, seed=None)¶继承 tablesample()
方法 FromClause
返回此的TableSample别名 FromClause
.
返回值是 TableSample
顶层也提供施工 tablesample()
功能。
1.1 新版功能.
参见
tablesample()
-使用指南和参数
tometadata
(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.tometadata(m2)
schema¶ -- 指示目标架构的可选字符串名称。默认为特殊符号 RETAIN_SCHEMA
这表示在新的 Table
. 如果设置为字符串名称,则 Table
将这个新名称作为 .schema
. 如果设置为 None
,该架构将设置为目标上设置的架构的架构。 MetaData
,这通常是 None
同样,除非显式设置::m2=元数据(schema='newschema')user诳copy诳one将使用“newschema”作为架构名称user诳copy诳one=user.to metadata(m2,schema=none)m3=metadata()诳架构默认为none诳;user诳copy诳two将使用none作为架构名称user诳copy诳two=user.to metadata(m3,schema=none)
referred_schema_fn¶ -- 可选的可调用文件,可提供该文件以提供应分配给引用表的架构名称。 ForeignKeyConstraint
. 可调用对象接受此父对象 Table
,我们要更改的目标模式 ForeignKeyConstraint
对象,以及该约束的现有“目标模式”。函数应返回应应用的字符串架构名称。例如:def refered_-schema_-fn(table,to_-schema,constraint,refered_-schema):if refered_-schema=='base_-tables':返回refered_-schema else:返回到_-schema new_-table=table.tometadata(m2,schema=“alt_-schema”,referered_schema_fn=参考_schema_fn)。添加的版本:0.9.2
name¶ -- 指示目标表名称的可选字符串名称。如果未指定或未指定,则保留表名。这允许 Table
复制到相同的 MetaData
使用新名称作为目标。…版本已添加::1.0.0
update
(dml, whereclause=None, values=None, inline=False, **kwargs)¶继承 update()
方法 TableClause
生成 update()
在此基础上构建 TableClause
.
例如。::
table.update().where(table.c.id==7).values(name='foo')
见 update()
获取参数和用法信息。
sqlalchemy.schema.
ThreadLocalMetaData
¶基地: sqlalchemy.schema.MetaData
呈现不同 bind
在每一条线上。
使 bind
元数据的属性是线程本地值,允许将此表集合绑定到不同的 Engine
每个线程中的实现或连接。
线程localmetadata开始绑定到每个线程中的none。必须通过将赋值给 bind
财产或使用 connect()
. 每个线程也可以动态地重新绑定多次,就像常规的 MetaData
.
__init__
()¶构造ThreadLocalMetadata。
bind
¶此线程的绑定引擎或连接。
此属性可以被分配一个引擎或连接,或者分配一个字符串或url以自动为此绑定创建基本引擎 create_engine()
.
dispose
()¶在所有线程上下文中释放所有绑定引擎。
is_bound
()¶如果此线程有绑定,则为true。