SQLAlchemy技艺文档(汉语版)-下

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

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

原来的书文链接:http://www.cnblogs.com/iwangzc/p/4112078.html(感谢作者的分享)

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

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

sqlalchemy
官方文档:http://docs.sqlalchemy.org/en/latest/contents.html

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

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

一.本子检查

 

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
import sqlalchemy

sqlalchemy.__version__

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

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

2.连接

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

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

from sqlalchemy import create_engine

engine = create_engine('sqlite:///:memory:',echo=True)

若果申明的点子已经开始选用,relationship()四之日其他类关联的参数可以经过strings钦赐。在上文的User类中,一旦具有映射成功,为了发出实际的参数,那几个字符串会被当作Python的表明式。下边是3个在User类中开创双向交流的例子:

倘若注脚的格局已经起来接纳,relationship()四之日别的类关联的参数能够由此strings内定。在上文的User类中,1旦具有映射成功,为了发出实际的参数,这么些字符串会被看成Python的表达式。上边是三个在User类中创设双向调换的事例:

echo参数为True时,会议及展览示每条实行的SQL语句,能够关闭。create_engine()重返三个Engine的实例,并且它代表通过数据库语法管理细节的骨干接口,在这种状态下,数据库语法将会被解释称Python的类措施。

class User(Base):
addresses = relationship("Address", order_by="Address.id", backref="user")
class User(Base):

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

③.申明影像

 

局地知识:

当使用O宝马X5M【一】时,构造进度首先描述数据库的表,然后定义我们用来映射那一个表的类。在现版本的SQLAlchemy中,那五个职责日常一齐执行,通过选取Declarative方法,大家能够创制一些饱含描述要被映射的实际数据库表的轨道的映射类。

一对文化:

在许多的外键约束(就算不是怀有的)关系数据库只可以链接到四个主键列,或具备唯一约束的列。

行使Declarative方法定义的映射类依靠三个基类,这么些基类是维系类和数据表关系的目录——我们所说的Declarative base
class。在三个普通的模块入口中,应用普通只供给有三个base的实例。大家通过declarative_base()效能创造3个基类:

在大大多的外键约束(即使不是持有的)关周全据库只可以链接到一个主键列,或富有唯壹约束的列。

外键约束要是是指向多少个列的主键,并且它本人也持有多列,这种被称为“复合外键”。

from sqlalchemy.ext.declarativeimportdeclarative_base

Base = declarative_base()

外键约束借使是指向五个列的主键,并且它本身也保有多列,这种被叫作“复合外键”。

外键列能够自动更新本人来对号入座它所引用的行仍旧列。那被叫作级联,是1种建设构造在关周到据库的功用。

有了那一个base,大家得以依赖这么些base定义自便数量的映射类。贰个轻巧易行的user例子:

外键列能够自动更新自个儿来对号入座它所引述的行照旧列。那被称为级联,是一种建构在关全面据库的功力。

外键能够参见本身的表格。这种被叫作“自引”外键。

from sqlalchemy import Column, Integer, String

class User(Base):

__tablename__= 'users'

id= Column(Integer, primary_key=True)

name = Column(String)

外键能够参见自个儿的表格。这种被誉为“自引”外键。

大家须求在数据库中创设几个addresses表,所以咱们会成立另1个元数据,那将会跳过曾经创办的表。

用Declarative构造的二个类至少供给多少个__tablename__性格,一个主键行。

我们供给在数据库中开创二个addresses表,所以大家会创设另多个元数据,那将会跳过曾经创造的表。

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

四.构造格局(项目中没用到)

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

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

伍.创办映射类的实例

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

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

jack.addresses

[]
ed_user = User(name='ed',fullname='Ed Jones', password='edspassword')
jack = User(name='jack', fullname='Jack Bean', password='gjffdd')
jack.addresses
[]

今后得以从来在User对象中增多Address对象。只须要钦赐一个全体的列表:

6.创办会话

 

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')>

当今大家已经筹划毫和数据库早先会话了。OKoleosM通过Session与数据库建构连接的。当使用第三次载入时,我们定义三个Session类(注脚create_engine()的同期),这一个Session类为新的Session对象提供工厂劳动。

以往得以一贯在User对象中增加Address对象。只必要钦赐二个完全的列表:

12.3使用EXISTS(存在?)

from sqlalchemy.orm import sessionmaker

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

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

那个定制的Session类会创制绑定到数据库的Session对象。假诺须求和数据库创建连接,只要求实例化叁个Session:

 

>>>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 = Session()
当使用双向关系时,元素在一个类中被添加后便会自动在另一个类中添加。这种行为发生在Python的更改事件属性中而不是用SQL语句:

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

等价于:

