ORM内构件¶

此处列出了其他部分未涉及的关键ORM结构。

class 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
history

返回电流 pre-flush 更改此属性的历史记录,通过 History 接口。

这种方法会 not 如果卸载属性的值,则发出加载程序可调用文件。

注解

属性历史记录系统跟踪 每平基 . 每一次 Session 刷新后,每个属性的历史记录将重置为空。这个 Session 默认情况下,每次自动刷新 Query 被调用。有关如何控制此的选项,请参见 刷新 .

参见

AttributeState.load_history() -如果值不在本地,则使用加载程序可调用文件检索历史记录。

attributes.get_history() -基础函数

load_history()

返回电流 pre-flush 更改此属性的历史记录,通过 History 接口。

这种方法 will 如果卸载属性的值,则发出加载程序可调用文件。

注解

属性历史记录系统跟踪 每平基 . 每一次 Session 刷新后,每个属性的历史记录将重置为空。这个 Session 默认情况下,每次自动刷新 Query 被调用。有关如何控制此的选项,请参见 刷新 .

0.9.0 新版功能.

loaded_value

从数据库加载的此属性的当前值。

如果该值尚未加载,或者不在对象字典中,则不返回值。

value

返回此属性的值。

此操作相当于直接或通过 getattr() ,如果需要,将触发任何挂起的加载程序可调用文件。

class sqlalchemy.orm.util.CascadeOptions

基地: builtins.frozenset

跟踪发送到Relationship()的选项。层叠

class 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

class sqlalchemy.orm.properties.ColumnProperty(*columns, **kwargs)

基地: sqlalchemy.orm.interfaces.StrategizedProperty

描述与表列对应的对象属性。

公共构造函数是 orm.column_property() 功能。

class Comparator(prop, parentmapper, adapt_to_entity=None)

基地: sqlalchemy.util.langhelpers.MemoizedSlotssqlalchemy.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_()

参见

all_() -独立版本

any_() -任何操作符

1.1 新版功能.

any(criterion=None, **kwargs)

继承 any() 方法 PropComparator

如果此集合包含符合给定条件的任何成员,则返回true。

通常执行 any()RelationshipProperty.Comparator.any() .

参数
  • criterion -- 针对成员类的表或属性制定的可选子句。

  • **kwargs -- 对应于成员类属性名的键/值对,将通过相等于相应的值进行比较。

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_()

参见

any_() -独立版本

all_() -所有操作符

1.1 新版功能.

asc()

继承 asc() 方法 ColumnOperators

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

between(cleft, cright, symmetric=False)

继承 between() 方法 ColumnOperators

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

bool_op(opstring, precedence=0)

继承 bool_op() 方法 Operators

返回自定义布尔运算符。

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

1.2.0b3 新版功能.

collate(collation)

继承 collate() 方法 ColumnOperators

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

参见

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() .

参数
  • criterion -- 针对成员类的表或属性制定的可选子句。

  • **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%"))
参数
  • other -- 要比较的表达式

  • escape -- 可选转义符,呈现 ESCAPE 关键字,例如:somecolumn.ilike(“foo/%bar”,escape=“/”)

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%"))
参数
  • other -- 要比较的表达式

  • escape -- 可选转义符,呈现 ESCAPE 关键字,例如:somecolumn.like(“foo/%bar”,escape=“/”)

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() 针对父对象的子句。

nullslast()

产生一个 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)

继承 op() 方法 Operators

生成通用运算符函数。

例如。::

somecolumn.op("*")(5)

生产::

somecolumn * 5

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

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

是中的值的位与 somecolumn .

参数
  • operator -- 将作为该元素和传递给生成函数的表达式之间的中缀运算符输出的字符串。

  • precedence -- 在对表达式加括号时应用于运算符的优先级。当对具有更高优先级的另一个运算符应用时,较低的数字将导致表达式加括号。默认值为 0 低于除逗号之外的所有运算符 (,AS 运算符。值100将大于或等于所有运算符,-100将小于或等于所有运算符。

  • is_comparison -- 如果为真,则该运算符将被视为“比较”运算符,即计算为布尔真/假值,如 ==> 等等。应设置此标志,以便ORM关系可以确定在自定义联接条件中使用的运算符是比较运算符。…versionAdded::0.9.2-添加了 Operators.op.is_comparison 标志。

  • return_type -- 一 TypeEngine 类或对象,它将强制此运算符生成的表达式的返回类型为该类型。默认情况下,指定 Operators.op.is_comparison 将决心 Boolean ,而那些不属于左侧操作数的类型。…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))
