此处列出了其他部分未涉及的关键ORM结构。
sqlalchemy.orm.state.
AttributeState
(state, key)¶提供与特定映射对象上的特定属性对应的检查接口。
这个 AttributeState
对象通过访问 InstanceState.attrs
特定的集合 InstanceState
::
from sqlalchemy import inspect
insp = inspect(some_mapped_object)
attr_state = insp.attrs.some_attribute
load_history
()¶返回电流 pre-flush 更改此属性的历史记录,通过 History
接口。
这种方法 will 如果卸载属性的值,则发出加载程序可调用文件。
注解
属性历史记录系统跟踪 每平基 . 每一次 Session
刷新后,每个属性的历史记录将重置为空。这个 Session
默认情况下,每次自动刷新 Query
被调用。有关如何控制此的选项,请参见 刷新 .
0.9.0 新版功能.
loaded_value
¶从数据库加载的此属性的当前值。
如果该值尚未加载,或者不在对象字典中,则不返回值。
value
¶返回此属性的值。
此操作相当于直接或通过 getattr()
,如果需要,将触发任何挂起的加载程序可调用文件。
sqlalchemy.orm.util.
CascadeOptions
¶基地: builtins.frozenset
跟踪发送到Relationship()的选项。层叠
sqlalchemy.orm.instrumentation.
ClassManager
(class_)¶基地: builtins.dict
在类级别跟踪状态信息。
__le__
¶继承 __le__
属性 dict
返回self<=value。
__lt__
¶继承 __lt__
属性 dict
返回self<value。
__ne__
¶继承 __ne__
属性 dict
回归自我!=值。
clear
() → None. Remove all items from D.¶继承 clear()
方法 dict
copy
() → a shallow copy of D¶继承 copy()
方法 dict
dispose
()¶把这个经理从班上除名。
fromkeys
()¶继承 fromkeys()
方法 dict
Create a new dictionary with keys from iterable and values set to value.
get
()¶继承 get()
方法 dict
Return the value for key if key is in the dictionary, else default.
has_parent
(state, key, optimistic=False)¶TODO
items
() → a set-like object providing a view on D's items¶继承 items()
方法 dict
keys
() → a set-like object providing a view on D's keys¶继承 keys()
方法 dict
manage
()¶将此实例标记为其类的管理器。
original_init
¶初始化自身。请参阅帮助(键入(self))以获得准确的签名。
pop
(k[, d]) → v, remove specified key and return the corresponding value.¶继承 pop()
方法 dict
如果找不到键,则返回d(如果给定),否则将引发keyError
popitem
() → (k, v), remove and return some (key, value) pair as a¶继承 popitem()
方法 dict
2元组;但如果d为空,则引发keyror。
setdefault
()¶继承 setdefault()
方法 dict
Insert key with a value of default if key is not in the dictionary.
Return the value for key if key is in the dictionary, else default.
state_getter
()¶返回(实例)->InstanceState可调用。
如果找不到实例的InstanceState,则“State Getter”可调用文件应引发keyError或attributeError。
unregister
()¶移除此ClassManager建立的所有工具。
update
([E, ]**F) → None. Update D from dict/iterable E and F.¶继承 update()
方法 dict
如果e存在并且有.keys()方法,那么对e:d中的k执行:操作 [k] = e [k] 如果e存在,并且缺少.keys()方法,则为:对于k,e:d中的v [k] =v在任何一种情况下,后面跟着:对于f:d中的k [k] = f [k]
values
() → an object providing a view on D's values¶继承 values()
方法 dict
sqlalchemy.orm.properties.
ColumnProperty
(*columns, **kwargs)¶基地: sqlalchemy.orm.interfaces.StrategizedProperty
描述与表列对应的对象属性。
公共构造函数是 orm.column_property()
功能。
Comparator
(prop, parentmapper, adapt_to_entity=None)¶基地: sqlalchemy.util.langhelpers.MemoizedSlots
, sqlalchemy.orm.interfaces.PropComparator
为生成布尔、比较和其他运算符 ColumnProperty
属性。
参见文档 PropComparator
简要概述。
__eq__
(other)¶继承 __eq__()
方法 ColumnOperators
实施 ==
操作符。
在列上下文中,生成子句 a = b
. 如果目标是 None
生产 a IS NULL
.
__le__
(other)¶继承 __le__()
方法 ColumnOperators
实施 <=
操作符。
在列上下文中,生成子句 a <= b
.
__lt__
(other)¶继承 __lt__()
方法 ColumnOperators
实施 <
操作符。
在列上下文中,生成子句 a < b
.
__ne__
(other)¶继承 __ne__()
方法 ColumnOperators
实施 !=
操作符。
在列上下文中,生成子句 a != b
. 如果目标是 None
生产 a IS NOT NULL
.
adapt_to_entity
(adapt_to_entity)¶返回此propComparator的副本,该副本将使用给定的 AliasedInsp
产生相应的表达式。
adapter
¶继承 adapter
属性 PropComparator
生成一个可调用文件,使列表达式适应此比较器的别名版本。
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 新版功能.
any
(criterion=None, **kwargs)¶继承 any()
方法 PropComparator
如果此集合包含符合给定条件的任何成员,则返回true。
通常执行 any()
是 RelationshipProperty.Comparator.any()
.
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 新版功能.
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 新版功能.
collate
(collation)¶继承 collate()
方法 ColumnOperators
产生一个 collate()
在给定排序规则字符串的情况下,对父对象执行子句。
参见
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"
在被传递到数据库之前。
desc
()¶继承 desc()
方法 ColumnOperators
产生一个 desc()
针对父对象的子句。
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"
在被传递到数据库之前。
has
(criterion=None, **kwargs)¶继承 has()
方法 PropComparator
如果此元素引用满足给定条件的成员,则返回true。
通常执行 has()
是 RelationshipProperty.Comparator.has()
.
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
标志设置为真。
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 新版功能.
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()
针对父对象的子句。
of_type
(class_)¶继承 of_type()
方法 PropComparator
根据多态子类重新定义此对象。
返回一个新的PropComparator,从中可以计算出进一步的条件。
例如。::
query.join(Company.employees.of_type(Engineer)).\
filter(Engineer.name=='foo')
class_¶ -- 一个类或映射器,指示条件将针对这个特定的子类。
参见
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)¶对参数进行运算。
这是最低级别的操作,提升 NotImplementedError
默认情况下。
在子类上覆盖此项可以允许将公共行为应用于所有操作。例如,重写 ColumnOperators
申请 func.lower()
左右两侧:
class MyComparator(ColumnOperators):
def operate(self, op, other):
return op(func.lower(self), func.lower(other))
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"
在被传递到数据库之前。
__eq__
¶继承 __eq__
属性 object
返回self==值。
__init__
(*columns, **kwargs)¶构建新的 ColumnProperty
对象。
此构造函数被镜像为公共API函数;请参见 column_property()
完整的用法和参数描述。
__le__
¶继承 __le__
属性 object
返回self<=value。
__lt__
¶继承 __lt__
属性 object
返回self<value。
__ne__
¶继承 __ne__
属性 object
回归自我!=值。
cascade_iterator
(type_, state, visited_instances=None, halt_on=None)¶从这个mapperproperty开始,循环访问与特定“cascade”的给定实例相关的实例。
返回迭代器3元组(实例、映射器、状态)。
请注意,在调用Cascade_迭代器之前,首先检查此MapperProperty上给定类型的“Cascade”集合。
此方法通常只适用于RelationshipProperty。
class_attribute
¶返回与此对应的类绑定描述符 MapperProperty
.
这基本上是一个 getattr()
调用:
return getattr(self.parent.class_, self.key)
即,如果 MapperProperty
被命名 addresses
,它映射到的类是 User
,此序列是可能的:
>>> from sqlalchemy import inspect
>>> mapper = inspect(User)
>>> addresses_property = mapper.attrs.addresses
>>> addresses_property.class_attribute is User.addresses
True
>>> User.addresses.property is addresses_property
True
create_row_processor
(context, path, mapper, result, adapter, populators)¶继承 create_row_processor()
方法 StrategizedProperty
生成行处理函数并附加到给定的填充器列表集。
do_init
()¶执行子类特定的初始化后映射器创建步骤。
这是由 MapperProperty
对象的init()方法。
expression
¶返回此ColumnProperty的主列或表达式。
extension_type
= symbol('NOT_EXTENSION')¶init
()¶继承 init()
方法 MapperProperty
在创建所有映射器之后调用,以组装映射器之间的关系并执行其他后期映射器创建初始化步骤。
instrument_class
(mapper)¶映射器调用该属性以启动由该映射器属性管理的类属性的检测。
这里的mapperproperty通常会调用attributes模块来设置instructedAttribute。
此步骤是设置InstrumentedAttribute的两个步骤中的第一个步骤,在映射器设置过程的早期调用。
第二步通常是init_class_属性步骤,通过post_instrument_class()钩子从strategizedproperty调用。此步骤将附加状态分配给InstrumentedAttribute(特别是“impl”),该属性是在MapperProperty确定需要执行哪种持久性管理(例如标量、对象、集合等)之后确定的。
merge
(session, source_state, source_dict, dest_state, dest_dict, load, _recursive, _resolve_conflict_map)¶合并此表示的属性 MapperProperty
从源对象到目标对象。
post_instrument_class
(mapper)¶继承 post_instrument_class()
方法 StrategizedProperty
执行init()完成后需要进行的检测调整。
给定的映射器是调用操作的映射器,在继承方案中,该映射器可能与self.parent不同;但是,映射器将始终至少是self.parent的子映射器。
此方法通常由StrategizedProperty使用,它将其委托给loaderStrategy.init_class_attribute()以对绑定到类的instructedAttribute执行最终设置。
set_parent
(parent, init)¶继承 set_parent()
方法 MapperProperty
设置引用此映射器属性的父映射器。
此方法被某些子类重写,以便在第一次知道映射器时执行额外的设置。
setup
(context, query_entity, path, adapter, **kwargs)¶继承 setup()
方法 StrategizedProperty
通过查询调用以构造SQL语句。
与目标映射器关联的每个映射器属性都处理查询上下文引用的语句,并根据需要添加列和/或条件。
sqlalchemy.orm.properties.
ComparableProperty
(comparator_factory, descriptor=None, doc=None, info=None)¶基地: sqlalchemy.orm.descriptor_props.DescriptorProperty
0.7 版后已移除: comparable_property()
已弃用,将在将来的版本中删除。请参阅 hybrid
延伸。
插入用于查询表达式的python属性。
__init__
(comparator_factory, descriptor=None, doc=None, info=None)¶构建新的 ComparableProperty
对象。
此构造函数被镜像为公共API函数;请参见 comparable_property()
完整的用法和参数描述。
sqlalchemy.orm.descriptor_props.
CompositeProperty
(class_, *attrs, **kwargs)¶基地: sqlalchemy.orm.descriptor_props.DescriptorProperty
定义一个“复合”映射属性,将列集合表示为一个属性。
CompositeProperty
是使用 composite()
功能。
参见
Comparator
(prop, parentmapper, adapt_to_entity=None)¶基地: sqlalchemy.orm.interfaces.PropComparator
为生成布尔、比较和其他运算符 CompositeProperty
属性。
参见中的示例 重新定义复合材料的比较操作 有关用法的概述,以及 PropComparator
.
CompositeBundle
(property_, expr)¶__init__
(class_, *attrs, **kwargs)¶构建新的 CompositeProperty
对象。
此构造函数被镜像为公共API函数;请参见 composite()
完整的用法和参数描述。
do_init
()¶在 CompositeProperty
已与其父映射器关联。
get_history
(state, dict_, passive=symbol('PASSIVE_OFF'))¶为使用attributes.get_history()的userland代码提供。
instrument_class
(mapper)¶映射器调用该属性以启动由该映射器属性管理的类属性的检测。
这里的mapperproperty通常会调用attributes模块来设置instructedAttribute。
此步骤是设置InstrumentedAttribute的两个步骤中的第一个步骤,在映射器设置过程的早期调用。
第二步通常是init_class_属性步骤,通过post_instrument_class()钩子从strategizedproperty调用。此步骤将附加状态分配给InstrumentedAttribute(特别是“impl”),该属性是在MapperProperty确定需要执行哪种持久性管理(例如标量、对象、集合等)之后确定的。
sqlalchemy.orm.attributes.
Event
(attribute_impl, op)¶在属性事件链的整个过程中传播的令牌。
作为事件源的指示器,还提供了控制跨属性操作链传播的方法。
这个 Event
对象作为 initiator
处理诸如 AttributeEvents.append()
, AttributeEvents.set()
和 AttributeEvents.remove()
.
这个 Event
对象当前由backref事件处理程序解释,用于控制操作在两个相互依赖的属性之间的传播。
0.9.0 新版功能.
sqlalchemy.orm.identity.
IdentityMap
¶check_modified
()¶如果存在任何InstanceStates已标记为“Modified”,则返回true。
sqlalchemy.orm.base.
InspectionAttr
¶应用于可以由返回的所有ORM对象的基类 inspect()
功能。
这里定义的属性允许使用简单的布尔检查来测试返回对象的基本事实。
虽然这里的布尔检查基本上与使用python isinstance()函数相同,但是这里的标志可以在不需要导入所有这些类的情况下使用,而且还可以在保持标志不变的情况下更改sqlachemy类系统,以实现前向兼容性。
extension_type
= symbol('NOT_EXTENSION')¶扩展类型(如果有)。默认为 interfaces.NOT_EXTENSION
is_aliased_class
= False¶如果此对象是 AliasedClass
.
is_attribute
= False¶如果此对象是python,则为true descriptor .
这可以指许多类型中的一种。通常是 QueryableAttribute
它代表 MapperProperty
. 但也可以是扩展类型,例如 AssociationProxy
或 hybrid_property
. 这个 InspectionAttr.extension_type
将引用标识特定子类型的常量。
is_clause_element
= False¶如果此对象是 ClauseElement
.
is_instance
= False¶如果此对象是 InstanceState
.
is_property
= False¶如果此对象是 MapperProperty
.
is_selectable
= False¶如果此对象是 Selectable
.
sqlalchemy.orm.base.
InspectionAttrInfo
¶基地: sqlalchemy.orm.base.InspectionAttr
添加 .info
属性到 InspectionAttr
.
原因 InspectionAttr
VS InspectionAttrInfo
前者与指定类的mixin兼容吗? __slots__
;这本质上是一个实现工件。
info
¶与对象关联的信息字典,允许用户定义的数据与此关联 InspectionAttr
.
字典在第一次访问时生成。或者,可以将其指定为 column_property()
, relationship()
或 composite()
功能。
在 1.0.0 版更改: MapperProperty.info
也可以通过 InspectionAttrInfo.info
属性,以便它可以应用于更广泛的ORM和扩展构造。
sqlalchemy.orm.state.
InstanceState
(obj, manager)¶基地: sqlalchemy.orm.base.InspectionAttrInfo
在实例级别跟踪状态信息。
这个 InstanceState
是SQLAlchemy窗体用来跟踪对象状态的键对象;它是在对象实例化时创建的,通常是由于 instrumentation 哪个SQLAlchemy适用于 __init__()
类的方法。
InstanceState
也是一个半公共对象,可用于运行时检查映射实例的状态,包括特定实例中的当前状态等信息 Session
以及有关单个属性的数据的详细信息。公共API以获取 InstanceState
对象是使用 inspect()
系统:
>>> from sqlalchemy import inspect
>>> insp = inspect(some_mapped_object)
参见
attrs
¶返回表示映射对象上每个属性的命名空间,包括其当前值和历史记录。
返回的对象是 AttributeState
. 此对象允许检查属性中的当前数据以及自上次刷新以来的属性历史记录。
callables
= ()¶一个可以关联每状态加载程序可调用的命名空间。
在SQLAlchemy 1.0中,这仅用于通过查询选项设置的惰性加载程序/延迟加载程序。
以前,可调用文件还用于通过在此字典中存储指向InstanceState本身的链接来指示过期的属性。此角色现在由过期的属性集处理。
deleted
¶如果对象是 deleted .
保证处于已删除状态的对象不在 Session.identity_map
它的父母 Session
;但是,如果回滚会话的事务,则对象将恢复到持久状态和标识映射。
注解
这个 InstanceState.deleted
属性是指在“持久”和“分离”状态之间发生的对象的特定状态;一旦对象 detached , the InstanceState.deleted
属性 不再返回真 ;以检测是否已删除状态,无论对象是否与 Session
使用 InstanceState.was_deleted
访问器。
dict
¶返回对象使用的实例dict。
在正常情况下,这始终是 __dict__
映射对象的属性,除非配置了其他检测系统。
在实际对象被垃圾收集的情况下,此访问器返回一个空字典。
expired_attributes
= None¶“过期”的一组键,由管理器的延迟标量加载程序加载,假定没有挂起的更改。
另请参阅 unmodified
刷新操作发生时与此集合相交的集合。
has_identity
¶返回 True
如果此对象具有标识密钥。
它的值应始终与表达式的值相同 state.persistent or state.detached
.
identity
¶返回映射对象的映射标识。这是ORM持久化的主键标识,可以直接传递给 Query.get()
.
返回 None
如果对象没有主键标识。
identity_key
¶返回映射对象的标识键。
这是用于在 Session.identity_map
映射。它包含返回的标识 identity
在它里面。
object
¶返回由此表示的映射对象 InstanceState
.
persistent
¶如果对象是 persistent .
处于持久状态的对象保证位于 Session.identity_map
它的父母 Session
.
在 1.1 版更改: 这个 InstanceState.persistent
对于在刷新过程中被“删除”的对象,访问器不再返回true;请使用 InstanceState.deleted
用于检测此状态的访问器。这允许“持久”状态确保身份映射中的成员身份。
session
¶归还拥有者 Session
在这种情况下,或 None
如果没有。
注意,这里的结果在某些情况下可能是 不同的 从那 obj in session
;已删除的对象将报告为非 in session
但是,如果事务仍在进行中,则此属性仍将引用该会话。只有当事务完成时,对象才会在正常情况下完全分离。
unloaded
¶返回一组没有加载值的键。
这包括过期的属性和任何其他从未填充或修改的属性。
unloaded_expirable
¶返回一组没有加载值的键。
这包括过期的属性和任何其他从未填充或修改的属性。
unmodified
¶返回没有未提交更改的密钥集
unmodified_intersection
(keys)¶返回self.unmodified.intersection(keys)。
was_deleted
¶如果此对象当前或以前处于“已删除”状态且尚未还原为持久性,则返回true。
一旦对象在flush中被删除,此标志将返回true。当对象被显式地或通过事务提交从会话中删除并进入“分离”状态时,此标志将继续报告为真。
1.1 新版功能: -添加了本地方法形式 orm.util.was_deleted()
.
sqlalchemy.orm.attributes.
InstrumentedAttribute
(class_, key, impl=None, comparator=None, parententity=None, of_type=None)¶基地: sqlalchemy.orm.attributes.QueryableAttribute
类绑定的插入指令的属性,它添加了基本的 descriptor 方法。
见 QueryableAttribute
对于大多数功能的描述。
__delete__
(instance)¶__get__
(instance, owner)¶__set__
(instance, value)¶sqlalchemy.orm.interfaces.
MANYTOONE
= symbol('MANYTOONE')¶指示多对一方向 relationship()
.
此符号通常由内部使用,但可能在某些API功能中公开。
sqlalchemy.orm.interfaces.
MANYTOMANY
= symbol('MANYTOMANY')¶指示的多对多方向 relationship()
.
此符号通常由内部使用,但可能在某些API功能中公开。
sqlalchemy.orm.interfaces.
MapperProperty
¶基地: sqlalchemy.orm.base._MappedAttribute
, sqlalchemy.orm.base.InspectionAttr
, sqlalchemy.util.langhelpers.MemoizedSlots
表示由映射的特定类属性 Mapper
.
最常见的 MapperProperty
是映射的 Column
,在映射中表示为 ColumnProperty
以及对由生成的另一类的引用 relationship()
,在映射中表示为 RelationshipProperty
.
info
¶与对象关联的信息字典,允许用户定义的数据与此关联 InspectionAttr
.
字典在第一次访问时生成。或者,可以将其指定为 column_property()
, relationship()
或 composite()
功能。
在 1.0.0 版更改: InspectionAttr.info
移居 MapperProperty
这样它就可以应用于更广泛的ORM和扩展结构。
cascade
= frozenset({})¶“cascade”属性名称集。
在调用“cascadeu迭代器”方法之前,检查此集合。
集合通常只适用于RelationshipProperty。
cascade_iterator
(type_, state, visited_instances=None, halt_on=None)¶从这个mapperproperty开始,循环访问与特定“cascade”的给定实例相关的实例。
返回迭代器3元组(实例、映射器、状态)。
请注意,在调用Cascade_迭代器之前,首先检查此MapperProperty上给定类型的“Cascade”集合。
此方法通常只适用于RelationshipProperty。
class_attribute
¶返回与此对应的类绑定描述符 MapperProperty
.
这基本上是一个 getattr()
调用:
return getattr(self.parent.class_, self.key)
即,如果 MapperProperty
被命名 addresses
,它映射到的类是 User
,此序列是可能的:
>>> from sqlalchemy import inspect
>>> mapper = inspect(User)
>>> addresses_property = mapper.attrs.addresses
>>> addresses_property.class_attribute is User.addresses
True
>>> User.addresses.property is addresses_property
True
create_row_processor
(context, path, mapper, result, adapter, populators)¶生成行处理函数并附加到给定的填充器列表集。
do_init
()¶执行子类特定的初始化后映射器创建步骤。
这是由 MapperProperty
对象的init()方法。
init
()¶在创建所有映射器之后调用,以组装映射器之间的关系并执行其他后期映射器创建初始化步骤。
instrument_class
(mapper)¶映射器调用该属性以启动由该映射器属性管理的类属性的检测。
这里的mapperproperty通常会调用attributes模块来设置instructedAttribute。
此步骤是设置InstrumentedAttribute的两个步骤中的第一个步骤,在映射器设置过程的早期调用。
第二步通常是init_class_属性步骤,通过post_instrument_class()钩子从strategizedproperty调用。此步骤将附加状态分配给InstrumentedAttribute(特别是“impl”),该属性是在MapperProperty确定需要执行哪种持久性管理(例如标量、对象、集合等)之后确定的。
is_property
= True¶inspectionattr接口的一部分;说明此对象是映射器属性。
merge
(session, source_state, source_dict, dest_state, dest_dict, load, _recursive, _resolve_conflict_map)¶合并此表示的属性 MapperProperty
从源对象到目标对象。
post_instrument_class
(mapper)¶执行init()完成后需要进行的检测调整。
给定的映射器是调用操作的映射器,在继承方案中,该映射器可能与self.parent不同;但是,映射器将始终至少是self.parent的子映射器。
此方法通常由StrategizedProperty使用,它将其委托给loaderStrategy.init_class_attribute()以对绑定到类的instructedAttribute执行最终设置。
set_parent
(parent, init)¶设置引用此映射器属性的父映射器。
此方法被某些子类重写,以便在第一次知道映射器时执行额外的设置。
setup
(context, query_entity, path, adapter, **kwargs)¶通过查询调用以构造SQL语句。
与目标映射器关联的每个映射器属性都处理查询上下文引用的语句,并根据需要添加列和/或条件。
sqlalchemy.orm.interfaces.
NOT_EXTENSION
= symbol('NOT_EXTENSION')¶符号表示 InspectionAttr
这不是SQLAlchemy.ext的一部分。
分配给 InspectionAttr.extension_type
属性。
sqlalchemy.orm.interfaces.
ONETOMANY
= symbol('ONETOMANY')¶表示一对多方向 relationship()
.
此符号通常由内部使用,但可能在某些API功能中公开。
sqlalchemy.orm.interfaces.
PropComparator
(prop, parentmapper, adapt_to_entity=None)¶基地: sqlalchemy.sql.operators.ColumnOperators
为定义SQL运算符 MapperProperty
对象。
SQLAlchemy允许在核心和ORM级别重新定义运算符。 PropComparator
是ORM级操作的运算符重定义的基类,包括 ColumnProperty
, RelationshipProperty
和 CompositeProperty
.
注解
随着SQLAlchemy 0.7中引入的混合属性的出现,以及SQLAlchemy 0.8中的核心级运算符重新定义,用户定义的用例 PropComparator
实例非常罕见。见 混合属性 以及 重新定义和创建新的运算符 .
用户定义的子类 PropComparator
可以创建。内置的python比较和数学运算符方法,例如 operators.ColumnOperators.__eq__()
, operators.ColumnOperators.__lt__()
和 operators.ColumnOperators.__add__()
可以重写以提供新的运算符行为。习俗 PropComparator
传递给 MapperProperty
实例通过 comparator_factory
争论。在每种情况下, PropComparator
应使用:
# definition of custom PropComparator subclasses
from sqlalchemy.orm.properties import \
ColumnProperty,\
CompositeProperty,\
RelationshipProperty
class MyColumnComparator(ColumnProperty.Comparator):
def __eq__(self, other):
return self.__clause_element__() == other
class MyRelationshipComparator(RelationshipProperty.Comparator):
def any(self, expression):
"define the 'any' operation"
# ...
class MyCompositeComparator(CompositeProperty.Comparator):
def __gt__(self, other):
"redefine the 'greater than' operation"
return sql.and_(*[a>b for a, b in
zip(self.__clause_element__().clauses,
other.__composite_values__())])
# application of custom PropComparator subclasses
from sqlalchemy.orm import column_property, relationship, composite
from sqlalchemy import Column, String
class SomeMappedClass(Base):
some_column = column_property(Column("some_column", String),
comparator_factory=MyColumnComparator)
some_relationship = relationship(SomeOtherClass,
comparator_factory=MyRelationshipComparator)
some_composite = composite(
Column("a", String), Column("b", String),
comparator_factory=MyCompositeComparator
)
注意,对于列级运算符重新定义,通常使用 TypeEngine.comparator_factory
属性。见 重新定义和创建新的运算符 更多细节。
__eq__
(other)¶继承 __eq__()
方法 ColumnOperators
实施 ==
操作符。
在列上下文中,生成子句 a = b
. 如果目标是 None
生产 a IS NULL
.
__le__
(other)¶继承 __le__()
方法 ColumnOperators
实施 <=
操作符。
在列上下文中,生成子句 a <= b
.
__lt__
(other)¶继承 __lt__()
方法 ColumnOperators
实施 <
操作符。
在列上下文中,生成子句 a < b
.
__ne__
(other)¶继承 __ne__()
方法 ColumnOperators
实施 !=
操作符。
在列上下文中,生成子句 a != b
. 如果目标是 None
生产 a IS NOT NULL
.
adapt_to_entity
(adapt_to_entity)¶返回此propComparator的副本,该副本将使用给定的 AliasedInsp
产生相应的表达式。
adapter
¶生成一个可调用文件,使列表达式适应此比较器的别名版本。
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 新版功能.
any
(criterion=None, **kwargs)¶如果此集合包含符合给定条件的任何成员,则返回true。
通常执行 any()
是 RelationshipProperty.Comparator.any()
.
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 新版功能.
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 新版功能.
collate
(collation)¶继承 collate()
方法 ColumnOperators
产生一个 collate()
在给定排序规则字符串的情况下,对父对象执行子句。
参见
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"
在被传递到数据库之前。
desc
()¶继承 desc()
方法 ColumnOperators
产生一个 desc()
针对父对象的子句。
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"
在被传递到数据库之前。
has
(criterion=None, **kwargs)¶如果此元素引用满足给定条件的成员,则返回true。
通常执行 has()
是 RelationshipProperty.Comparator.has()
.
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
标志设置为真。
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 新版功能.
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()
针对父对象的子句。
of_type
(class_)¶根据多态子类重新定义此对象。
返回一个新的PropComparator,从中可以计算出进一步的条件。
例如。::
query.join(Company.employees.of_type(Engineer)).\
filter(Engineer.name=='foo')
class_¶ -- 一个类或映射器,指示条件将针对这个特定的子类。
参见
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)¶对参数进行运算。
这是最低级别的操作,提升 NotImplementedError
默认情况下。
在子类上覆盖此项可以允许将公共行为应用于所有操作。例如,重写 ColumnOperators
申请 func.lower()
左右两侧:
class MyComparator(ColumnOperators):
def operate(self, op, other):
return op(func.lower(self), func.lower(other))
reverse_operate
(op, other, **kwargs)¶继承 reverse_operate()
方法 Operators
对参数进行反向运算。
用法与 operate()
.
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.orm.properties.
RelationshipProperty
(argument, secondary=None, primaryjoin=None, secondaryjoin=None, foreign_keys=None, uselist=None, order_by=False, backref=None, back_populates=None, post_update=False, cascade=False, extension=None, viewonly=False, lazy='select', collection_class=None, passive_deletes=False, passive_updates=True, remote_side=None, enable_typechecks=True, join_depth=None, comparator_factory=None, single_parent=False, innerjoin=False, distinct_target_key=None, doc=None, active_history=False, cascade_backrefs=True, load_on_pending=False, bake_queries=True, _local_remote_pairs=None, query_class=None, info=None, omit_join=None)¶基地: sqlalchemy.orm.interfaces.StrategizedProperty
描述一个对象属性,该属性包含与相关数据库表对应的单个项或项列表。
公共构造函数是 orm.relationship()
功能。
参见
Comparator
(prop, parentmapper, adapt_to_entity=None, of_type=None)¶基地: sqlalchemy.orm.interfaces.PropComparator
为生成布尔、比较和其他运算符 RelationshipProperty
属性。
参见文档 PropComparator
有关ORM级运算符定义的简要概述。
参见
__eq__
(other)¶实施 ==
操作符。
在多对一的上下文中,例如:
MyClass.some_prop == <some object>
这通常会产生一个子句,例如:
mytable.related_id == <some id>
<some id>
是给定对象的主键。
这个 ==
运算符为非多对一比较提供部分功能:
不支持与集合进行比较。使用 contains()
.
与标量一对多相比,将生成一个子句,将父级中的目标列与给定目标进行比较。
与标量“多对多”相比,关联表的别名也将呈现出来,形成作为查询主体一部分的自然联接。对于超出简单比较和连词的查询(如使用或的查询),这将不起作用。使用显式联接、outerjoin或 has()
对于更全面的非多对一标量成员测试。
对比 None
在一对多或多对多上下文中给出,将产生一个不存在子句。
__init__
(prop, parentmapper, adapt_to_entity=None, of_type=None)¶建设 RelationshipProperty.Comparator
是ORM属性机制的内部机制。
__le__
(other)¶继承 __le__()
方法 ColumnOperators
实施 <=
操作符。
在列上下文中,生成子句 a <= b
.
__lt__
(other)¶继承 __lt__()
方法 ColumnOperators
实施 <
操作符。
在列上下文中,生成子句 a < b
.
__ne__
(other)¶实施 !=
操作符。
在多对一的上下文中,例如:
MyClass.some_prop != <some object>
这通常会产生一个子句,例如:
mytable.related_id != <some id>
<some id>
是给定对象的主键。
这个 !=
运算符为非多对一比较提供部分功能:
不支持与集合进行比较。使用 contains()
与 not_()
.
与标量一对多相比,将生成一个子句,将父级中的目标列与给定目标进行比较。
与标量“多对多”相比,关联表的别名也将呈现出来,形成作为查询主体一部分的自然联接。对于超出简单比较和连词的查询(如使用或的查询),这将不起作用。使用显式联接、outerjoin或 has()
与 not_()
对于更全面的非多对一标量成员测试。
对比 None
在一对多或多对多上下文中给出,生成一个exists子句。
adapt_to_entity
(adapt_to_entity)¶返回此propComparator的副本,该副本将使用给定的 AliasedInsp
产生相应的表达式。
adapter
¶继承 adapter
属性 PropComparator
生成一个可调用文件,使列表达式适应此比较器的别名版本。
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 新版功能.
any
(criterion=None, **kwargs)¶生成一个表达式,使用exists根据特定条件测试集合。
像这样的表达:
session.query(MyClass).filter(
MyClass.somereference.any(SomeRelated.x==2)
)
将生成如下查询:
SELECT * FROM my_table WHERE
EXISTS (SELECT 1 FROM related WHERE related.my_id=my_table.id
AND related.x=2)
因为 any()
使用关联子查询时,与大型目标表相比,它的性能不如使用联接时好。
any()
对于测试空集合特别有用:
session.query(MyClass).filter(
~MyClass.somereference.any()
)
将生产:
SELECT * FROM my_table WHERE
NOT EXISTS (SELECT 1 FROM related WHERE
related.my_id=my_table.id)
any()
仅对集合有效,即 relationship()
那有 uselist=True
. 对于标量引用,请使用 has()
.
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 新版功能.
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 新版功能.
collate
(collation)¶继承 collate()
方法 ColumnOperators
产生一个 collate()
在给定排序规则字符串的情况下,对父对象执行子句。
参见
concat
(other)¶继承 concat()
方法 ColumnOperators
实现“concat”运算符。
在列上下文中,生成子句 a || b
或使用 concat()
mysql上的操作符。
contains
(other, **kwargs)¶返回一个简单表达式,用于测试集合是否包含特定项。
contains()
仅对集合有效,即 relationship()
实现一对多或多对多 uselist=True
.
在简单的一对多上下文中使用时,表达式如下:
MyClass.contains(other)
生成如下子句:
mytable.id == <some id>
<some id>
上的外键属性的值 other
它引用其父对象的主键。由此可知 contains()
与简单的一对多操作一起使用时非常有用。
对于多对多的操作, contains()
有更多的警告。关联表将在语句中呈现,生成一个“隐式”联接,即在FROM子句中包含多个表,这些表在WHERE子句中相等:
query(MyClass).filter(MyClass.contains(other))
生成如下查询:
SELECT * FROM my_table, my_association_table AS
my_association_table_1 WHERE
my_table.id = my_association_table_1.parent_id
AND my_association_table_1.child_id = <some id>
<some id>
将是 other
. 从上面可以清楚地看到 contains()
将 not 当用于超越简单和连词(如多个连词)的查询时,使用多对多集合 contains()
由或联接的表达式。在这种情况下,将需要使用子查询或显式的“外部联接”。见 any()
对于性能较低的替代使用,请参阅 Query.outerjoin()
以及 使用联接查询 有关构造外部联接的详细信息。
desc
()¶继承 desc()
方法 ColumnOperators
产生一个 desc()
针对父对象的子句。
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"
在被传递到数据库之前。
entity
¶此引用的目标实体 RelationshipProperty.Comparator
.
这不是一个 Mapper
或 AliasedInsp
对象。
这是 relationship()
.
has
(criterion=None, **kwargs)¶生成一个表达式,使用exists根据特定条件测试标量引用。
像这样的表达:
session.query(MyClass).filter(
MyClass.somereference.has(SomeRelated.x==2)
)
将生成如下查询:
SELECT * FROM my_table WHERE
EXISTS (SELECT 1 FROM related WHERE
related.id==my_table.related_id AND related.x=2)
因为 has()
使用关联子查询时,与大型目标表相比,它的性能不如使用联接时好。
has()
仅对标量引用有效,即 relationship()
那有 uselist=False
. 对于集合引用,请使用 any()
.
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子句-这不是为实现 relationship()
-此时基于属性。
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 新版功能.
like
(other, escape=None)¶继承 like()
方法 ColumnOperators
实施 like
操作符。
在列上下文中,生成表达式::
a LIKE other
例如。::
stmt = select([sometable]).\
where(sometable.c.column.like("%foobar%"))
mapper
¶目标 Mapper
由此引用 RelationshipProperty.Comparator
.
这是 relationship()
.
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()
针对父对象的子句。
of_type
(cls)¶根据多态子类重新定义此对象。
见 PropComparator.of_type()
举个例子。
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)¶对参数进行运算。
这是最低级别的操作,提升 NotImplementedError
默认情况下。
在子类上覆盖此项可以允许将公共行为应用于所有操作。例如,重写 ColumnOperators
申请 func.lower()
左右两侧:
class MyComparator(ColumnOperators):
def operate(self, op, other):
return op(func.lower(self), func.lower(other))
reverse_operate
(op, other, **kwargs)¶继承 reverse_operate()
方法 Operators
对参数进行反向运算。
用法与 operate()
.
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"
在被传递到数据库之前。
__eq__
¶继承 __eq__
属性 object
返回self==值。
__init__
(argument, secondary=None, primaryjoin=None, secondaryjoin=None, foreign_keys=None, uselist=None, order_by=False, backref=None, back_populates=None, post_update=False, cascade=False, extension=None, viewonly=False, lazy='select', collection_class=None, passive_deletes=False, passive_updates=True, remote_side=None, enable_typechecks=True, join_depth=None, comparator_factory=None, single_parent=False, innerjoin=False, distinct_target_key=None, doc=None, active_history=False, cascade_backrefs=True, load_on_pending=False, bake_queries=True, _local_remote_pairs=None, query_class=None, info=None, omit_join=None)¶构建新的 RelationshipProperty
对象。
此构造函数被镜像为公共API函数;请参见 relationship()
完整的用法和参数描述。
__le__
¶继承 __le__
属性 object
返回self<=value。
__lt__
¶继承 __lt__
属性 object
返回self<value。
__ne__
¶继承 __ne__
属性 object
回归自我!=值。
cascade
¶返回此的当前级联设置 RelationshipProperty
.
cascade_iterator
(type_, state, dict_, visited_states, halt_on=None)¶从这个mapperproperty开始,循环访问与特定“cascade”的给定实例相关的实例。
返回迭代器3元组(实例、映射器、状态)。
请注意,在调用Cascade_迭代器之前,首先检查此MapperProperty上给定类型的“Cascade”集合。
此方法通常只适用于RelationshipProperty。
class_attribute
¶返回与此对应的类绑定描述符 MapperProperty
.
这基本上是一个 getattr()
调用:
return getattr(self.parent.class_, self.key)
即,如果 MapperProperty
被命名 addresses
,它映射到的类是 User
,此序列是可能的:
>>> from sqlalchemy import inspect
>>> mapper = inspect(User)
>>> addresses_property = mapper.attrs.addresses
>>> addresses_property.class_attribute is User.addresses
True
>>> User.addresses.property is addresses_property
True
create_row_processor
(context, path, mapper, result, adapter, populators)¶继承 create_row_processor()
方法 StrategizedProperty
生成行处理函数并附加到给定的填充器列表集。
do_init
()¶执行子类特定的初始化后映射器创建步骤。
这是由 MapperProperty
对象的init()方法。
entity
¶返回目标映射实体,该实体是所引用的类或别名类tha的inspect()。
extension_type
= symbol('NOT_EXTENSION')¶init
()¶继承 init()
方法 MapperProperty
在创建所有映射器之后调用,以组装映射器之间的关系并执行其他后期映射器创建初始化步骤。
instrument_class
(mapper)¶映射器调用该属性以启动由该映射器属性管理的类属性的检测。
这里的mapperproperty通常会调用attributes模块来设置instructedAttribute。
此步骤是设置InstrumentedAttribute的两个步骤中的第一个步骤,在映射器设置过程的早期调用。
第二步通常是init_class_属性步骤,通过post_instrument_class()钩子从strategizedproperty调用。此步骤将附加状态分配给InstrumentedAttribute(特别是“impl”),该属性是在MapperProperty确定需要执行哪种持久性管理(例如标量、对象、集合等)之后确定的。
mapper
¶返回目标 Mapper
为此 RelationshipProperty
.
这是一个懒惰的初始化静态属性。
merge
(session, source_state, source_dict, dest_state, dest_dict, load, _recursive, _resolve_conflict_map)¶合并此表示的属性 MapperProperty
从源对象到目标对象。
post_instrument_class
(mapper)¶继承 post_instrument_class()
方法 StrategizedProperty
执行init()完成后需要进行的检测调整。
给定的映射器是调用操作的映射器,在继承方案中,该映射器可能与self.parent不同;但是,映射器将始终至少是self.parent的子映射器。
此方法通常由StrategizedProperty使用,它将其委托给loaderStrategy.init_class_attribute()以对绑定到类的instructedAttribute执行最终设置。
set_parent
(parent, init)¶继承 set_parent()
方法 MapperProperty
设置引用此映射器属性的父映射器。
此方法被某些子类重写,以便在第一次知道映射器时执行额外的设置。
setup
(context, query_entity, path, adapter, **kwargs)¶继承 setup()
方法 StrategizedProperty
通过查询调用以构造SQL语句。
与目标映射器关联的每个映射器属性都处理查询上下文引用的语句,并根据需要添加列和/或条件。
sqlalchemy.orm.descriptor_props.
SynonymProperty
(name, map_column=None, descriptor=None, comparator_factory=None, doc=None, info=None)¶基地: sqlalchemy.orm.descriptor_props.DescriptorProperty
__eq__
¶继承 __eq__
属性 object
返回self==值。
__init__
(name, map_column=None, descriptor=None, comparator_factory=None, doc=None, info=None)¶构建新的 SynonymProperty
对象。
此构造函数被镜像为公共API函数;请参见 synonym()
完整的用法和参数描述。
__le__
¶继承 __le__
属性 object
返回self<=value。
__lt__
¶继承 __lt__
属性 object
返回self<value。
__ne__
¶继承 __ne__
属性 object
回归自我!=值。
cascade_iterator
(type_, state, visited_instances=None, halt_on=None)¶从这个mapperproperty开始,循环访问与特定“cascade”的给定实例相关的实例。
返回迭代器3元组(实例、映射器、状态)。
请注意,在调用Cascade_迭代器之前,首先检查此MapperProperty上给定类型的“Cascade”集合。
此方法通常只适用于RelationshipProperty。
class_attribute
¶返回与此对应的类绑定描述符 MapperProperty
.
这基本上是一个 getattr()
调用:
return getattr(self.parent.class_, self.key)
即,如果 MapperProperty
被命名 addresses
,它映射到的类是 User
,此序列是可能的:
>>> from sqlalchemy import inspect
>>> mapper = inspect(User)
>>> addresses_property = mapper.attrs.addresses
>>> addresses_property.class_attribute is User.addresses
True
>>> User.addresses.property is addresses_property
True
create_row_processor
(context, path, mapper, result, adapter, populators)¶生成行处理函数并附加到给定的填充器列表集。
do_init
()¶继承 do_init()
方法 MapperProperty
执行子类特定的初始化后映射器创建步骤。
这是由 MapperProperty
对象的init()方法。
extension_type
= symbol('NOT_EXTENSION')¶init
()¶继承 init()
方法 MapperProperty
在创建所有映射器之后调用,以组装映射器之间的关系并执行其他后期映射器创建初始化步骤。
instrument_class
(mapper)¶继承 instrument_class()
方法 DescriptorProperty
映射器调用该属性以启动由该映射器属性管理的类属性的检测。
这里的mapperproperty通常会调用attributes模块来设置instructedAttribute。
此步骤是设置InstrumentedAttribute的两个步骤中的第一个步骤,在映射器设置过程的早期调用。
第二步通常是init_class_属性步骤,通过post_instrument_class()钩子从strategizedproperty调用。此步骤将附加状态分配给InstrumentedAttribute(特别是“impl”),该属性是在MapperProperty确定需要执行哪种持久性管理(例如标量、对象、集合等)之后确定的。
merge
(session, source_state, source_dict, dest_state, dest_dict, load, _recursive, _resolve_conflict_map)¶继承 merge()
方法 MapperProperty
合并此表示的属性 MapperProperty
从源对象到目标对象。
post_instrument_class
(mapper)¶执行init()完成后需要进行的检测调整。
给定的映射器是调用操作的映射器,在继承方案中,该映射器可能与self.parent不同;但是,映射器将始终至少是self.parent的子映射器。
此方法通常由StrategizedProperty使用,它将其委托给loaderStrategy.init_class_attribute()以对绑定到类的instructedAttribute执行最终设置。
set_parent
(parent, init)¶设置引用此映射器属性的父映射器。
此方法被某些子类重写,以便在第一次知道映射器时执行额外的设置。
setup
(context, query_entity, path, adapter, **kwargs)¶继承 setup()
方法 MapperProperty
通过查询调用以构造SQL语句。
与目标映射器关联的每个映射器属性都处理查询上下文引用的语句,并根据需要添加列和/或条件。
sqlalchemy.orm.query.
QueryContext
(query)¶sqlalchemy.orm.attributes.
QueryableAttribute
(class_, key, impl=None, comparator=None, parententity=None, of_type=None)¶基地: sqlalchemy.orm.base._MappedAttribute
, sqlalchemy.orm.base.InspectionAttr
, sqlalchemy.orm.interfaces.PropComparator
基类 descriptor 代表 MapperProperty
对象。实际 MapperProperty
可通过 QueryableAttribute.property
属性。
__eq__
(other)¶继承 __eq__()
方法 ColumnOperators
实施 ==
操作符。
在列上下文中,生成子句 a = b
. 如果目标是 None
生产 a IS NULL
.
__le__
(other)¶继承 __le__()
方法 ColumnOperators
实施 <=
操作符。
在列上下文中,生成子句 a <= b
.
__lt__
(other)¶继承 __lt__()
方法 ColumnOperators
实施 <
操作符。
在列上下文中,生成子句 a < b
.
__ne__
(other)¶继承 __ne__()
方法 ColumnOperators
实施 !=
操作符。
在列上下文中,生成子句 a != b
. 如果目标是 None
生产 a IS NOT NULL
.
adapt_to_entity
(adapt_to_entity)¶返回此propComparator的副本,该副本将使用给定的 AliasedInsp
产生相应的表达式。
adapter
¶继承 adapter
属性 PropComparator
生成一个可调用文件,使列表达式适应此比较器的别名版本。
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 新版功能.
any
(criterion=None, **kwargs)¶继承 any()
方法 PropComparator
如果此集合包含符合给定条件的任何成员,则返回true。
通常执行 any()
是 RelationshipProperty.Comparator.any()
.
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 新版功能.
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 新版功能.
collate
(collation)¶继承 collate()
方法 ColumnOperators
产生一个 collate()
在给定排序规则字符串的情况下,对父对象执行子句。
参见
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"
在被传递到数据库之前。
desc
()¶继承 desc()
方法 ColumnOperators
产生一个 desc()
针对父对象的子句。
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"
在被传递到数据库之前。
extension_type
= symbol('NOT_EXTENSION')¶has
(criterion=None, **kwargs)¶继承 has()
方法 PropComparator
如果此元素引用满足给定条件的成员,则返回true。
通常执行 has()
是 RelationshipProperty.Comparator.has()
.
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
¶返回基础SQL元素的“info”字典。
这里的行为如下:
如果属性是列映射属性,即 ColumnProperty
,直接映射到架构级别 Column
对象,此属性将返回 SchemaItem.info
与核心级别相关联的字典 Column
对象。
如果属性是 ColumnProperty
但映射到除 Column
,该属性将引用 MapperProperty.info
与直接关联的字典 ColumnProperty
,假定SQL表达式本身没有自己的 .info
属性(应该是这种情况,除非用户定义的SQL构造已经定义了属性)。
如果属性引用任何其他类型的 MapperProperty
包括 RelationshipProperty
,该属性将引用 MapperProperty.info
与之相关联的词典 MapperProperty
.
访问 MapperProperty.info
字典 MapperProperty
无条件,包括 ColumnProperty
这与 schema.Column
,可以使用 QueryableAttribute.property
属性为 MyClass.someattribute.property.info
.
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 新版功能.
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()
针对父对象的子句。
of_type
(cls)¶根据多态子类重新定义此对象。
返回一个新的PropComparator,从中可以计算出进一步的条件。
例如。::
query.join(Company.employees.of_type(Engineer)).\
filter(Engineer.name=='foo')
class_¶ -- 一个类或映射器,指示条件将针对这个特定的子类。
参见
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)¶对参数进行运算。
这是最低级别的操作,提升 NotImplementedError
默认情况下。
在子类上覆盖此项可以允许将公共行为应用于所有操作。例如,重写 ColumnOperators
申请 func.lower()
左右两侧:
class MyComparator(ColumnOperators):
def operate(self, op, other):
return op(func.lower(self), func.lower(other))
parent
¶返回表示父级的检查实例。
这将是 Mapper
或 AliasedInsp
,取决于与此属性关联的父实体的性质。
property
¶返回 MapperProperty
与此关联 QueryableAttribute
.
这里的返回值通常是 ColumnProperty
或 RelationshipProperty
.
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.orm.session.
UOWTransaction
(session)¶filter_states_for_dep
(dep, states)¶将给定的InstanceStates列表筛选为与给定DependencyProcessor相关的列表。
finalize_flush_changes
()¶成功刷新()后,将处理的对象标记为干净/已删除。
在execute()方法成功且事务已提交之后,将在flush()方法中调用此方法。
get_attribute_history
(state, key, passive=symbol('PASSIVE_NO_INITIALIZE'))¶facade to attributes.get_state_history(),包括结果缓存。
is_deleted
(state)¶如果给定状态在此UOWTransaction中标记为已删除,则返回true。
remove_state_actions
(state)¶从UOWTransaction中删除状态的挂起操作。
was_already_deleted
(state)¶如果给定状态已过期并且以前已被删除,则返回true。