版本:1.1.0b2 |发布日期:2016年7月1日

SQLAlchemy 1.1文档

ORM内部

这里列出了关键的ORM结构,其他部分未涉及。

class sqlalchemy.orm.state.AttributeState(state, key)

提供与特定映射对象上的特定属性对应的检查界面。

AttributeState对象通过特定InstanceStateInstanceState.attrs集合进行访问:

from sqlalchemy import inspect

insp = inspect(some_mapped_object)
attr_state = insp.attrs.some_attribute
历史 T0> ¶ T1>

通过History界面返回此属性的当前预冲刷更改历史记录。

如果该属性的值被卸载,该方法将发送加载器可调参数。

也可以看看

AttributeState.load_history() - 如果值不是本地存在,则使用加载器可调用项检索历史记录。

attributes.get_history() - 底层函数

load_history T0> ( T1> ) T2> ¶ T3>

通过History界面返回此属性的当前预冲刷更改历史记录。

如果该属性的值被卸载,这个方法发送加载器可调用对象。

版本0.9.0中新增。

loaded_value T0> ¶ T1>

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

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

值 T0> ¶ T1>

返回此属性的值。

这个操作等同于直接或通过getattr()访问对象的属性,并且如果需要的话,将会触发任何挂起的加载器可调用。

class sqlalchemy.orm.util。 CascadeOptions

Bases: __builtin__.frozenset

跟踪发送给relationship()。cascade的选项

class sqlalchemy.orm.instrumentation.ClassManager(class_)

Bases: __builtin__.dict

跟踪班级的状态信息。

__文件__ T0> ¶ T1>
inherited from the __le__ attribute of dict

x .__ le __(y)x

__ LT __ T0> ¶ T1>
inherited from the __lt__ attribute of dict

x.__lt__(y) <==> x

__ NE __ T0> ¶ T1>
inherited from the __ne__ attribute of dict

x .__ ne __(y)x!= y

清除 →无。删除D. 中的所有项目
inherited from the clear() method of dict
拷贝 →D 的浅拷贝
inherited from the copy() method of dict
处置 T0> ( T1> ) T2> ¶ T3>

将这位经理从同级中解散。

fromkeys(S[, v]) → New dict with keys from S and values equal to v.
fromkeys() 方法继承的dict

v默认为None。

get(k[, d]) → D[k] if k in D, else d. d defaults to None.
继承自 get() 方法 dict
has_key(k) → True if D has a key k, else False
has_key() 方法继承的dict
has_parent statekeyoptimistic = False T5> ¶ T6>

去做

items() → list of D's (key, value) pairs, as 2-tuples
inherited from the items() method of dict
iteritems() → an iterator over the (key, value) items of D
inherited from the iteritems() method of dict
iterkeys() → an iterator over the keys of D
inherited from the iterkeys() method of dict
itervalues() → an iterator over the values of D
inherited from the itervalues() method of dict
键 tt> →D键列表
inherited from the keys() method of dict
管理 T0> ( T1> ) T2> ¶ T3>

将此实例标记为其类的管理器。

original_init T0> ¶ T1>

x .__ init __(...)初始化x;请参阅帮助(键入(x))进行签名

pop tt> k d ] t6>)→v,移除指定的键并返回相应的值。
inherited from the pop() method of dict

如果没有找到key,给定返回d,否则引发KeyError

popitem →(k,v),移除并返回一些(key,value)对作为¶ t3 >
inherited from the popitem() method of dict

2元组;但如果D为空则引发KeyError。

setdefault(k[, d]) → D.get(k,d), also set D[k]=d if k not in D
inherited from the setdefault() method of dict
state_getter T0> ( T1> ) T2> ¶ T3>

返回(实例) - > InstanceState可调用。

如果不能找到实例的InstanceState,“state getter”callables应该引发KeyError或AttributeError。

注销 T0> ( T1> ) T2> ¶ T3>

删除由此ClassManager建立的所有工具。

update([E, ]**F) → None. 从dict / iterable E和F中更新D。
inherited from the update() method of dict

如果E存在且具有.keys()方法,则:对于E中的k:D [k] = E [k]如果E存在并且缺少.keys()方法,则:for(k,v)in E: D [k] = v在任一情况下,这后面是:对于F中的k:D [k] = F [k]

→D值列表
inherited from the values() method of dict
viewitems() → a set-like object providing a view on D's items
inherited from the viewitems() method of dict
viewkeys() → a set-like object providing a view on D's keys
inherited from the viewkeys() method of dict
viewvalues() → an object providing a view on D's values
inherited from the viewvalues() method of 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的文档。

也可以看看:

PropComparator

ColumnOperators

Redefining and Creating New Operators

TypeEngine.comparator_factory

__当量__ T0> ( T1> 其他 T2> ) T3> ¶ T4>

实现==运算符。

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

__文件__ T0> ( T1> 其他 T2> ) T3> ¶ T4>
继承自 __le__() ColumnOperators的方法

实现<=运算符。

在列上下文中,生成子句a b

__ LT __ T0> ( T1> 其他 T2> ) T3> ¶ T4>
inherited from the __lt__() method of ColumnOperators

实现<运算符。

在列上下文中,生成子句a b

__ NE __ T0> ( T1> 其他 T2> ) T3> ¶ T4>

实现!=运算符。

在列上下文中,生成子句a != bIf the target is None, produces a IS NOT NULL.

adapt_to_entity T0> ( T1> adapt_to_entity T2> ) T3> ¶ T4>
inherited from the adapt_to_entity() method of PropComparator

返回将使用给定的AliasedInsp产生相应表达式的PropComparator的副本。

适配器 T0> ¶ T1>
inherited from the adapter attribute of PropComparator

生成一个可调用的列,适应列表达式以适应该比较器的别名版本。

所有_ T0> ( T1> ) T2> ¶ T3>

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

版本1.1中的新功能

任何 criterion = None** kwargs / T5>
inherited from the any() method of PropComparator

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

any()的通常实现是RelationshipProperty.Comparator.any()

参数:
  • criterion – an optional ClauseElement formulated against the member class’ table or attributes.
  • **kwargs – key/value pairs corresponding to member class attribute names which will be compared via equality to the corresponding values.
任何_ T0> ( T1> ) T2> ¶ T3>
inherited from the any_() method of ColumnOperators

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

版本1.1中的新功能

ASC T0> ( T1> ) T2> ¶ T3>
inherited from the asc() method of ColumnOperators

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

between(cleft, cright, symmetric=False)
inherited from the between() method of ColumnOperators

根据父对象,在()子句之间产生一个between()

整理 T0> ( T1> 整理 T2> ) T3> ¶ T4>
inherited from the collate() method of ColumnOperators

根据给定的排序字符串,针对父对象生成一个collate()子句。

的concat T0> ( T1> 其他 T2> ) T3> ¶ T4>
inherited from the concat() method of ColumnOperators

实现'concat'操作符。

在列上下文中,生成子句a || b,或者使用concat()运算符。

包含 其他** kwargs >
inherited from the contains() method of ColumnOperators

实现“包含”运算符。

在列上下文中,生成子句LIKE '%&lt; other&gt;%'

递减 T0> ( T1> ) T2> ¶ T3>
inherited from the desc() method of ColumnOperators

针对父对象生成一个desc()子句。

不同 T0> ( T1> ) T2> ¶ T3>
从 tt> distinct() 方法继承的ColumnOperators

针对父对象生成一个distinct()子句。

endswith other** kwargs t5 >
inherited from the endswith() method of ColumnOperators

实现'endswith'操作符。

在列上下文中,生成子句LIKE '%&lt; other&gt;

criterion = None** kwargs / T5>
inherited from the has() method of PropComparator

如果此元素引用符合给定条件的成员,则返回true。

The usual implementation of has() is RelationshipProperty.Comparator.has().

参数:
  • criterion – an optional ClauseElement formulated against the member class’ table or attributes.
  • **kwargs – key/value pairs corresponding to member class attribute names which will be compared via equality to the corresponding values.
ilike 其他escape =无 t5 >
inherited from the ilike() method of ColumnOperators

实现ilike运算符。

在列上下文中,生成子句a ILIKE 其他