参数
  • op -- 操作符可调用。

  • *other -- 操作的“另一方”。对于大多数操作,将是单个标量。

  • **kwargs -- 修饰语。这些可由特殊操作符通过,如 ColumnOperators.contains() .

reverse_operate(op, other, **kwargs)

对参数进行反向运算。

用法与 operate() .

startswith(other, **kwargs)

实施 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)

设置引用此映射器属性的父映射器。

此方法被某些子类重写,以便在第一次知道映射器时执行额外的设置。

setup(context, query_entity, path, adapter, **kwargs)

继承 setup() 方法 StrategizedProperty

通过查询调用以构造SQL语句。

与目标映射器关联的每个映射器属性都处理查询上下文引用的语句,并根据需要添加列和/或条件。

class 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() 完整的用法和参数描述。

class sqlalchemy.orm.descriptor_props.CompositeProperty(class_, *attrs, **kwargs)

基地: sqlalchemy.orm.descriptor_props.DescriptorProperty

定义一个“复合”映射属性,将列集合表示为一个属性。

CompositeProperty 是使用 composite() 功能。

class Comparator(prop, parentmapper, adapt_to_entity=None)

基地: sqlalchemy.orm.interfaces.PropComparator

为生成布尔、比较和其他运算符 CompositeProperty 属性。

参见中的示例 重新定义复合材料的比较操作 有关用法的概述,以及 PropComparator .

class CompositeBundle(property_, expr)

基地: sqlalchemy.orm.query.Bundle

create_row_processor(query, procs, labels)

为此生成“行处理”函数 Bundle .

可以被子类重写。

参见

列束 -包括子类化的示例。

__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确定需要执行哪种持久性管理(例如标量、对象、集合等)之后确定的。

class sqlalchemy.orm.attributes.Event(attribute_impl, op)

在属性事件链的整个过程中传播的令牌。

作为事件源的指示器,还提供了控制跨属性操作链传播的方法。

这个 Event 对象作为 initiator 处理诸如 AttributeEvents.append()AttributeEvents.set()AttributeEvents.remove() .

这个 Event 对象当前由backref事件处理程序解释,用于控制操作在两个相互依赖的属性之间的传播。

0.9.0 新版功能.

变量
  • impl -- 这个 AttributeImpl 它是当前事件发起程序。

  • op -- 符号 OP_APPENDOP_REMOVEOP_REPLACEOP_BULK_REPLACE ,指示源操作。

class sqlalchemy.orm.identity.IdentityMap
check_modified()

如果存在任何InstanceStates已标记为“Modified”,则返回true。

class 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 . 但也可以是扩展类型,例如 AssociationProxyhybrid_property . 这个 InspectionAttr.extension_type 将引用标识特定子类型的常量。

is_clause_element = False

如果此对象是 ClauseElement .

is_instance = False

如果此对象是 InstanceState .

is_mapper = False

如果此对象是 Mapper .

is_property = False

如果此对象是 MapperProperty .

is_selectable = False

如果此对象是 Selectable .

class 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和扩展构造。

class 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 访问器。

detached

如果对象是 detached .

dict

返回对象使用的实例dict。

在正常情况下,这始终是 __dict__ 映射对象的属性,除非配置了其他检测系统。

在实际对象被垃圾收集的情况下,此访问器返回一个空字典。

expired_attributes = None

“过期”的一组键,由管理器的延迟标量加载程序加载,假定没有挂起的更改。

另请参阅 unmodified 刷新操作发生时与此集合相交的集合。

has_identity

返回 True 如果此对象具有标识密钥。

它的值应始终与表达式的值相同 state.persistent or state.detached .

identity

返回映射对象的映射标识。这是ORM持久化的主键标识,可以直接传递给 Query.get() .

返回 None 如果对象没有主键标识。

注解

一个对象,它是 transientpendingnot 在刷新之前拥有一个映射的标识,即使其属性包含主键值也是如此。

identity_key

返回映射对象的标识键。

这是用于在 Session.identity_map 映射。它包含返回的标识 identity 在它里面。

mapper

返回 Mapper 用于此映射对象。

object

