SQLAlchemy技术文书档案

11.``操作主外键关联的对象

http://www.cnblogs.com/iwangzc/category/620910.html

 

即使注明的主意已经起来采纳,relationship()花潮其他类关联的参数能够透过strings钦命。在上文的User类中,一旦有所映射成功,为了产生实际的参数,那几个字符串会被看做Python的表明式。下面是多少个在User类中开创双向沟通的例子:

构造类和外键简单,就不过多赘述。主要说明以下``relationship()``函数:这个函数告诉``ORM``,``Address``类应该和``User``类连接起来,通过使用``addresses.user``。``relationship()``使用外键明确这两张表的关系。决定``Adderess.user``属性是多对一的。``relationship()``的子函数``backref()``提供表达反向关系的细节:``relationship()``对象的集合被``User.address``引用。多对一的反向关系总是一对多。更多的细节参考Basic
Rel
Rational
Patterns
``。

as()``(用在标量?不在集合中):

是时候考虑怎样映射和查询一个和``Users``表关联的第二张表了。假设我们系统的用户可以存储任意数量的``email``地址。我们需要定义一个新表``Address``与``User``相关联。

>>>for name, in session.query(User.name).\

...

filter(User.addresses.any(Address.email_address.like('%google%'))):


...
    print name

jack

has()``(用在标量?不在集合中):

现行反革命能够直接在User对象中添加Address对象。只须要钦点二个全体的列表:

 

Any()``(用于集合中):

现在我们已经在``User``类中创建了一个空的``addresser``集合,可变集合类型,例如``set``和``dict``,都可以用,但是默认的集合类型是``list``。

外键约束假设是指向五个列的主键,并且它自身也兼具多列,那种被号称“复合外键”。

query.filter(User.addresses.any(Address.email_address == 'bar'))#also takes keyword arguments:
query.filter(User.addresses.any(email_address='bar'))

any()``限制行匹配:

在超越三分之二的外键约束(就算不是颇具的)关周到据库只可以链接到三个主键列,或具备唯一约束的列。

在大多数的外键约束(纵然不是具有的)关系数据库只好链接到二个主键列,或具备唯一约束的列。

 

一对文化:

12.1使用别名

当在多个表中查询时,如果同一张表需要被引用好几次,SQL通常要求对这个表起一个别名,因此,SQL可以区分对这个表进行的其他操作。Query也支持别名的操作。下面我们joinAddress实体两次,找到同时拥有两个不同email的用户:

>>>from sqlalchemy.ormimport aliased
>>>adalias1 = aliased(Address)
>>>adalias2 = aliased(Address)
>>>for username, email1, email2 in\
...
    session.query(User.name,adalias1.email_address,adalias2.email_address).\
...
    join(adalias1, User.addresses).\
...
    join(adalias2, User.addresses).\
...
    filter(adalias1.email_address=='jack@google.com').\
...
    filter(adalias2.email_address=='j25@yahoo.com'):
...
    print username, email1,
email2      
jack
jack@google.com j25@yahoo.com

笔者们供给在数据库中开创3个addresses表,所以我们会成立另叁个元数据,这将会跳过曾经创办的表。

has()``和``any()``一样在应对多对一关系的情况下(注意“~“意味着”``NOT”``)

class User(Base):

addresses = relationship("Address", order_by="Address.id", backref="user")

 

`=== None都以用在多对一中,而contains()用在一对多的集合中:`

 

现在我们已经在``User``类中创建了一个空的``addresser``集合,可变集合类型,例如``set``和``dict``,都可以用,但是默认的集合类型是``list``。

10.``建立联系(外键)

等价于:

12.4 ``常见的关系运算符

外键可以参考自身的报表。那种被称作“自引”外键。

`=== None都以用在多对一中,而contains()用在一对多的联谊中:`

from sqlalchemyimport ForeignKey

from sqlalchemy.ormimport relationship, backref

class Address(Base):

__tablename__ = 'addresses'

id= Column(Integer, primary_key=True)

email_address = Column(String, nullable=False)

user_id = Column(Integer, ForeignKey('users.id'))

user = relationship("User", backref=backref('addresses',order_by=id))

def__repr__(self):

    return"<Address(email_address='%s')>"%self.email_address

any()``限制行匹配:

10.``建立联系(外键)

>>>for name, in session.query(User.name).\
...

filter(User.addresses.any(Address.email_address.like('%google%'))):

...
    print name
jack

这两个互补关系:``Address.user``和``User.addresses``被称为双向关系。这是``SQLAlchemy ORM``的一个非常关键的功能。更多关系``backref``的细节参见Linking
Relationships with
Backref

 