例如。:

select([sometable]).where(sometable.c.column.ilike("%foobar%"))
参数:
  • 其他 - 要比较的表达式
  • 转义 -

    可选的转义字符,呈现ESCAPE关键字,例如:

    somecolumn.ilike("foo/%bar", escape="/")

也可以看看

ColumnOperators.like()

在_ T0> ( T1> 其他 T2> ) T3> ¶ T4>
inherited from the in_() method of ColumnOperators

在运算符中实现in

在列上下文中,生成子句a IN 其他“other”可以是列表达式的元组/列表,或者是一个select()结构。

是_ T0> ( T1> 其他 T2> ) T3> ¶ T4>
inherited from the is_() method of ColumnOperators

实现IS运算符。

正常情况下,当与None的值进行比较时,会自动生成IS,这将解析为NULL但是,如果与某些平台上的布尔值进行比较,则可能需要显式使用IS

New in version 0.7.9.

is_distinct_from T0> ( T1> 其他 T2> ) T3> ¶ T4>
inherited from the is_distinct_from() method of ColumnOperators

实现IS DISTINCT FROM运算符。

在大多数平台上呈现“一个IS DISTINCT FROM b”;在一些如SQLite可能会呈现“一个不是b”。

版本1.1中的新功能

IsNot运算 T0> ( T1> 其他 T2> ) T3> ¶ T4>
inherited from the isnot() method of ColumnOperators

实现IS NOT运算符。

Normally, IS NOT is generated automatically when comparing to a value of None, which resolves to NULL. 然而,明确使用IS NOT,如果与某些平台上的布尔值进行比较可能是可取的。

New in version 0.7.9.

也可以看看

ColumnOperators.is_()

isnot_distinct_from T0> ( T1> 其他 T2> ) T3> ¶ T4>
inherited from the isnot_distinct_from() method of ColumnOperators

实现IS NOT DISTINCT FROM运算符。

在大多数平台上呈现“一个不是从BIND DISTINCT”;在某些如SQLite上可能会呈现“a IS b”。

版本1.1中的新功能

like(other, escape=None)
inherited from the like() method of ColumnOperators

像运算符一样实现like

在列上下文中,生成子句a LIKE 其他

例如。:

select([sometable]).where(sometable.c.column.like("%foobar%"))
参数:
  • 其他 - 要比较的表达式
  • 转义 -

    可选的转义字符,呈现ESCAPE关键字,例如:

    somecolumn.like("foo/%bar", escape="/")
匹配 其他** kwargs t5 >
inherited from the match() method of ColumnOperators

实现数据库特定的“匹配”运算符。

match() attempts to resolve to a MATCH-like function or operator provided by the backend. 例子包括:

  • Postgresql - 呈现x @@ to_tsquery(y)
  • MySQL - renders MATCH (x) AGAINST (y IN BOOLEAN MODE)
  • Oracle - 呈现CONTAINS(x, y)
  • 其他后端可能会提供特殊的实现。
  • 没有任何特殊实现的后端会将操作符发送为“MATCH”。例如,这与SQlite兼容。
notilike(other, escape=None)
inherited from the notilike() method of ColumnOperators

执行NOT ILIKE运算符。

这相当于对ColumnOperators.ilike()使用否定,即~x.ilike(y)

0.8版本中的新功能

notin _ T0> ( T1> 其他 T2> ) T3> ¶ T4>
inherited from the notin_() method of ColumnOperators

执行NOT IN运算符。

这相当于对ColumnOperators.in_(),即~x.in_(y)使用否定。

0.8版本中的新功能

也可以看看

ColumnOperators.in_()

notlike 其他转义=无 t5 >
inherited from the notlike() method of ColumnOperators

执行NOT LIKE运算符。

这等同于使用ColumnOperators.like()的否定,即~x.like(y)

0.8版本中的新功能

也可以看看

ColumnOperators.like()

nullsfirst T0> ( T1> ) T2> ¶ T3>
inherited from the nullsfirst() method of ColumnOperators

针对父对象生成一个nullsfirst()子句。

nullslast T0> ( T1> ) T2> ¶ T3>
inherited from the nullslast() method of ColumnOperators

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

of_type T0> ( T1> 类_ T2> ) T3> ¶ T4>
inherited from the of_type() method of PropComparator

用多态子类重新定义这个对象。

返回一个新的PropComparator,可以从中进一步评估标准。

例如。:

query.join(Company.employees.of_type(Engineer)).\
   filter(Engineer.name=='foo')
参数:class_ – a class or mapper indicating that criterion will be against this specific subclass.
op opstringprecedence = 0is_comparison = False ) T5> ¶ T6>
继承自 op() 方法的Operators

产生通用的操作员功能。

例如。:

somecolumn.op("*")(5)

生产:

somecolumn * 5

这个函数也可以用来使按位运算符明确。例如:

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

somecolumn中的值的按位与。

参数:
  • operator – a string which will be output as the infix operator between this element and the expression passed to the generated function.
  • 优先级 -

    当对表达式进行加括号时,优先级适用于运算符。较低的数字将使表达式在针对具有较高优先级的另一个运算符应用时加括号。除了逗号(,)和AS运算符以外,0的默认值低于所有运算符。100的值将会高于或等于所有运算符,-100将低于或等于所有运算符。

    新版本0.8: - 添加了“优先”参数。

  • is_comparison -

    如果为True,则运算符将被视为“比较”运算符,即,其值为布尔值true / false,如==>等。应该设置此标志,以便ORM关系可以确定运算符在自定义连接条件中使用时是比较运算符。

    版本0.9.2新增: - 添加了Operators.op.is_comparison标志。

startswith 其他** kwargs t5 >
inherited from the startswith() method of ColumnOperators

实现startwith运算符。

在列上下文中,生成子句LIKE '&lt; other&gt;%'

ColumnProperty.__init__(*columns, **kwargs)

构建一个新的ColumnProperty对象。

这个构造函数被镜像为公共API函数;有关完整的用法和参数说明,请参阅column_property()

ColumnProperty cascade_iterator type状态visited_instances = / t5>,halt_on = None
inherited from the cascade_iterator() method of MapperProperty

从MapperProperty开始,迭代与给定实例有关的特定“级联”的实例。

返回一个iterator3-tuples(实例,映射器,状态)。

请注意,在调用cascade_iterator之前,首先会检查此MapperProperty上的“级联”集合是否为给定类型。

此方法通常只适用于RelationshipProperty。

COLUMNPROPERTY。 T0> class_attribute T1> ¶ T2>
inherited from the class_attribute attribute of MapperProperty

返回对应于这个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
COLUMNPROPERTY。 T0> 表达 T1> ¶ T2>

返回此ColumnProperty的主要列或表达式。

ColumnProperty extension_type =符号('NOT_EXTENSION')
COLUMNPROPERTY。 T0> 初始化 T1> ( T2> ) T3> ¶ T4>
inherited from the init() method of MapperProperty

在创建所有映射器之后调用,以组合映射器之间的关系并执行其他映射器创建初始化步骤。

ColumnProperty.set_parent(parent, init)
inherited from the set_parent() method of MapperProperty

设置引用此MapperProperty的父映射器。

第一次知道映射器时,这个方法被一些子类覆盖以执行额外的设置。

class sqlalchemy.orm.properties.ComparableProperty(comparator_factory, descriptor=None, doc=None, info=None)

基础:sqlalchemy.orm.descriptor_props.DescriptorProperty

在查询表达式中使用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 is constructed using the composite() function.

也可以看看

Composite Column Types

class Comparator(prop, parentmapper, adapt_to_entity=None)

基础:sqlalchemy.orm.interfaces.PropComparator

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

请参阅Redefining Comparison Operations for Composites中的示例以了解用法概述以及PropComparator的文档。

也可以看看:

PropComparator

ColumnOperators

Redefining and Creating New Operators

TypeEngine.comparator_factory

CompositeProperty.__init__(class_, *attrs, **kwargs)

构建一个新的CompositeProperty对象。

这个构造函数被镜像为公共API函数;有关完整的用法和参数说明,请参阅composite()