返回由此表示的映射对象 InstanceState .

pending

如果对象是 pending .

persistent

如果对象是 persistent .

处于持久状态的对象保证位于 Session.identity_map 它的父母 Session .

在 1.1 版更改: 这个 InstanceState.persistent 对于在刷新过程中被“删除”的对象,访问器不再返回true;请使用 InstanceState.deleted 用于检测此状态的访问器。这允许“持久”状态确保身份映射中的成员身份。

session

归还拥有者 Session 在这种情况下,或 None 如果没有。

注意,这里的结果在某些情况下可能是 不同的 从那 obj in session ;已删除的对象将报告为非 in session 但是,如果事务仍在进行中,则此属性仍将引用该会话。只有当事务完成时,对象才会在正常情况下完全分离。

transient

如果对象是 transient .

unloaded

返回一组没有加载值的键。

这包括过期的属性和任何其他从未填充或修改的属性。

unloaded_expirable

返回一组没有加载值的键。

这包括过期的属性和任何其他从未填充或修改的属性。

unmodified

返回没有未提交更改的密钥集

unmodified_intersection(keys)

返回self.unmodified.intersection(keys)。

was_deleted

如果此对象当前或以前处于“已删除”状态且尚未还原为持久性,则返回true。

一旦对象在flush中被删除,此标志将返回true。当对象被显式地或通过事务提交从会话中删除并进入“分离”状态时,此标志将继续报告为真。

1.1 新版功能: -添加了本地方法形式 orm.util.was_deleted() .

参见

InstanceState.deleted -指“已删除”状态

orm.util.was_deleted() -独立函数

Quickie对象状态简介

class 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功能中公开。

class sqlalchemy.orm.interfaces.MapperProperty

基地: sqlalchemy.orm.base._MappedAttributesqlalchemy.orm.base.InspectionAttrsqlalchemy.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功能中公开。

class sqlalchemy.orm.interfaces.PropComparator(prop, parentmapper, adapt_to_entity=None)

基地: sqlalchemy.sql.operators.ColumnOperators

为定义SQL运算符 MapperProperty 对象。

SQLAlchemy允许在核心和ORM级别重新定义运算符。 PropComparator 是ORM级操作的运算符重定义的基类,包括 ColumnPropertyRelationshipPropertyCompositeProperty .

注解

随着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_()

参见

all_() -独立版本

any_() -任何操作符

1.1 新版功能.

any(criterion=None, **kwargs)

如果此集合包含符合给定条件的任何成员,则返回true。

通常执行 any()RelationshipProperty.Comparator.any() .

参数
  • criterion -- 针对成员类的表或属性制定的可选子句。

  • **kwargs -- 对应于成员类属性名的键/值对,将通过相等于相应的值进行比较。

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_()

参见

any_() -独立版本

all_() -所有操作符

1.1 新版功能.

asc()

继承 asc() 方法 ColumnOperators

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

between(cleft, cright, symmetric=False)

继承 between() 方法 ColumnOperators

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

bool_op(opstring, precedence=0)

继承 bool_op() 方法 Operators

返回自定义布尔运算符。

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

1.2.0b3 新版功能.

collate(collation)

继承 collate() 方法 ColumnOperators

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

参见

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() .

参数
  • criterion -- 针对成员类的表或属性制定的可选子句。

  • **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%"))
参数
  • other -- 要比较的表达式

  • escape -- 可选转义符,呈现 ESCAPE 关键字,例如:somecolumn.ilike(“foo/%bar”,escape=“/”)

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%"))
参数
  • other -- 要比较的表达式

  • escape -- 可选转义符,呈现 ESCAPE 关键字,例如:somecolumn.like(“foo/%bar”,escape=“/”)

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() 针对父对象的子句。

nullslast()

产生一个 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)

继承 op() 方法 Operators

生成通用运算符函数。

例如。::

somecolumn.op("*")(5)

生产::

somecolumn * 5

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

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

是中的值的位与 somecolumn .