固然如此上边包车型大巴Session已经和数据库引擎Engine关联,不过还未曾展开任何连接。当它首先次被选择时,就能从Engine维护的多个连接池中寻找是不是存在连接,假如存在便会保持两次三番知道我们付出全数更换并且/或然关闭session对象。

 

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

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


...
    print name

jack

柒.加多新目的(简略)

把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')>]

any()``限制行匹配:

ed_user = User(name='ed', fullname='Ed Jones', password='edspassword')

session.add(ed_user)

 

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

...

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


...
    print name

jack

从那之后,我们能够认为,新加上的那些目标实例仍在伺机中;ed_user对象未来并不意味着数据库中的壹行数据。直到使用flush进度,Session才会让SQL保持三番五次。如果查询那条数据的话,全体等待音讯会被第有的时候间刷新,查询结果也会立时发行。

当我们访问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')>

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

session.commit()

 

>>> session.query(Address).\

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

[]

由此commit()能够交到全数盈余的更改到数据库。

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

>>>session.query(User).join(Address).\
...
    filter(Address.email_address=='jack@google.com').\
...
    all() 
[<User(name='jack',fullname='JackBean', password='gjffdd')>]

12.4 ``常见的关系运算符

8.回滚

 

`=== None都是用在多对一中,而contains()用在1对多的群集中:`

session.rollback()
之所以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
query.filter(Address.user == someuser)

query.filter(User.addresses.contains(someaddress))

9.查询

 

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

由此Session的query()方法创设3个查询对象。那个函数的参数数量是可变的,参数能够是其它类如故是类的描述的集合。上面是1个迭代输出User类的事例:

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
query.filter(User.addresses.any(Address.email_address == 'bar'))#also takes keyword arguments:

query.filter(User.addresses.any(email_address='bar'))
for instance in session.query(User).order_by(User.id):

print instance.name,instance.fullname

 

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

Query也支撑O福睿斯M描述作为参数。任哪天候,八个类的实业或许是依据列的实体说明都得以视作query()函数的参数,重回类型是元组:

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.filter(Address.user.has(name='ed'))
for name, fullname in session.query(User.name,User.fullname): 

print name, fullname

 

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

Query再次回到的元组被取名字为KeyedTuple类的实例元组。并且能够把它便是三个平日的Python数据类操作。元组的名字就一定于属性的属性名,类的类名一样。

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')>
session.query(Address).with_parent(someuser,'addresses')
for row in session.query(User, User.name).all():

print row.User,row.name

<User(name='ed',fullname='Ed Jones', password='f8s7ccs')>ed

12.3使用EXISTS(存在?)

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

label()不驾驭怎么解释,看下例子就知道了。相当于row.name

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

待补充。。。

for row in session.query(User.name.label('name_label')).all():

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

aliased()笔者的敞亮是类的小名,要是有五个实体都要询问多少个类,能够用aliased()

 

from sqlalchemy.orm import aliased

user_alias = aliased(User, name='user_alias')

for row in session.query(user_alias,user_alias.name).all():

print row.user_alias

等价于:

Query的
基本操作包含LIMIT和OFFSET,使用Python数组切成块和O猎豹CS六DERBY结合能够让操作变得很有益。

>>>for name, in session.query(User.name).\
...
   filter(User.addresses.any()):

...
    print name
jack
for u in session.query(User).order_by(User.id)[1:3]:

#只查询第二条和第三条数据

 

9.一运用重要字变量过滤查询结果,filter 和 filter_by都适用。【贰】使用很简短,上边列出多少个常用的操作:

any()``限制行匹配:

query.filter(User.name == 'ed') #equals

query.filter(User.name != 'ed') #not equals

query.filter(User.name.like('%ed%')) #LIKE

uery.filter(User.name.in_(['ed','wendy', 'jack'])) #IN