CompositeProperty。 T0> do_init T1> ( T2> ) T3> ¶ T4>

CompositeProperty与其父映射器关联之后发生的初始化。

CompositeProperty.get_history(state, dict_, passive=symbol('PASSIVE_OFF'))

为使用attributes.get_history()的用户级代码提供。

class sqlalchemy.orm.attributes。 Event attribute_implop T5> ) T6> ¶ T7>

一个令牌在一系列属性事件中传播。

作为事件来源的指标,也提供了一种控制属性操作链中传播的手段。

The Event object is sent as the initiator argument when dealing with the AttributeEvents.append(), AttributeEvents.set(), and AttributeEvents.remove() events.

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

版本0.9.0中新增。

变量:
  • impl - AttributeImpl它是当前的事件发起者。
  • op - 符号OP_APPENDOP_REMOVEOP_REPLACE,指示源操作。
class sqlalchemy.orm.identity。 IdentityMap
check_modified T0> ( T1> ) T2> ¶ T3>

如果存在的实例状态已被标记为“已修改”,则返回True。

class sqlalchemy.orm.base。 InspectionAttr

适用于所有可由inspect()函数返回的ORM对象的基类。

这里定义的属性允许使用简单的布尔检查来测试返回对象的基本事实。

虽然这里的布尔检查基本上与使用Python isinstance()函数相同,但这里的标志可以在不需要导入所有这些类的情况下使用,也可以使SQLAlchemy类系统在保持标志完整为了向前兼容。

extension_type =符号('NOT_EXTENSION')

扩展类型,如果有的话。默认为interfaces.NOT_EXTENSION

0.8.0版本中的新功能

is_aliased_class = False

如果此对象是AliasedClass的实例,则为true。

is_attribute = False

如果此对象是Python descriptor,则为真。

这可以指许多类型之一。通常是QueryableAttribute,它代表MapperProperty处理属性事件。但也可以是扩展类型,如AssociationProxyhybrid_propertyThe InspectionAttr.extension_type will refer to a constant identifying the specific subtype.

is_clause_element = False

如果此对象是ClauseElement的实例,则为true。

is_instance = False

如果此对象是InstanceState的实例,则为true。

is_mapper = False

如果此对象是Mapper的实例,则为true。

is_property = False

如果此对象是MapperProperty的实例,则为true。

is_selectable = False

如果此对象是Selectable的实例,则返回True。

class sqlalchemy.orm.base。 InspectionAttrInfo

基础:sqlalchemy.orm.base.InspectionAttr

.info属性添加到InspectionAttr

The rationale for InspectionAttr vs. InspectionAttrInfo is that the former is compatible as a mixin for classes that specify __slots__; this is essentially an implementation artifact.

信息 T0> ¶ T1>

与对象关联的信息字典,允许用户定义的数据与这个InspectionAttr关联。

字典在第一次访问时生成。或者,它可以被指定为column_property()relationship()composite()函数的构造函数参数。

0.8版新增功能增加了对所有MapperProperty子类的.info支持。

版本1.0.0更改: MapperProperty.info也可以通过InspectionAttrInfo.info属性在扩展类型中使用,以便它可以应用于更广泛的ORM和扩展构造。

class sqlalchemy.orm.state.InstanceState(obj, manager)

基础:sqlalchemy.orm.base.InspectionAttr

跟踪实例级别的状态信息。

The InstanceState is a key object used by the SQLAlchemy ORM in order to track the state of an object; it is created the moment an object is instantiated, typically as a result of instrumentation which SQLAlchemy applies to the __init__() method of the class.

InstanceState is also a semi-public object, available for runtime inspection as to the state of a mapped instance, including information such as its current status within a particular Session and details about data on individual attributes. 为了获取InstanceState对象的公共API是使用inspect()系统:

>>> from sqlalchemy import inspect
>>> insp = inspect(some_mapped_object)

也可以看看

Runtime Inspection API

ATTRS T0> ¶ T1>

返回表示映射对象上每个属性的名称空间,包括其当前值和历史记录。

返回的对象是AttributeState的一个实例。该对象允许检查属性中的当前数据以及自上次刷新以来的属性历史记录。

callables =()

每个状态加载器可调用的名称空间可以关联。

在SQLAlchemy 1.0中,这只用于通过查询选项设置的懒加载器/延迟加载器。

以前,通过在此字典中存储指向InstanceState本身的链接,也使用可调用标记来指示过期的属性。此角色现在由expired_attributes集处理。

删除 T0> ¶ T1>

如果对象deleted,则返回true。

处于删除状态的对象保证不在其父节点SessionSession.identity_map内。但是,如果会话的事务回滚,对象将被恢复到持久状态和身份映射。

注意

InstanceState.deleted属性是指在“持久”和“分离”状态之间发生的对象的特定状态;一旦对象detachedInstanceState.deleted属性不再返回True;为了检测一个状态是否被删除,无论该对象是否与一个Session关联,使用InstanceState.was_deleted存取器。

分离 T0> ¶ T1>

如果对象detached,则返回true。

字典 T0> ¶ T1>

返回对象使用的实例字典。

在正常情况下,除非已经配置了替代的仪器系统,否则这始终与映射对象的__dict__属性同义。

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

expired_attributes =无

假定没有待处理的更改,由管理器的延迟标量加载器加载的“过期”密钥集。

当刷新操作发生时,还可以看到与此集合相交的unmodified集合。

has_identity T0> ¶ T1>

如果这个对象有一个标识关键字,则返回True

它应该总是和表达式state.persistent state.detached相同。

身份 T0> ¶ T1>

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

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

注意

即使其属性包含主键值,在transientpending not的对象上也将具有映射的标识,直到刷新为止。

identity_key T0> ¶ T1>

返回映射对象的身份密钥。

这是在Session.identity_map映​​射中定位对象的关键。它包含由identity返回的标识。

映射器 T0> ¶ T1>

返回用于这个mapepd对象的Mapper

对象 T0> ¶ T1>

返回由InstanceState表示的映射对象。

未决 T0> ¶ T1>

如果对象pending,则返回true。

持久 T0> ¶ T1>

如果对象是persistent,则返回true。

处于持久状态的对象保证在其父节点SessionSession.identity_map内。

在版本1.1中更改:对于在flush内被“删除”的对象,InstanceState.persistent访问器不再返回True。使用InstanceState.deleted访问器来检测这个状态。这允许“持久”状态保证身份映射中的成员身份。

会话 T0> ¶ T1>

返回这个实例的Session,或者None,如果没有可用的。

Note that the result here can in some cases be different from that of obj in session; an object that’s been deleted will report as not in session, however if the transaction is still in progress, this attribute will still refer to that session. 只有在交易完成的情况下,物品在正常情况下才能完全分离。

瞬态 T0> ¶ T1>

如果对象是transient,则返回true。

卸载 T0> ¶ T1>

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

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

未修饰 T0> ¶ T1>

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

unmodified_intersection T0> ( T1> 键 T2> ) T3> ¶ T4>

返回self.unmodified.intersection(键)。

was_deleted T0> ¶ T1>

如果此对象处于或以前处于“已删除”状态且尚未恢复为持续状态,则返回True。

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

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

也可以看看

InstanceState.deleted - refers to the “deleted” state

orm.util.was_deleted() - 独立功能

Quickie Intro to Object States

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

基础:sqlalchemy.orm.attributes.QueryableAttribute

添加基本​​descriptor方法的类绑定插装属性。

有关大多数功能的描述,请参见QueryableAttribute

__删除__ T0> ( T1> 实例 T2> ) T3> ¶ T4>
__get__(instance, owner)
__set__(instance, value)
sqlalchemy.orm.interfaces。 MANYTOONE = symbol('MANYTOONE')

指示relationship()

此符号通常由内部使用,但可能会暴露在某些API功能中。

sqlalchemy.orm.interfaces。 MANYTOMANY =符号('MANYTOMANY')

指示relationship()的多对多方向。

此符号通常由内部使用,但可能会暴露在某些API功能中。

class sqlalchemy.orm.interfaces。 MapperProperty

基础:sqlalchemy.orm.base._MappedAttributesqlalchemy.orm.base.InspectionAttrsqlalchemy.util.langhelpers.MemoizedSlots

表示由Mapper映​​射的特定类属性。

The most common occurrences of MapperProperty are the mapped Column, which is represented in a mapping as an instance of ColumnProperty, and a reference to another class produced by relationship(), represented in the mapping as an instance of RelationshipProperty.

信息 T0> ¶ T1>

与对象关联的信息字典,允许用户定义的数据与这个InspectionAttr关联。

字典在第一次访问时生成。或者,它可以被指定为column_property()relationship()composite()函数的构造函数参数。

0.8版新增功能增加了对所有MapperProperty子类的.info支持。

从版本1.0.0更改: InspectionAttr.infoMapperProperty移动,以便它可以应用到更广泛的ORM和扩展结构。

cascade = frozenset([])

“级联”属性名称的集合。

在调用“cascade_iterator”方法之前检查该集合。

该集合通常仅适用于RelationshipProperty。

cascade_iterator(type_, state, visited_instances=None, halt_on=None)

从MapperProperty开始,迭代与给定实例有关的特定“级联”的实例。

返回一个iterator3-tuples(实例,映射器,状态)。

请注意,在调用cascade_iterator之前,首先会检查此MapperProperty上的“级联”集合是否为给定类型。

此方法通常只适用于RelationshipProperty。

class_attribute T0> ¶ T1>

返回对应于这个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 T0> ( T1> ) T2> ¶ T3>

执行子类特定的初始化后映射器创建步骤。

这是一个由MapperProperty对象的init()方法调用的模板方法。

初始化 T0> ( T1> ) T2> ¶ T3>

在创建所有映射器之后调用,以组合映射器之间的关系并执行其他映射器创建初始化步骤。

instrument_class T0> ( T1> 映射器 T2> ) T3> ¶ T4>

Hook被Mapper调用到该属性,以启动由此MapperProperty管理的类属性的检测。

这里的MapperProperty通常会调用属性模块来设置InstrumentedAttribute。

这一步是设置InstrumentedAttribute的两个步骤中的第一步,在映射器设置过程中被称为早期。

第二步通常是通过post_instrument_class()钩子从StrategizedProperty调用的init_class_attribute步骤。这一步为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 T0> ( T1> 映射器 T2> ) T3> ¶ T4>

执行init()完成后需要进行的仪器调整。

给定的Mapper是调用操作的Mapper,在继承场景中可能不是与self.parent相同的Mapper;然而,Mapper将总是至少成为self.parent的子映射器。

这个方法通常由StrategizedProperty使用,它将其委托给LoaderStrategy.init_class_attribute()来对类绑定的InstrumentedAttribute执行最终的设置。

set_parent(parent, init)

设置引用此MapperProperty的父映射器。

第一次知道映射器时,这个方法被一些子类覆盖以执行额外的设置。

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

由Query调用以构造SQL语句。

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

sqlalchemy.orm.interfaces。 NOT_EXTENSION =符号('NOT_EXTENSION')

表示InspectionAttr的符号不属于sqlalchemy.ext的一部分。

被分配给InspectionAttr.extension_type属性。

sqlalchemy.orm.interfaces。 ONETOMANY =符号('ONETOMANY')

指示relationship()的一对多方向。

此符号通常由内部使用,但可能会暴露在某些API功能中。

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

基础:sqlalchemy.sql.operators.ColumnOperators

定义MapperProperty对象的SQL运算符。

SQLAlchemy允许在核心和ORM级别重新定义运算符。PropComparator is the base class of operator redefinition for ORM-level operations, including those of ColumnProperty, RelationshipProperty, and CompositeProperty.

注意

随着SQLAlchemy 0.7中引入的混合属性的出现以及SQLAlchemy 0.8中的核心级操作符重定义,用户定义的PropComparator实例的用例极为罕见。参见Hybrid Attributes以及Redefining and Creating New Operators

用户可以创建PropComparator的子类。内置的Python比较和数学运算符方法,如operators.ColumnOperators.__eq__()operators.ColumnOperators.__lt__()operators.ColumnOperators.__add__(),可以被覆盖以提供新的操作员行为。通过comparator_factory参数将自定义PropComparator传递给MapperProperty实例。在每种情况下,应使用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属性在核心级别定义运算符会更简单。有关更多详细信息,请参见Redefining and Creating New Operators

也可以看看:

ColumnProperty.Comparator

RelationshipProperty.Comparator

CompositeProperty.Comparator

ColumnOperators

Redefining and Creating New Operators

TypeEngine.comparator_factory

__当量__ T0> ( T1> 其他 T2> ) T3> ¶ T4>

实现==运算符。

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

__文件__ T0> ( T1> 其他 T2> ) T3> ¶ T4>
继承自 __le__() ColumnOperators的方法

实现<=运算符。

在列上下文中,生成子句a b

__ LT __ T0> ( T1> 其他 T2> ) T3> ¶ T4>
inherited from the __lt__() method of ColumnOperators

实现<运算符。

在列上下文中,生成子句a b

__ NE __ T0> ( T1> 其他 T2> ) T3> ¶ T4>

实现!=运算符。

在列上下文中,生成子句a != bIf the target is None, produces a IS NOT NULL.

adapt_to_entity T0> ( T1> adapt_to_entity T2> ) T3> ¶ T4>

返回将使用给定的AliasedInsp产生相应表达式的PropComparator的副本。

适配器 T0> ¶ T1>

生成一个可调用的列,适应列表达式以适应该比较器的别名版本。

所有_ T0> ( T1> ) T2> ¶ T3>

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

版本1.1中的新功能

任何 criterion = None** kwargs / T5>

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

any()的通常实现是RelationshipProperty.Comparator.any()

参数:
  • criterion – an optional ClauseElement formulated against the member class’ table or attributes.
  • **kwargs – key/value pairs corresponding to member class attribute names which will be compared via equality to the corresponding values.
任何_ T0> ( T1> ) T2> ¶ T3>
inherited from the any_() method of ColumnOperators

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

版本1.1中的新功能

ASC T0> ( T1> ) T2> ¶ T3>
inherited from the asc() method of ColumnOperators

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

between(cleft, cright, symmetric=False)
inherited from the between() method of ColumnOperators

根据父对象,在()子句之间产生一个between()

整理 T0> ( T1> 整理 T2> ) T3> ¶ T4>
inherited from the collate() method of ColumnOperators

根据给定的排序字符串,针对父对象生成一个collate()子句。

的concat T0> ( T1> 其他 T2> ) T3> ¶ T4>
inherited from the concat() method of ColumnOperators

实现'concat'操作符。

在列上下文中,生成子句a || b,或者使用concat()运算符。

包含 其他** kwargs >
inherited from the contains() method of ColumnOperators

实现“包含”运算符。

在列上下文中,生成子句LIKE '%&lt; other&gt;%'

递减 T0> ( T1> ) T2> ¶ T3>
inherited from the desc() method of ColumnOperators

针对父对象生成一个desc()子句。

不同 T0> ( T1> ) T2> ¶ T3>
从 tt> distinct() 方法继承的ColumnOperators

针对父对象生成一个distinct()子句。

endswith other** kwargs t5 >
inherited from the endswith() method of ColumnOperators

实现'endswith'操作符。

在列上下文中,生成子句LIKE '%&lt; other&gt;

criterion = None** kwargs / T5>

如果此元素引用符合给定条件的成员,则返回true。

The usual implementation of has() is RelationshipProperty.Comparator.has().

参数:
  • criterion – an optional ClauseElement formulated against the member class’ table or attributes.
  • **kwargs – key/value pairs corresponding to member class attribute names which will be compared via equality to the corresponding values.
ilike 其他escape =无 t5 >
inherited from the ilike() method of ColumnOperators

实现ilike运算符。

在列上下文中,生成子句a ILIKE 其他

例如。:

select([sometable]).where(sometable.c.column.ilike("%foobar%"))
参数:
  • 其他 - 要比较的表达式
  • 转义 -

    可选的转义字符,呈现ESCAPE关键字,例如:

    somecolumn.ilike("foo/%bar", escape="/")

也可以看看

ColumnOperators.like()