参数
  • operator -- 将作为该元素和传递给生成函数的表达式之间的中缀运算符输出的字符串。

  • precedence -- 在对表达式加括号时应用于运算符的优先级。当对具有更高优先级的另一个运算符应用时,较低的数字将导致表达式加括号。默认值为 0 低于除逗号之外的所有运算符 (,AS 运算符。值100将大于或等于所有运算符,-100将小于或等于所有运算符。

  • is_comparison -- 如果为真,则该运算符将被视为“比较”运算符,即计算为布尔真/假值,如 ==> 等等。应设置此标志,以便ORM关系可以确定在自定义联接条件中使用的运算符是比较运算符。…versionAdded::0.9.2-添加了 Operators.op.is_comparison 标志。

  • return_type -- 一 TypeEngine 类或对象,它将强制此运算符生成的表达式的返回类型为该类型。默认情况下,指定 Operators.op.is_comparison 将决心 Boolean ,而那些不属于左侧操作数的类型。…versionAdded::1.2.0b3-添加了 Operators.op.return_type 争论。

operate(op, *other, **kwargs)

继承 operate() 方法 Operators

对参数进行运算。

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

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

class MyComparator(ColumnOperators):
    def operate(self, op, other):
        return op(func.lower(self), func.lower(other))
参数
  • op -- 操作符可调用。

  • *other -- 操作的“另一方”。对于大多数操作,将是单个标量。

  • **kwargs -- 修饰语。这些可由特殊操作符通过,如 ColumnOperators.contains() .

reverse_operate(op, other, **kwargs)

对参数进行反向运算。

用法与 operate() .

startswith(other, **kwargs)

实施 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" 在被传递到数据库之前。

class 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() 功能。

参见

关系配置

class 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_()

参见

all_() -独立版本

any_() -任何操作符

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_()

参见

any_() -独立版本

all_() -所有操作符

1.1 新版功能.

asc()

继承 asc() 方法 ColumnOperators

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

between(cleft, cright, symmetric=False)

继承 between() 方法 ColumnOperators

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

bool_op(opstring, precedence=0)

继承 bool_op() 方法 Operators

返回自定义布尔运算符。

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

1.2.0b3 新版功能.

collate(collation)

继承 collate() 方法 ColumnOperators

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

参见

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 .

这不是一个 MapperAliasedInsp 对象。

这是 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%"))
参数
  • other -- 要比较的表达式

  • escape -- 可选转义符,呈现 ESCAPE 关键字,例如:somecolumn.ilike(“foo/%bar”,escape=“/”)

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%"))
参数
  • other -- 要比较的表达式

  • escape -- 可选转义符,呈现 ESCAPE 关键字,例如:somecolumn.like(“foo/%bar”,escape=“/”)

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() 针对父对象的子句。

nullslast()

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

of_type(cls)

根据多态子类重新定义此对象。

PropComparator.of_type() 举个例子。

op(opstring, precedence=0, is_comparison=False, return_type=None)

继承 op() 方法 Operators

生成通用运算符函数。

例如。::

somecolumn.op("*")(5)

生产::

somecolumn * 5

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

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

是中的值的位与 somecolumn .

参数
  • operator -- 将作为该元素和传递给生成函数的表达式之间的中缀运算符输出的字符串。

  • precedence -- 在对表达式加括号时应用于运算符的优先级。当对具有更高优先级的另一个运算符应用时,较低的数字将导致表达式加括号。默认值为 0 低于除逗号之外的所有运算符 (,AS 运算符。值100将大于或等于所有运算符,-100将小于或等于所有运算符。

  • is_comparison -- 如果为真,则该运算符将被视为“比较”运算符,即计算为布尔真/假值,如 ==> 等等。应设置此标志,以便ORM关系可以确定在自定义联接条件中使用的运算符是比较运算符。…versionAdded::0.9.2-添加了 Operators.op.is_comparison 标志。

  • return_type -- 一 TypeEngine 类或对象,它将强制此运算符生成的表达式的返回类型为该类型。默认情况下,指定 Operators.op.is_comparison 将决心 Boolean ,而那些不属于左侧操作数的类型。…versionAdded::1.2.0b3-添加了 Operators.op.return_type 争论。

operate(op, *other, **kwargs)

继承 operate() 方法 Operators

对参数进行运算。

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

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

class MyComparator(ColumnOperators):
    def operate(self, op, other):
        return op(func.lower(self), func.lower(other))
参数
  • op -- 操作符可调用。

  • *other -- 操作的“另一方”。对于大多数操作,将是单个标量。

  • **kwargs -- 修饰语。这些可由特殊操作符通过,如 ColumnOperators.contains() .

reverse_operate(op, other, **kwargs)

对参数进行反向运算。

用法与 operate() .

startswith(other, **kwargs)

实施 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)

设置引用此映射器属性的父映射器。

此方法被某些子类重写,以便在第一次知道映射器时执行额外的设置。

setup(context, query_entity, path, adapter, **kwargs)

继承 setup() 方法 StrategizedProperty

通过查询调用以构造SQL语句。

与目标映射器关联的每个映射器属性都处理查询上下文引用的语句,并根据需要添加列和/或条件。

class 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语句。

与目标映射器关联的每个映射器属性都处理查询上下文引用的语句,并根据需要添加列和/或条件。

class sqlalchemy.orm.query.QueryContext(query)
class sqlalchemy.orm.attributes.QueryableAttribute(class_, key, impl=None, comparator=None, parententity=None, of_type=None)

基地: sqlalchemy.orm.base._MappedAttributesqlalchemy.orm.base.InspectionAttrsqlalchemy.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_()

参见

all_() -独立版本

any_() -任何操作符

1.1 新版功能.

any(criterion=None, **kwargs)

继承 any() 方法 PropComparator

如果此集合包含符合给定条件的任何成员,则返回true。

通常执行 any()RelationshipProperty.Comparator.any() .

参数
  • criterion -- 针对成员类的表或属性制定的可选子句。

  • **kwargs -- 对应于成员类属性名的键/值对,将通过相等于相应的值进行比较。

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_()

参见

any_() -独立版本

all_() -所有操作符

1.1 新版功能.

asc()

继承 asc() 方法 ColumnOperators

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

between(cleft, cright, symmetric=False)

继承 between() 方法 ColumnOperators

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

bool_op(opstring, precedence=0)

继承 bool_op() 方法 Operators

返回自定义布尔运算符。

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

1.2.0b3 新版功能.

collate(collation)

继承 collate() 方法 ColumnOperators

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

参见

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() .

参数
  • criterion -- 针对成员类的表或属性制定的可选子句。

  • **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%"))
参数
  • other -- 要比较的表达式

  • escape -- 可选转义符,呈现 ESCAPE 关键字,例如:somecolumn.ilike(“foo/%bar”,escape=“/”)

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”字典。

这里的行为如下:

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%"))
参数
  • other -- 要比较的表达式

  • escape -- 可选转义符,呈现 ESCAPE 关键字,例如:somecolumn.like(“foo/%bar”,escape=“/”)

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() 针对父对象的子句。

nullslast()

产生一个 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)