query.filter(User.name.in_(session.query(User.name).filter(User.name.like('%ed%'))#IN

query.filter(~User.name.in_(['ed','wendy', 'jack']))#not IN

query.filter(User.name == None)#is None

query.filter(User.name != None)#not None

from sqlalchemy import and_

query.filter(and_(User.name =='ed',User.fullname =='Ed Jones')) # and

query.filter(User.name == 'ed',User.fullname =='Ed Jones') # and

query.filter(User.name == 'ed').filter(User.fullname == 'Ed Jones')# and

from sqlalchemy import or_

query.filter(or_(User.name =='ed', User.name =='wendy')) #or

query.filter(User.name.match('wendy')) #match
>>>for name, in session.query(User.name).\
...

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

...
    print name
jack

玖.二.回来列表和数码(标量?)

 

all()再次回到一个列表:能够开始展览Python列表的操作。

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

query = session.query(User).filter(User.name.like('%ed')).order_by(User.id)

query.all()

[<User(name='ed',fullname='EdJones', password='f8s7ccs')>,<User(name='fred',
fullname='FredFlinstone', password='blah')>]
>>> session.query(Address).\
...
        filter(~Address.user.has(User.name=='jack')).all()

[]

first()适用于限制三个境况,再次回到查询到的首先个结实作为标量?:好像只可以作为质量,类

 

query.first()

<User(name='ed',fullname='Ed Jones', password='f8s7ccs')>

12.4 ``常见的关系运算符

one()完全获得具备行,并且只要查询到的不仅仅三个对象可能有复合行,就能抛出十一分。

`=== None都以用在多对一中,而contains()用在壹对多的汇聚中:`

from sqlalchemy.orm.exc import MultipleResultsFound

user = query.one()

try:

  user = query.one()

except
  MultipleResultsFound, e:

  print e

Multiple rows were found for one()
query.filter(Address.user == someuser)
query.filter(User.addresses.contains(someaddress))

万11行也并未有:

 

from sqlalchemy.orm.exc import NoResultFound

try:

  user = query.filter(User.id == 99).one()

except
NoResultFound, e:

  print e

No row was found for one()

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

one()方法对于想要消除“no items found”和“multiple items
found”是区别的种类是极好的。(那句有语病啊)比方web服务重回,本来是在no results
found情形下回到”40四“的,结果在三个results found意况下也会跑出二个行使极其。

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

scalar()作为one()方法的依靠,并且在one()成功基础上重临行的首先列。

 

query = session.query(User.id).filter(User.name == 'ed')

query.scalar()

7

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

玖.三.应用字符串SQL

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

字符串能使Query越来越灵敏,通过text()构造钦点字符串的选用,这种艺术能够用在大多方法中,像filter()和order_by()。

 

from sqlalchemy import text

for user in session.query(User).filter(text("id<224")).order_by(text("id")).all()

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

绑定参数能够钦命字符串,用params()方法钦点数值。

session.query(Address).with_parent(someuser,'addresses')
session.query(User).filter(text("id<:value and name=:name")).\

params(value=224, name='fred').order_by(User.id).one()

 

如若要用七个完好无损的SQL语句,能够使用from_statement()。

ession.query(User).from_statement(text("SELECT* FROM users where name=:name")).\

            params(name='ed').all()

也能够用from_statement()获取完整的”raw”,用字符名分明希望被询问的一定列:

session.query("id","name", "thenumber12").\

from_statement(text("SELECT id, name, 12 as ""thenumber12 FROM users where name=:name")).\

 params(name=’ed’).all()

[(1,u'ed', 12)]

感觉这个不太符合ORM的思想啊。。。

9.4 计数

count()用来计算查询结果的数目。

session.query(User).filter(User.name.like('%ed')).count()

func.count()方法比count()更加尖端一点【三】

from sqlalchemy import func

session.query(func.count(User.name),User.name).group_by(User.name).all()


[(1,u'ed'), (1,u'fred'), (1,u'mary'), (1,u'wendy')]

为了促成轻便计数SELECT count(*) FROM table``,可以这么写:

session.query(func.count('*')).select_from(User).scalar()

如果我们明确表达计数是根据``User``表的主键的话,可以省略``select_from(User):

session.query(func.count(User.id)).scalar()

上面两行结果均为``4``。

Go to
(下)

 

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

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

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

构造类和外键简单,就不过多赘述。主要说明以下``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

如果表明的措施已经早先使用,relationship()仲春其他类关联的参数能够通过strings钦定。在上文的User类中,1旦有所映射成功,为了产生实际的参数,那么些字符串会被看作Python的表达式。下边是三个在User类中开创双向沟通的例子:

class User(Base):

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

壹对文化:

在大多数的外键约束(纵然不是有所的)关系数据库只可以链接到八个主键列,或具有唯壹约束的列。

外键约束纵然是指向两个列的主键,并且它自己也装有多列,这种被称呼“复合外键”。

外键列能够自动更新自个儿来对号入座它所引用的行依然列。那被可以称作级联,是壹种创建在关周全据库的功用。

外键能够参照自个儿的表格。这种被称作“自引”外键。

我们供给在数据库中创设二个addresses表,所以大家会创立另四个元数据,那将会跳过曾经创办的表。

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

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

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

jack.addresses

[]

近些日子得以向来在User对象中增加Address对象。只须求钦点一个完好无损的列表:

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')>

12.3使用EXISTS(存在?)

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

>>>from sqlalchemy.sqlimport exists

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

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

    print name

jack

等价于:

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

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


...
    print name

jack

any()``限制行匹配:

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

...

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


...
    print name

jack

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

>>> session.query(Address).\

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

[]

12.4 ``常见的关系运算符

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

query.filter(Address.user == someuser)

query.filter(User.addresses.contains(someaddress))

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

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

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

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

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

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

session.query(Address).with_parent(someuser,'addresses')

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

待补充。。。

相关文章