在_ T0> ( T1> 其他 T2> ) T3> ¶ T4>
inherited from the in_() method of ColumnOperators

在运算符中实现in

在列上下文中,生成子句a IN 其他“other”可以是列表达式的元组/列表,或者是一个select()结构。

是_ T0> ( T1> 其他 T2> ) T3> ¶ T4>
inherited from the is_() method of ColumnOperators

实现IS运算符。

正常情况下,当与None的值进行比较时,会自动生成IS,这将解析为NULL但是,如果与某些平台上的布尔值进行比较,则可能需要显式使用IS

New in version 0.7.9.

is_distinct_from T0> ( T1> 其他 T2> ) T3> ¶ T4>
inherited from the is_distinct_from() method of ColumnOperators

实现IS DISTINCT FROM运算符。

在大多数平台上呈现“一个IS DISTINCT FROM b”;在一些如SQLite可能会呈现“一个不是b”。

版本1.1中的新功能

IsNot运算 T0> ( T1> 其他 T2> ) T3> ¶ T4>
inherited from the isnot() method of ColumnOperators

实现IS NOT运算符。

Normally, IS NOT is generated automatically when comparing to a value of None, which resolves to NULL. 然而,明确使用IS NOT,如果与某些平台上的布尔值进行比较可能是可取的。

New in version 0.7.9.

也可以看看

ColumnOperators.is_()

isnot_distinct_from T0> ( T1> 其他 T2> ) T3> ¶ T4>
inherited from the isnot_distinct_from() method of ColumnOperators

实现IS NOT DISTINCT FROM运算符。

在大多数平台上呈现“一个不是从BIND DISTINCT”;在某些如SQLite上可能会呈现“a IS b”。

版本1.1中的新功能

like(other, escape=None)
inherited from the like() method of ColumnOperators

像运算符一样实现like

在列上下文中,生成子句a LIKE 其他

例如。:

select([sometable]).where(sometable.c.column.like("%foobar%"))
参数:
  • 其他 - 要比较的表达式
  • 转义 -

    可选的转义字符,呈现ESCAPE关键字,例如:

    somecolumn.like("foo/%bar", escape="/")
匹配 其他** kwargs t5 >
inherited from the match() method of ColumnOperators

实现数据库特定的“匹配”运算符。

match() attempts to resolve to a MATCH-like function or operator provided by the backend. 例子包括:

  • Postgresql - 呈现x @@ to_tsquery(y)
  • MySQL - renders MATCH (x) AGAINST (y IN BOOLEAN MODE)
  • Oracle - 呈现CONTAINS(x, y)
  • 其他后端可能会提供特殊的实现。
  • 没有任何特殊实现的后端会将操作符发送为“MATCH”。例如,这与SQlite兼容。
notilike(other, escape=None)
inherited from the notilike() method of ColumnOperators

执行NOT ILIKE运算符。

这相当于对ColumnOperators.ilike()使用否定,即~x.ilike(y)

0.8版本中的新功能

notin _ T0> ( T1> 其他 T2> ) T3> ¶ T4>
inherited from the notin_() method of ColumnOperators

执行NOT IN运算符。

这相当于对ColumnOperators.in_(),即~x.in_(y)使用否定。

0.8版本中的新功能

也可以看看

ColumnOperators.in_()

notlike 其他转义=无 t5 >
inherited from the notlike() method of ColumnOperators

执行NOT LIKE运算符。

这等同于使用ColumnOperators.like()的否定,即~x.like(y)

0.8版本中的新功能

也可以看看

ColumnOperators.like()

nullsfirst T0> ( T1> ) T2> ¶ T3>
inherited from the nullsfirst() method of ColumnOperators

针对父对象生成一个nullsfirst()子句。

nullslast T0> ( T1> ) T2> ¶ T3>
inherited from the nullslast() method of ColumnOperators

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

of_type T0> ( T1> 类_ T2> ) T3> ¶ T4>

用多态子类重新定义这个对象。

返回一个新的PropComparator,可以从中进一步评估标准。

例如。:

query.join(Company.employees.of_type(Engineer)).\
   filter(Engineer.name=='foo')
参数:class_ – a class or mapper indicating that criterion will be against this specific subclass.
op opstringprecedence = 0is_comparison = False ) T5> ¶ T6>
继承自 op() 方法的Operators

产生通用的操作员功能。

例如。:

somecolumn.op("*")(5)

生产:

somecolumn * 5

这个函数也可以用来使按位运算符明确。例如:

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

somecolumn中的值的按位与。

参数:
  • operator – a string which will be output as the infix operator between this element and the expression passed to the generated function.
  • 优先级 -

    当对表达式进行加括号时,优先级适用于运算符。较低的数字将使表达式在针对具有较高优先级的另一个运算符应用时加括号。除了逗号(,)和AS运算符以外,0的默认值低于所有运算符。100的值将会高于或等于所有运算符,-100将低于或等于所有运算符。

    新版本0.8: - 添加了“优先”参数。

  • is_comparison -

    如果为True,则运算符将被视为“比较”运算符,即,其值为布尔值true / false,如==>等。应该设置此标志,以便ORM关系可以确定运算符在自定义连接条件中使用时是比较运算符。

    版本0.9.2新增: - 添加了Operators.op.is_comparison标志。

操作 tt> op*其他** kwargs / T5> ¶ T6>
inherited from the operate() method of Operators

操作一个参数。

这是最低级别的操作,默认情况下会引发NotImplementedError

在子类上覆盖这个可以允许将所有的操作都应用到常见的行为上。例如,覆盖ColumnOperatorsfunc.lower()应用于左侧和右侧:

class MyComparator(ColumnOperators):
    def operate(self, op, other):
        return op(func.lower(self), func.lower(other))
参数:
  • op - 操作员可调用。
  • *其他 - 操作的“其他”一侧。将是大多数操作的单一标量。
  • ** kwargs - 修饰符。这些可以由特殊的操作符(如ColumnOperators.contains())传递。
reverse_operate op其他** kwargs T5> ¶ T6>
inherited from the reverse_operate() method of Operators

对参数进行反向操作。

用法与operate()相同。

startswith 其他** kwargs t5 >
inherited from the startswith() method of ColumnOperators

实现startwith运算符。

在列上下文中,生成子句LIKE '&lt; other&gt;%'

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=True, 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, strategy_class=None, _local_remote_pairs=None, query_class=None, info=None)

基础:sqlalchemy.orm.interfaces.StrategizedProperty

描述保存与相关数据库表对应的单个项目或项目列表的对象属性。

公共构造函数是orm.relationship()函数。

也可以看看:

Relationship Configuration

class Comparator(prop, parentmapper, adapt_to_entity=None, of_type=None)

基础:sqlalchemy.orm.interfaces.PropComparator

RelationshipProperty属性生成布尔型,比较型和其他运算符。

有关ORM级别操作符定义的简要概述,请参阅PropComparator的文档。

也可以看看:

PropComparator

ColumnProperty.Comparator

ColumnOperators

Redefining and Creating New Operators

TypeEngine.comparator_factory

__当量__ T0> ( T1> 其他 T2> ) T3> ¶ T4>

实现==运算符。

在多对一的情况下,比如:

MyClass.some_prop == <some object>

这通常会产生一个条款,如:

mytable.related_id == <some id>

其中&lt; some id&gt;是给定对象的主键。

==运算符提供了非多对一比较的部分功能:

  • 不支持与收藏的比较。使用contains()
  • 与标量一对多比较,将生成一个子句,将父级中的目标列与给定的目标进行比较。
  • 与标量多对多相比,关联表的别名也将被渲染,从而形成作为查询主体的一部分的自然连接。这不适用于超出简单和比较连接的查询,比如那些使用OR的查询。使用显式连接,外连接或has()来进行更全面的非多对一标量成员测试。
  • 在一对多或多对多的上下文中给出的None的比较产生一个NOT EXISTS子句。
__init__(prop, parentmapper, adapt_to_entity=None, of_type=None)

RelationshipProperty.Comparator的构造是ORM属性结构的内部。

__文件__ T0> ( T1> 其他 T2> ) T3> ¶ T4>
继承自 __le__() ColumnOperators的方法

实现<=运算符。

在列上下文中,生成子句a b

__ LT __ T0> ( T1> 其他 T2> ) T3> ¶ T4>
inherited from the __lt__() method of ColumnOperators

实现<运算符。

在列上下文中,生成子句a b

__ NE __ T0> ( T1> 其他 T2> ) T3> ¶ T4>

实现!=运算符。

在多对一的情况下,比如:

MyClass.some_prop != <some object>

这通常会产生一个条款,如:

mytable.related_id != <some id>

其中&lt; some id&gt;是给定对象的主键。

!=运算符提供了非多对一比较的部分功能:

  • 不支持与收藏的比较。contains()not_()结合使用。
  • 与标量一对多比较,将生成一个子句,将父级中的目标列与给定的目标进行比较。
  • 与标量多对多相比,关联表的别名也将被渲染,从而形成作为查询主体的一部分的自然连接。这不适用于超出简单和比较连接的查询,比如那些使用OR的查询。为了更全面的非多对一标量成员测试,使用显式连接,外连接或has()not_()
  • 在一对多或多对多的上下文中给出的None的比较产生一个EXISTS子句。
适配器 T0> ¶ T1>
inherited from the adapter attribute of PropComparator

生成一个可调用的列,适应列表达式以适应该比较器的别名版本。

所有_ T0> ( T1> ) T2> ¶ T3>

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

版本1.1中的新功能

任何 criterion = None** kwargs / T5>

根据特定的标准,使用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() is particularly useful for testing for empty collections:

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() is only valid for collections, i.e. a relationship() that has uselist=True. 对于标量引用,请使用has()

任何_ T0> ( T1> ) T2> ¶ T3>
inherited from the any_() method of ColumnOperators

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

版本1.1中的新功能

ASC T0> ( T1> ) T2> ¶ T3>
inherited from the asc() method of ColumnOperators

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

between(cleft, cright, symmetric=False)
inherited from the between() method of ColumnOperators

根据父对象,在()子句之间产生一个between()

整理 T0> ( T1> 整理 T2> ) T3> ¶ T4>
inherited from the collate() method of ColumnOperators

根据给定的排序字符串,针对父对象生成一个collate()子句。

的concat T0> ( T1> 其他 T2> ) T3> ¶ T4>
inherited from the concat() method of ColumnOperators

实现'concat'操作符。

在列上下文中,生成子句a || b,或者使用concat()运算符。

包含 其他** kwargs >

返回一个简单的表达式来测试集合是否包含特定的项目。

contains()仅对集合有效,即relationship()uselist=True

当用于简单的一对多的上下文中时,表达式如下所示:

MyClass.contains(other)

产生一个如下的子句:

mytable.id == <some id>

Where <some id> is the value of the foreign key attribute on other which refers to the primary key of its parent object. 由此可见,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>

Where <some id> would be the primary key of other. From the above, it is clear that contains() will not work with many-to-many collections when used in queries that move beyond simple AND conjunctions, such as multiple contains() expressions joined by OR. 在这种情况下,需要使用子查询或明确的“外连接”。See any() for a less-performant alternative using EXISTS, or refer to Query.outerjoin() as well as Querying with Joins for more details on constructing outer joins.

递减 T0> ( T1> ) T2> ¶ T3>
inherited from the desc() method of ColumnOperators

针对父对象生成一个desc()子句。

不同 T0> ( T1> ) T2> ¶ T3>
从 tt> distinct() 方法继承的ColumnOperators

针对父对象生成一个distinct()子句。

endswith other** kwargs t5 >
inherited from the endswith() method of ColumnOperators

实现'endswith'操作符。

在列上下文中,生成子句LIKE '%&lt; other&gt;

criterion = None** kwargs / T5>

生成一个表达式,使用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() is only valid for scalar references, i.e. a relationship() that has uselist=False. 对于集合引用,请使用any()

ilike 其他escape =无 t5 >
inherited from the ilike() method of ColumnOperators

实现ilike运算符。

在列上下文中,生成子句a ILIKE 其他

例如。:

select([sometable]).where(sometable.c.column.ilike("%foobar%"))
参数:
  • 其他 - 要比较的表达式
  • 转义 -

    可选的转义字符,呈现ESCAPE关键字,例如:

    somecolumn.ilike("foo/%bar", escape="/")

也可以看看

ColumnOperators.like()

在_ T0> ( T1> 其他 T2> ) T3> ¶ T4>

产生一个IN子句 - 目前还没有为relationship()属性实现。

是_ T0> ( T1> 其他 T2> ) T3> ¶ T4>
inherited from the is_() method of ColumnOperators

实现IS运算符。

正常情况下,当与None的值进行比较时,会自动生成IS,这将解析为NULL但是,如果与某些平台上的布尔值进行比较,则可能需要显式使用IS

New in version 0.7.9.

is_distinct_from T0> ( T1> 其他 T2> ) T3> ¶ T4>
inherited from the is_distinct_from() method of ColumnOperators

实现IS DISTINCT FROM运算符。

在大多数平台上呈现“一个IS DISTINCT FROM b”;在一些如SQLite可能会呈现“一个不是b”。

版本1.1中的新功能

IsNot运算 T0> ( T1> 其他 T2> ) T3> ¶ T4>
inherited from the isnot() method of ColumnOperators

实现IS NOT运算符。

Normally, IS NOT is generated automatically when comparing to a value of None, which resolves to NULL. 然而,明确使用IS NOT,如果与某些平台上的布尔值进行比较可能是可取的。

New in version 0.7.9.

也可以看看

ColumnOperators.is_()

isnot_distinct_from T0> ( T1> 其他 T2> ) T3> ¶ T4>
inherited from the isnot_distinct_from() method of ColumnOperators

实现IS NOT DISTINCT FROM运算符。

在大多数平台上呈现“一个不是从BIND DISTINCT”;在某些如SQLite上可能会呈现“a IS b”。

版本1.1中的新功能

like(other, escape=None)
inherited from the like() method of ColumnOperators

像运算符一样实现like

在列上下文中,生成子句a LIKE 其他

例如。:

select([sometable]).where(sometable.c.column.like("%foobar%"))
参数:
  • 其他 - 要比较的表达式
  • 转义 -

    可选的转义字符,呈现ESCAPE关键字,例如:

    somecolumn.like("foo/%bar", escape="/")
映射器 T0> ¶ T1>

RelationshipProperty.Comparator引用的目标Mapper

这是relationship()的“目标”或“远程”端。

匹配 其他** kwargs t5 >
inherited from the match() method of ColumnOperators

实现数据库特定的“匹配”运算符。

match() attempts to resolve to a MATCH-like function or operator provided by the backend. 例子包括:

  • Postgresql - 呈现x @@ to_tsquery(y)
  • MySQL - renders MATCH (x) AGAINST (y IN BOOLEAN MODE)
  • Oracle - 呈现CONTAINS(x, y)
  • 其他后端可能会提供特殊的实现。
  • 没有任何特殊实现的后端会将操作符发送为“MATCH”。例如,这与SQlite兼容。
notilike(other, escape=None)
inherited from the notilike() method of ColumnOperators

执行NOT ILIKE运算符。

这相当于对ColumnOperators.ilike()使用否定,即~x.ilike(y)

0.8版本中的新功能

notin _ T0> ( T1> 其他 T2> ) T3> ¶ T4>
inherited from the notin_() method of ColumnOperators

执行NOT IN运算符。

这相当于对ColumnOperators.in_(),即~x.in_(y)使用否定。

0.8版本中的新功能

也可以看看

ColumnOperators.in_()

notlike 其他转义=无 t5 >
inherited from the notlike() method of ColumnOperators

执行NOT LIKE运算符。

这等同于使用ColumnOperators.like()的否定,即~x.like(y)

0.8版本中的新功能

也可以看看

ColumnOperators.like()

nullsfirst T0> ( T1> ) T2> ¶ T3>
inherited from the nullsfirst() method of ColumnOperators

针对父对象生成一个nullsfirst()子句。

nullslast T0> ( T1> ) T2> ¶ T3>
inherited from the nullslast() method of ColumnOperators

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

of_type T0> ( T1> CLS T2> ) T3> ¶ T4>

生成一个表示父类的特定“子类型”属性的构造。

目前这可以与Query.join()Query.outerjoin()结合使用。

op opstringprecedence = 0is_comparison = False ) T5> ¶ T6>
继承自 op() 方法的Operators

产生通用的操作员功能。

例如。:

somecolumn.op("*")(5)

生产:

somecolumn * 5

这个函数也可以用来使按位运算符明确。例如:

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

somecolumn中的值的按位与。

参数:
  • operator – a string which will be output as the infix operator between this element and the expression passed to the generated function.
  • 优先级 -

    当对表达式进行加括号时,优先级适用于运算符。较低的数字将使表达式在针对具有较高优先级的另一个运算符应用时加括号。除了逗号(,)和AS运算符以外,0的默认值低于所有运算符。100的值将会高于或等于所有运算符,-100将低于或等于所有运算符。

    新版本0.8: - 添加了“优先”参数。

  • is_comparison -

    如果为True,则运算符将被视为“比较”运算符,即,其值为布尔值true / false,如==>等。应该设置此标志,以便ORM关系可以确定运算符在自定义连接条件中使用时是比较运算符。

    版本0.9.2新增: - 添加了Operators.op.is_comparison标志。

操作 tt> op*其他** kwargs / T5> ¶ T6>
inherited from the operate() method of Operators

操作一个参数。

这是最低级别的操作,默认情况下会引发NotImplementedError

在子类上覆盖这个可以允许将所有的操作都应用到常见的行为上。例如,覆盖ColumnOperatorsfunc.lower()应用于左侧和右侧:

class MyComparator(ColumnOperators):
    def operate(self, op, other):
        return op(func.lower(self), func.lower(other))
参数:
  • op - 操作员可调用。
  • *其他 - 操作的“其他”一侧。将是大多数操作的单一标量。
  • ** kwargs - 修饰符。这些可以由特殊的操作符(如ColumnOperators.contains())传递。
reverse_operate op其他** kwargs T5> ¶ T6>
inherited from the reverse_operate() method of Operators

对参数进行反向操作。

用法与operate()相同。

startswith 其他** kwargs t5 >
inherited from the startswith() method of ColumnOperators

实现startwith运算符。

在列上下文中,生成子句LIKE '&lt; other&gt;%'

RelationshipProperty.__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=True, 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, strategy_class=None, _local_remote_pairs=None, query_class=None, info=None)

构建一个新的RelationshipProperty对象。

这个构造函数被镜像为公共API函数;请参阅relationship()以获取完整的用法和参数说明。

RelationshipProperty。 T0> 级联 T1> ¶ T2>

返回RelationshipProperty的当前级联设置。

RelationshipProperty。 T0> class_attribute T1> ¶ T2>
inherited from the class_attribute attribute of MapperProperty

返回对应于这个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
RelationshipProperty extension_type =符号('NOT_EXTENSION')
RelationshipProperty。 T0> 初始化 T1> ( T2> ) T3> ¶ T4>
inherited from the init() method of MapperProperty

在创建所有映射器之后调用,以组合映射器之间的关系并执行其他映射器创建初始化步骤。

RelationshipProperty。 T0> 映射器 T1> ¶ T2>

返回这个RelationshipProperty的目标Mapper

这是一个惰性初始化静态属性。

RelationshipProperty.set_parent(parent, init)
inherited from the set_parent() method of MapperProperty

设置引用此MapperProperty的父映射器。

第一次知道映射器时,这个方法被一些子类覆盖以执行额外的设置。

RelationshipProperty。 T0> 表 T1> ¶ T2>

返回链接到RelationshipProperty对象的目标Mapper的可选项。

从版本0.7开始弃用:使用.target

class sqlalchemy.orm.descriptor_props.SynonymProperty(name, map_column=None, descriptor=None, comparator_factory=None, doc=None, info=None)

基础:sqlalchemy.orm.descriptor_props.DescriptorProperty

__init__(name, map_column=None, descriptor=None, comparator_factory=None, doc=None, info=None)

构建一个新的SynonymProperty对象。

这个构造函数被镜像为公共API函数;有关完整的用法和参数说明,请参阅synonym()

cascade_iterator(type_, state, visited_instances=None, halt_on=None)
inherited from the cascade_iterator() method of MapperProperty

从MapperProperty开始,迭代与给定实例有关的特定“级联”的实例。

返回一个iterator3-tuples(实例,映射器,状态)。

请注意,在调用cascade_iterator之前,首先会检查此MapperProperty上的“级联”集合是否为给定类型。

此方法通常只适用于RelationshipProperty。

class_attribute T0> ¶ T1>
inherited from the class_attribute attribute of MapperProperty

返回对应于这个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)
inherited from the create_row_processor() method of MapperProperty

生成行处理函数并追加到给定的填充器列表集。

do_init T0> ( T1> ) T2> ¶ T3>
inherited from the do_init() method of MapperProperty

执行子类特定的初始化后映射器创建步骤。

这是一个由MapperProperty对象的init()方法调用的模板方法。

extension_type =符号('NOT_EXTENSION')
初始化 T0> ( T1> ) T2> ¶ T3>
inherited from the init() method of MapperProperty

在创建所有映射器之后调用,以组合映射器之间的关系并执行其他映射器创建初始化步骤。

merge(session, source_state, source_dict, dest_state, dest_dict, load, _recursive, _resolve_conflict_map)
inherited from the merge() method of MapperProperty

合并由MapperProperty表示的属性从源到目标对象。

post_instrument_class T0> ( T1> 映射器 T2> ) T3> ¶ T4>
inherited from the post_instrument_class() method of MapperProperty

执行init()完成后需要进行的仪器调整。

给定的Mapper是调用操作的Mapper,在继承场景中可能不是与self.parent相同的Mapper;然而,Mapper将总是至少成为self.parent的子映射器。

这个方法通常由StrategizedProperty使用,它将其委托给LoaderStrategy.init_class_attribute()来对类绑定的InstrumentedAttribute执行最终的设置。

setup(context, entity, path, adapter, **kwargs)
inherited from the setup() method of MapperProperty

由Query调用以构造SQL语句。

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

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属性进行访问。

__当量__ T0> ( T1> 其他 T2> ) T3> ¶ T4>

实现==运算符。

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

__文件__ T0> ( T1> 其他 T2> ) T3> ¶ T4>
继承自 __le__() ColumnOperators的方法

实现<=运算符。

在列上下文中,生成子句a b

__ LT __ T0> ( T1> 其他 T2> ) T3> ¶ T4>
inherited from the __lt__() method of ColumnOperators

实现<运算符。

在列上下文中,生成子句a b

__ NE __ T0> ( T1> 其他 T2> ) T3> ¶ T4>

实现!=运算符。

在列上下文中,生成子句a != bIf the target is None, produces a IS NOT NULL.

适配器 T0> ¶ T1>
inherited from the adapter attribute of PropComparator

生成一个可调用的列,适应列表达式以适应该比较器的别名版本。

所有_ T0> ( T1> ) T2> ¶ T3>

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

版本1.1中的新功能

任何 criterion = None** kwargs / T5>
inherited from the any() method of PropComparator

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

any()的通常实现是RelationshipProperty.Comparator.any()

参数:
  • criterion – an optional ClauseElement formulated against the member class’ table or attributes.
  • **kwargs – key/value pairs corresponding to member class attribute names which will be compared via equality to the corresponding values.
任何_ T0> ( T1> ) T2> ¶ T3>
inherited from the any_() method of ColumnOperators

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

版本1.1中的新功能

ASC T0> ( T1> ) T2> ¶ T3>
inherited from the asc() method of ColumnOperators

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

between(cleft, cright, symmetric=False)
inherited from the between() method of ColumnOperators

根据父对象,在()子句之间产生一个between()

整理 T0> ( T1> 整理 T2> ) T3> ¶ T4>
inherited from the collate() method of ColumnOperators

根据给定的排序字符串,针对父对象生成一个collate()子句。

的concat T0> ( T1> 其他 T2> ) T3> ¶ T4>
inherited from the concat() method of ColumnOperators

实现'concat'操作符。

在列上下文中,生成子句a || b,或者使用concat()运算符。

包含 其他** kwargs >
inherited from the contains() method of ColumnOperators

实现“包含”运算符。

在列上下文中,生成子句LIKE '%&lt; other&gt;%'

递减 T0> ( T1> ) T2> ¶ T3>
inherited from the desc() method of ColumnOperators

针对父对象生成一个desc()子句。

不同 T0> ( T1> ) T2> ¶ T3>
从 tt> distinct() 方法继承的ColumnOperators

针对父对象生成一个distinct()子句。

endswith other** kwargs t5 >
inherited from the endswith() method of ColumnOperators

实现'endswith'操作符。

在列上下文中,生成子句LIKE '%&lt; other&gt;

extension_type =符号('NOT_EXTENSION')
criterion = None** kwargs / T5>
inherited from the has() method of PropComparator

如果此元素引用符合给定条件的成员,则返回true。

The usual implementation of has() is RelationshipProperty.Comparator.has().

参数:
  • criterion – an optional ClauseElement formulated against the member class’ table or attributes.
  • **kwargs – key/value pairs corresponding to member class attribute names which will be compared via equality to the corresponding values.
ilike 其他escape =无 t5 >
inherited from the ilike() method of ColumnOperators

实现ilike运算符。

在列上下文中,生成子句a ILIKE 其他

例如。:

select([sometable]).where(sometable.c.column.ilike("%foobar%"))
参数:
  • 其他 - 要比较的表达式
  • 转义 -

    可选的转义字符,呈现ESCAPE关键字,例如:

    somecolumn.ilike("foo/%bar", escape="/")

也可以看看

ColumnOperators.like()

在_ T0> ( T1> 其他 T2> ) T3> ¶ T4>
inherited from the in_() method of ColumnOperators

在运算符中实现in

在列上下文中,生成子句a IN 其他“other”可以是列表达式的元组/列表,或者是一个select()结构。

信息 T0> ¶ T1>

返回底层SQL元素的'info'字典。

这里的行为如下:

0.8.0版本中的新功能

是_ T0> ( T1> 其他 T2> ) T3> ¶ T4>
inherited from the is_() method of ColumnOperators

实现IS运算符。

正常情况下,当与None的值进行比较时,会自动生成IS,这将解析为NULL但是,如果与某些平台上的布尔值进行比较,则可能需要显式使用IS

New in version 0.7.9.

is_distinct_from T0> ( T1> 其他 T2> ) T3> ¶ T4>
inherited from the is_distinct_from() method of ColumnOperators

实现IS DISTINCT FROM运算符。

在大多数平台上呈现“一个IS DISTINCT FROM b”;在一些如SQLite可能会呈现“一个不是b”。

版本1.1中的新功能

IsNot运算 T0> ( T1> 其他 T2> ) T3> ¶ T4>
inherited from the isnot() method of ColumnOperators

实现IS NOT运算符。

Normally, IS NOT is generated automatically when comparing to a value of None, which resolves to NULL. 然而,明确使用IS NOT,如果与某些平台上的布尔值进行比较可能是可取的。

New in version 0.7.9.

也可以看看

ColumnOperators.is_()

isnot_distinct_from T0> ( T1> 其他 T2> ) T3> ¶ T4>
inherited from the isnot_distinct_from() method of ColumnOperators

实现IS NOT DISTINCT FROM运算符。

在大多数平台上呈现“一个不是从BIND DISTINCT”;在某些如SQLite上可能会呈现“a IS b”。

版本1.1中的新功能

like(other, escape=None)
inherited from the like() method of ColumnOperators

像运算符一样实现like

在列上下文中,生成子句a LIKE 其他

例如。:

select([sometable]).where(sometable.c.column.like("%foobar%"))
参数:
  • 其他 - 要比较的表达式
  • 转义 -

    可选的转义字符,呈现ESCAPE关键字,例如:

    somecolumn.like("foo/%bar", escape="/")
匹配 其他** kwargs t5 >
inherited from the match() method of ColumnOperators

实现数据库特定的“匹配”运算符。

match() attempts to resolve to a MATCH-like function or operator provided by the backend. 例子包括:

  • Postgresql - 呈现x @@ to_tsquery(y)
  • MySQL - renders MATCH (x) AGAINST (y IN BOOLEAN MODE)
  • Oracle - 呈现CONTAINS(x, y)
  • 其他后端可能会提供特殊的实现。
  • 没有任何特殊实现的后端会将操作符发送为“MATCH”。例如,这与SQlite兼容。
notilike(other, escape=None)
inherited from the notilike() method of ColumnOperators

执行NOT ILIKE运算符。

这相当于对ColumnOperators.ilike()使用否定,即~x.ilike(y)

0.8版本中的新功能

notin _ T0> ( T1> 其他 T2> ) T3> ¶ T4>
inherited from the notin_() method of ColumnOperators

执行NOT IN运算符。

这相当于对ColumnOperators.in_(),即~x.in_(y)使用否定。

0.8版本中的新功能

也可以看看

ColumnOperators.in_()

notlike 其他转义=无 t5 >
inherited from the notlike() method of ColumnOperators

执行NOT LIKE运算符。

这等同于使用ColumnOperators.like()的否定,即~x.like(y)

0.8版本中的新功能

也可以看看

ColumnOperators.like()

nullsfirst T0> ( T1> ) T2> ¶ T3>
inherited from the nullsfirst() method of ColumnOperators

针对父对象生成一个nullsfirst()子句。

nullslast T0> ( T1> ) T2> ¶ T3>
inherited from the nullslast() method of ColumnOperators

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

op opstringprecedence = 0is_comparison = False ) T5> ¶ T6>
继承自 op() 方法的Operators

产生通用的操作员功能。

例如。:

somecolumn.op("*")(5)

生产:

somecolumn * 5

这个函数也可以用来使按位运算符明确。例如:

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

somecolumn中的值的按位与。

参数:
  • operator – a string which will be output as the infix operator between this element and the expression passed to the generated function.
  • 优先级 -

    当对表达式进行加括号时,优先级适用于运算符。较低的数字将使表达式在针对具有较高优先级的另一个运算符应用时加括号。除了逗号(,)和AS运算符以外,0的默认值低于所有运算符。100的值将会高于或等于所有运算符,-100将低于或等于所有运算符。

    新版本0.8: - 添加了“优先”参数。

  • is_comparison -

    如果为True,则运算符将被视为“比较”运算符,即,其值为布尔值true / false,如==>等。应该设置此标志,以便ORM关系可以确定运算符在自定义连接条件中使用时是比较运算符。

    版本0.9.2新增: - 添加了Operators.op.is_comparison标志。

父 T0> ¶ T1>

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

这将是MapperAliasedInsp的一个实例,具体取决于该属性所关联的父实体的性质。

属性 T0> ¶ T1>

返回与这个QueryableAttribute关联的MapperProperty

这里的返回值通常是ColumnPropertyRelationshipProperty的实例。

startswith 其他** kwargs t5 >
inherited from the startswith() method of ColumnOperators

实现startwith运算符。

在列上下文中,生成子句LIKE '&lt; other&gt;%'

class sqlalchemy.orm.session.UOWTransaction(session)
filter_states_for_dep(dep, states)

将InstanceState的给定列表筛选为与给定的DependencyProcessor相关的列表。

finalize_flush_changes T0> ( T1> ) T2> ¶ T3>

在成功刷新()后将处理的对象标记为干净/删除。

在execute()方法成功且事务已提交之后,在flush()方法内调用此方法。

get_attribute_history(state, key, passive=symbol('PASSIVE_NO_INITIALIZE'))

外观到attributes.get_state_history(),包括缓存结果。

IS_DELETED T0> ( T1> 状态 T2> ) T3> ¶ T4>

如果在此uowtransaction中给定状态标记为已删除,则返回true。

remove_state_actions T0> ( T1> 状态 T2> ) T3> ¶ T4>

从uowtransaction中移除一个状态的挂起的动作。

was_already_deleted T0> ( T1> 状态 T2> ) T3> ¶ T4>

如果给定的状态已过期并且之前被删除,则返回true。