query.filter(Address.user.has(name='ed'))

 

13 ``预先加载(跟性能有关)和``lazy loading``相对,建议直接查看文档吧

query.filter(Address.user.has(name='ed'))
session.query(Address).with_parent(someuser,'addresses')

12.3使用EXISTS(存在?)

>>>for name, in session.query(User.name).\

...
   filter(User.addresses.any()):


...
    print name

jack

外键列能够自动更新本人来对号入座它所引述的行依旧列。那被号称级联,是一种建立在关周详据库的机能。

jack = User(name='jack', fullname='Jack Bean', password='gjffdd')

jack.addresses

[]
class User(Base):
addresses = relationship("Address", order_by="Address.id", backref="user")
query.filter(Address.user == someuser)

query.filter(User.addresses.contains(someaddress))
session.query(Address).with_parent(someuser,'addresses')

has()``和``any()``一样在应对多对一关系的情况下(注意“~“意味着”``NOT”``)

 

Query.with_parent()``(所有关系都适用):

>>>from sqlalchemy.sqlimport exists
>>>
stmt = exists().where(Address.user_id==User.id)
>>>for name, in session.query(User.name).filter(stmt):
    print name
jack
>>> session.query(Address).\

...
        filter(~Address.user.has(User.name=='jack')).all()

[]

 

query.filter(User.addresses.any(Address.email_address == 'bar'))#also takes keyword arguments:

query.filter(User.addresses.any(email_address='bar'))

 

如果表达式返回任何行``,``EXISTS``为真,这是一个布尔值。它可以用在``jions``中,也可以用来定位在一个关系表中没有相应行的情况:

如果表达式返回任何行``,``EXISTS``为真,这是一个布尔值。它可以用在``jions``中,也可以用来定位在一个关系表中没有相应行的情况:

构造类和外键简单,就不过多赘述。主要说明以下``relationship()``函数:这个函数告诉``ORM``,``Address``类应该和``User``类连接起来,通过使用``addresses.user``。``relationship()``使用外键明确这两张表的关系。决定``Adderess.user``属性是多对一的。``relationship()``的子函数``backref()``提供表达反向关系的细节:``relationship()``对象的集合被``User.address``引用。多对一的反向关系总是一对多。更多的细节参考Basic
Rel
Rational
Patterns
``。

这两个互补关系:``Address.user``和``User.addresses``被称为双向关系。这是``SQLAlchemy ORM``的一个非常关键的功能。更多关系``backref``的细节参见Linking
Relationships with
Backref

12.4 ``常见的关系运算符

外键能够参照自个儿的报表。那种被誉为“自引”外键。

是时候考虑怎样映射和查询一个和``Users``表关联的第二张表了。假设我们系统的用户可以存储任意数量的``email``地址。我们需要定义一个新表``Address``与``User``相关联。

 

待补充。。。

一对知识:

12.3使用EXISTS(存在?)

当使用双向关系时,元素在一个类中被添加后便会自动在另一个类中添加。这种行为发生在Python的更改事件属性中而不是用SQL语句:

>>> jack.addresses[1]
<Address(email_address='j25@yahoo.com')>
>>> jack.addresses[1].user
<User(name='jack', fullname='Jack Bean', password='gjffdd')>

11.``操作主外键关联的对象

等价于:

jack.addresses = [Address(email_address='jack@google.com'),Address(email_address='j25@yahoo.com')]

当使用双向关系时,元素在一个类中被添加后便会自动在另一个类中添加。这种行为发生在Python的更改事件属性中而不是用SQL语句:

>>> jack.addresses[1]

<Address(email_address='j25@yahoo.com')>

>>> jack.addresses[1].user

<User(name='jack', fullname='Jack Bean', password='gjffdd')>

把jack提交到数据库中,再次查询Jack,(No SQL is yet issued for Jack’s addresses:)这句实在是翻译不了了,看看代码就明白是什么意思:

>>> jack = session.query(User).\
...

filter_by(name='jack').one()

>>> jack

<User(name='jack',fullname='Jack Bean', password='gjffdd')>

>>>jack.addresses 

[<Address(email_address='jack@google.com')>,
<Address(email_address='j25@yahoo.com')>]

当我们访问uaddresses集合时,SQL会被突然执行,这是一个延迟加载(lazy loading)关系的典型例子。现在addresses集合加载完成并且可以像对待普通列表一样对其进行操作。以后我们会优化这种加载方式。

12.使用JOINS查询