继承 op() 方法 Operators

生成通用运算符函数。

例如。::

somecolumn.op("*")(5)

生产::

somecolumn * 5

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

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

是中的值的位与 somecolumn .

参数
  • operator -- 将作为该元素和传递给生成函数的表达式之间的中缀运算符输出的字符串。

  • precedence -- 在对表达式加括号时应用于运算符的优先级。当对具有更高优先级的另一个运算符应用时,较低的数字将导致表达式加括号。默认值为 0 低于除逗号之外的所有运算符 (,AS 运算符。值100将大于或等于所有运算符,-100将小于或等于所有运算符。

  • is_comparison -- 如果为真,则该运算符将被视为“比较”运算符,即计算为布尔真/假值,如 ==> 等等。应设置此标志,以便ORM关系可以确定在自定义联接条件中使用的运算符是比较运算符。…versionAdded::0.9.2-添加了 Operators.op.is_comparison 标志。

  • return_type -- 一 TypeEngine 类或对象,它将强制此运算符生成的表达式的返回类型为该类型。默认情况下,指定 Operators.op.is_comparison 将决心 Boolean ,而那些不属于左侧操作数的类型。…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))
参数
  • op -- 操作符可调用。

  • *other -- 操作的“另一方”。对于大多数操作,将是单个标量。

  • **kwargs -- 修饰语。这些可由特殊操作符通过,如 ColumnOperators.contains() .

parent

返回表示父级的检查实例。

这将是 MapperAliasedInsp ,取决于与此属性关联的父实体的性质。

property

返回 MapperProperty 与此关联 QueryableAttribute .

这里的返回值通常是 ColumnPropertyRelationshipProperty .

reverse_operate(op, other, **kwargs)

对参数进行反向运算。

用法与 operate() .

startswith(other, **kwargs)

实施 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" 在被传递到数据库之前。

class 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。