现在我们有了两张表,可以进行更多的查询操作,特别是怎样对两张表同时进行查询,Wikipediapage on SQL JOIN提供了很详细的说明,其中一些我们将在这里说明。之前用Query.filter()时,我们已经用过JOIN了,filter是一种简单的隐式join:

>>>for u, a in session.query(User, Address).filter(User.id==Address.user_id).filter(Address.email_address=='jack@google.com').all():   

    print u

    print a

<User(name='jack',fullname='JackBean', password='gjffdd')>

<Address(email_address='jack@google.com')>

用Query.join()方法会更加简单:

>>>session.query(User).join(Address).\

...
    filter(Address.email_address=='jack@google.com').\

...
    all() 

[<User(name='jack',fullname='JackBean', password='gjffdd')>]

之所以Query.join()知道怎么join两张表是因为它们之间只有一个外键。如果两张表中没有外键或者有一个以上的外键,当下列几种形式使用的时候,Query.join()可以表现的更好:

query.join(Address,User.id==Address.user_id)# 明确的条件

query.join(User.addresses)# 指定从左到右的关系

query.join(Address,User.addresses)    #同样,有明确的目标

query.join('addresses') # 同样,使用字符串

    outerjoin()和join()用法相同

query.outerjoin(User.addresses)# LEFT OUTER JOIN

12.1使用别名

当在多个表中查询时,如果同一张表需要被引用好几次,SQL通常要求对这个表起一个别名,因此,SQL可以区分对这个表进行的其他操作。Query也支持别名的操作。下面我们joinAddress实体两次,找到同时拥有两个不同email的用户:

>>>from sqlalchemy.ormimport aliased

>>>adalias1 = aliased(Address)

>>>adalias2 = aliased(Address)

>>>for username, email1, email2 in\

...
    session.query(User.name,adalias1.email_address,adalias2.email_address).\

...
    join(adalias1, User.addresses).\

...
    join(adalias2, User.addresses).\

...
    filter(adalias1.email_address=='jack@google.com').\

...
    filter(adalias2.email_address=='j25@yahoo.com'):

...
    print username, email1,
email2      

jack
jack@google.com j25@yahoo.com

12.1使用子查询(暂时理解不了啊,多看代码研究吧:()

from sqlalchemy.sqlimport func

stmt = session.query(Address.user_id,func.count('*').\

...
        label('address_count')).\

...
        group_by(Address.user_id).subquery()

>>>
for u, count in session.query(User,stmt.c.address_count).\

...
    outerjoin(stmt, User.id==stmt.c.user_id).order_by(User.id):

    print u, count

<User(name='ed',fullname='EdJones', password='f8s7ccs')>
None

<User(name='wendy',fullname='Wendy Williams', password='foobar')>
None

<User(name='mary',fullname='Mary Contrary', password='xxg527')>
None

<User(name='fred',fullname='Fred Flinstone', password='blah')>
None

<User(name='jack',fullname='Jack Bean', password='gjffdd')>
2

12.2从子查询中选择实体?

上面的代码中我们只返回了包含子查询的一个列的结果。如果想要子查询映射到一个实体的话,使用aliased()设置一个要映射类的子查询别名:

>>>
stmt = session.query(Address).\

...
     filter(Address.email_address!= 'j25@yahoo.com').\

...
     subquery()

>>>
adalias = aliased(Address, stmt)
#?为什么有两个参数?

>>>
for user, address in session.query(User, adalias).\

...
        join(adalias, User.addresses): 

...
    print user

...
    print address

<User(name='jack',fullname='Jack Bean', password='gjffdd')>

<Address(email_address='jack@google.com')>

外键约束如若是指向三个列的主键,并且它自己也兼具多列,那种被号称“复合外键”。

外键列能够自动更新本人来对号入座它所引述的行依旧列。这被叫做级联,是一种建立在关周详据库的意义。

 

>>>from sqlalchemy.sqlimport exists

>>>
stmt = exists().where(Address.user_id==User.id)

>>>for name, in session.query(User.name).filter(stmt):

    print name

jack
之所以Query.join()知道怎么join两张表是因为它们之间只有一个外键。如果两张表中没有外键或者有一个以上的外键,当下列几种形式使用的时候,Query.join()可以表现的更好:

query.join(Address,User.id==Address.user_id)# 明确的条件
query.join(User.addresses)# 指定从左到右的关系
query.join(Address,User.addresses)    #同样,有明确的目标
query.join('addresses') # 同样,使用字符串
    outerjoin()和join()用法相同
query.outerjoin(User.addresses)# LEFT OUTER JOIN
当我们访问uaddresses集合时,SQL会被突然执行,这是一个延迟加载(lazy loading)关系的典型例子。现在addresses集合加载完成并且可以像对待普通列表一样对其进行操作。以后我们会优化这种加载方式。

12.使用JOINS查询

现在我们有了两张表,可以进行更多的查询操作,特别是怎样对两张表同时进行查询,Wikipediapage on SQL JOIN提供了很详细的说明,其中一些我们将在这里说明。之前用Query.filter()时,我们已经用过JOIN了,

filter是一种简单的隐式join:

>>>for u, a in session.query(User, Address).filter(User.id==Address.user_id).filter(Address.email_address=='jack@google.com').all():   
    print u
    print a
<User(name='jack',fullname='JackBean', password='gjffdd')>
<Address(email_address='jack@google.com')>

我们须要在数据库中开创多个addresses表,所以大家会创设另三个元数据,那将会跳过曾经创办的表。

 

未来得以一向在User对象中添加Address对象。只供给钦赐三个完完全全的列表:

 

query.filter(Address.user == someuser)
query.filter(User.addresses.contains(someaddress))
jack.addresses = [Address(email_address='jack@google.com'),Address(email_address='j25@yahoo.com')]
用Query.join()方法会更加简单:

>>>session.query(User).join(Address).\
...
    filter(Address.email_address=='jack@google.com').\
...
    all() 
[<User(name='jack',fullname='JackBean', password='gjffdd')>]
把jack提交到数据库中,再次查询Jack,(No SQL is yet issued for Jack’s addresses:)这句实在是翻译不了了,看看代码就明白是什么意思:

>>> jack = session.query(User).\
...
filter_by(name='jack').one()

>>> jack
<User(name='jack',fullname='Jack Bean', password='gjffdd')>


>>>jack.addresses 
[<Address(email_address='jack@google.com')>,
<Address(email_address='j25@yahoo.com')>]
jack = User(name='jack', fullname='Jack Bean', password='gjffdd')
jack.addresses
[]
>>>for name, in session.query(User.name).\
...
   filter(User.addresses.any()):

...
    print name
jack
12.1使用子查询(暂时理解不了啊,多看代码研究吧:()

from sqlalchemy.sqlimport func
stmt = session.query(Address.user_id,func.count('*').\
...
        label('address_count')).\
...
        group_by(Address.user_id).subquery()
>>>
for u, count in session.query(User,stmt.c.address_count).\
...
    outerjoin(stmt, User.id==stmt.c.user_id).order_by(User.id):
    print u, count
<User(name='ed',fullname='EdJones', password='f8s7ccs')>
None
<User(name='wendy',fullname='Wendy Williams', password='foobar')>
None
<User(name='mary',fullname='Mary Contrary', password='xxg527')>
None
<User(name='fred',fullname='Fred Flinstone', password='blah')>
None
<User(name='jack',fullname='Jack Bean', password='gjffdd')>
2

 

Query.with_parent()``(所有关系都适用):

12.2从子查询中选择实体?

上面的代码中我们只返回了包含子查询的一个列的结果。如果想要子查询映射到一个实体的话,使用aliased()设置一个要映射类的子查询别名:

>>>
stmt = session.query(Address).\

...
     filter(Address.email_address!= 'j25@yahoo.com').\

...
     subquery()

>>>
adalias = aliased(Address, stmt)
#?为什么有两个参数?

>>>
for user, address in session.query(User, adalias).\

...
        join(adalias, User.addresses): 

...
    print user

...
    print address

<User(name='jack',fullname='Jack Bean', password='gjffdd')>

<Address(email_address='jack@google.com')>

Any()``(用于集合中):

>>> session.query(Address).\
...
        filter(~Address.user.has(User.name=='jack')).all()

[]
from sqlalchemyimport ForeignKey

from sqlalchemy.orm import relationship, backref
class Address(Base):
__tablename__ = 'addresses'
id= Column(Integer, primary_key=True)
email_address = Column(String, nullable=False)
user_id = Column(Integer, ForeignKey('users.id'))
user = relationship("User", backref=backref('addresses',order_by=id))
def __repr__(self):
    return"<Address(email_address='%s')>"%self.email_address

 

 

 

要是表明的不二法门已经上马接纳,relationship()中和任何类关联的参数能够通过strings钦赐。在上文的User类中,一旦有所映射成功,为了发生实际的参数,那些字符串会被视作Python的表明式。上面是二个在User类中开创双向沟通的例证: