SQLAlchemy 简单笔记

ORM 江湖#####

曾几何时，程序员因为惧怕SQL而在开发的时候小心翼翼的写着sql，心中总是少不了恐慌，万一不小心sql语句出错，搞坏了数据库怎么办？又或者为了获取一些数据，什么内外左右连接，函数存储过程等等。毫无疑问，不搞懂这些，怎么都觉得变扭，说不定某天就跳进了坑里，叫天天不应，喊地地不答。

ORM 的出现，让畏惧SQL的开发者，在坑里看见了爬出去的绳索，仿佛天空并不是那么黑暗，至少再暗，我们也有了眼睛。顾名思义，ORM 对象关系映射，简而言之，就是把数据库的一个个table(表)，映射为编程语言的class(类)。

python中比较著名的ORM框架有很多，大名顶顶的 SQLAlchemy 是python世界里当仁不让的ORM框架。江湖中peewee，strom， pyorm，SQLObject 各领风骚，可是最终还是SQLAlchemy 傲视群雄。

SQLAlchemy 简介#####

SQLAlchemy 分为两个部分，一共用于 ORM 的对象映射，另外一个是核心的 SQL expression 。第一个很好理解，纯粹的ORM，后面这个不是 ORM，而是DBAPI的封装，当然也提供了很多方法，避免了直接写sql，而是通过一些sql表达式。使用 SQLAlchemy 则可以分为三种方式。

使用 sql expression ，通过 SQLAlchemy 的方法写sql表达式，简介的写sql
使用 raw sql，直接书写 sql
使用 ORM 避开直接书写 sql

本文先探讨 SQLAlchemy的 sql expresstion 部分的用法。主要还是跟着官方的 SQL Expression Language Tutorial.介绍

为什么要学习 sql expresstion ，而不直接上 ORM？因为后面这个两个是 orm 的基础。并且，即是不使用orm，后面这两个也能很好的完成工作，并且代码的可读性更好。纯粹把SQLAlchemy当成dbapi使用。首先SQLAlchemy 内建数据库连接池，解决了连接操作相关繁琐的处理。其次，提供方便的强大的log功能，最后，复杂的查询语句，依靠单纯的ORM比较难实现。

实战#####

连接数据库######

首先需要导入 sqlalchemy 库，然后建立数据库连接，这里使用 mysql。通过create_engine方法进行

from sqlalchemy import create_engine
engine = create_engine("mysql://root:@localhost:3306/webpy?charset=utf8",encoding="utf-8", echo=True)

create_engine 方法进行数据库连接，返回一个 db 对象。里面的参数表示

数据库类型://用户名:密码（没有密码则为空，不填）@数据库主机地址/数据库名?编码
echo = True 是为了方便控制台 logging 输出一些sql信息，默认是False

通过这个engine对象可以直接execute 进行查询，例如 engine.execute("SELECT * FROM user") 也可以通过 engine 获取连接在查询，例如 conn = engine.connect() 通过 conn.execute()方法进行查询。两者有什么差别呢？

直接使用engine的execute执行sql的方式, 叫做connnectionless执行,
借助 engine.connect()获取conn, 然后通过conn执行sql, 叫做connection执行
主要差别在于是否使用transaction模式, 如果不涉及transaction, 两种方法效果是一样的. 官网推荐使用后者。

定义表#####

定义数据表，才能进行sql表达式的操作，毕竟sql表达式的表的确定，是sqlalchemy制定的，如果数据库已经存在了数据表还需要定义么？当然，这里其实是一个映射关系，如果不指定，查询表达式就不知道是附加在那个表的操作，当然定义的时候，注意表名和字段名，代码和数据的必须保持一致。定义好之后,就能创建数据表，一旦创建了，再次运行创建的代码，数据库是不会创建的。

# -*- coding: utf-8 -*-
__author__ = 'ghost'

from sqlalchemy import create_engine, Table, Column, Integer, String, MetaData, ForeignKey
# 连接数据库 
engine = create_engine("mysql://root:@localhost:3306/webpy?charset=utf8",encoding="utf-8", echo=True)
# 获取元数据
metadata = MetaData()
# 定义表
user = Table('user', metadata,
        Column('id', Integer, primary_key=True),
        Column('name', String(20)),
        Column('fullname', String(40)),
    )

address = Table('address', metadata,
        Column('id', Integer, primary_key=True),
        Column('user_id', None, ForeignKey('user.id')),
        Column('email', String(60), nullable=False)
    )
# 创建数据表，如果数据表存在，则忽视
metadata.create_all(engine)
# 获取数据库连接
conn = engine.connect()

插入 insert

有了数据表和连接对象，对应数据库操作就简单了。

>>> i = user.insert()   # 使用查询
>>> i  
<sqlalchemy.sql.dml.Insert object at 0x0000000002637748>
>>> print i  # 内部构件的sql语句
INSERT INTO "user" (id, name, fullname) VALUES (:id, :name, :fullname)
>>> u = dict(name='jack', fullname='jack Jone')
>>> r = conn.execute(i, **u)  # 执行查询，第一个为查询对象，第二个参数为一个插入数据字典，如果插入的是多个对象，就把对象字典放在列表里面
>>> r
<sqlalchemy.engine.result.ResultProxy object at 0x0000000002EF9390>
>>> r.inserted_primary_key  # 返回插入行 主键 id
[4L]
>>> addresses
[{'user_id': 1, 'email': 'jack@yahoo.com'}, {'user_id': 1, 'email': 'jack@msn.com'}, {'user_id': 2, 'email': 'www@www.org'}, {'user_id': 2, 'email': 'wendy@aol.com'}]
>>> i = address.insert()
>>> r = conn.execute(i, addresses)   # 插入多条记录
>>> r
<sqlalchemy.engine.result.ResultProxy object at 0x0000000002EB5080>
>>> r.rowcount   #返回影响的行数
4L

>>> i = user.insert().values(name='tom', fullname='tom Jim')
>>> i.compile()
<sqlalchemy.sql.compiler.SQLCompiler object at 0x0000000002F6F390>
>>> print i.compile()
INSERT INTO "user" (name, fullname) VALUES (:name, :fullname)
>>> print i.compile().params
{'fullname': 'tom Jim', 'name': 'tom'}
>>> r = conn.execute(i)
>>> r.rowcount
1L

查询 select

查询方式很灵活，多数时候使用 sqlalchemy.sql 下面的 select方法

>>> s = select([user])  # 查询 user表
>>> s
<sqlalchemy.sql.selectable.Select at 0x25a7748; Select object>
>>> print s
SELECT "user".id, "user".name, "user".fullname 
FROM "user"

如果需要查询自定义的字段，可是使用 user 的cloumn 对象，例如
>>> user.c # 表 user 的字段column对象
<sqlalchemy.sql.base.ImmutableColumnCollection object at 0x0000000002E804A8>
>>> print user.c
['user.id', 'user.name', 'user.fullname']
>>> s = select([user.c.name,user.c.fullname])
>>> r = conn.execute(s)
>>> r
<sqlalchemy.engine.result.ResultProxy object at 0x00000000025A7748>
>>> r.rowcount # 影响的行数
5L
>>> ru = r.fetchall()
>>> ru
[(u'hello', u'hello world'), (u'Jack', u'Jack Jone'), (u'Jack', u'Jack Jone'), (u'jack', u'jack Jone'), (u'tom', u'tom Jim')]
>>> r
<sqlalchemy.engine.result.ResultProxy object at 0x00000000025A7748>
>>> r.closed # 只要 r.fetchall() 之后，就会自动关闭 ResultProxy 对象
True

同时查询两个表
>>> s = select([user.c.name, address.c.user_id]).where(user.c.id==address.c.user_id) # 使用了字段和字段比较的条件
>>> s
<sqlalchemy.sql.selectable.Select at 0x2f03390; Select object>
>>> print s
SELECT "user".name, address.user_id
FROM "user", address
WHERE "user".id = address.user_id

操作符######

>>> print user.c.id == address.c.user_id  # 返回一个编译的字符串
"user".id = address.user_id
>>> print user.c.id == 7
"user".id = :id_1   # 编译成为带参数的sql 语句片段字符串
>>> print user.c.id != 7
"user".id != :id_1
>>> print user.c.id > 7
"user".id > :id_1
>>> print user.c.id == None
"user".id IS NULL
>>> print user.c.id + address.c.id   # 使用两个整形的变成 +
"user".id + address.id
>>> print user.c.name + address.c.email  # 使用两个字符串 变成 ||
"user".name || address.email

操作连接######

这里的连接指条件查询的时候，逻辑运算符的连接，即 and or 和 not
>>> print and_(
user.c.name.like('j%'),
user.c.id == address.c.user_id,
or_(
address.c.email == 'wendy@aol.com',
address.c.email == 'jack@yahoo.com'
),
not_(user.c.id>5))
"user".name LIKE :name_1 AND "user".id = address.user_id AND (address.email = :email_1 OR address.email = :email_2) AND "user".id <= :id_1
>>>

得到的结果为编译的sql语句片段，下面看一个完整的例子

>>> se_sql = [(user.c.fullname +", " + address.c.email).label('title')]
>>> wh_sql = and_(
              user.c.id == address.c.user_id,
              user.c.name.between('m', 'z'),
              or_(
                  address.c.email.like('%@aol.com'),
                  address.c.email.like('%@msn.com')
              )
         )
>>> print wh_sql
"user".id = address.user_id AND "user".name BETWEEN :name_1 AND :name_2 AND (address.email LIKE :email_1 OR address.email LIKE :email_2)
>>> s = select(se_sql).where(wh_sql)
>>> print s
SELECT "user".fullname || :fullname_1 || address.email AS title 
FROM "user", address 
WHERE "user".id = address.user_id AND "user".name BETWEEN :name_1 AND :name_2 AND (address.email LIKE :email_1 OR address.email LIKE :email_2)
>>> r = conn.execute(s)
>>> r.fetchall()

使用 raw sql 方式

遇到负责的sql语句的时候，可以使用 sqlalchemy.sql 下面的 text 函数。将字符串的sql语句包装编译成为 execute执行需要的sql对象。例如：、
>>> text_sql = "SELECT id, name, fullname FROM user WHERE id=:id" # 原始sql语句，参数用（：value）表示
>>> s = text(text_sql)
>>> print s
SELECT id, name, fullname FROM user WHERE id=:id
>>> s
<sqlalchemy.sql.elements.TextClause object at 0x0000000002587668>
>>> conn.execute(s, id=3).fetchall() # id=3 传递：id参数
[(3L, u'Jack', u'Jack Jone')]

连接 join

连接有join 和 outejoin 两个方法，join 有两个参数，第一个是join 的表，第二个是on 的条件，joing之后必须要配合select_from 方法
>>> print user.join(address)
"user" JOIN address ON "user".id = address.user_id # 因为开启了外键，所以join 能只能识别 on 条件
>>> print user.join(address, address.c.user_id==user.c.id) # 手动指定 on 条件
"user" JOIN address ON address.user_id = "user".id

>>> s = select([user.c.name, address.c.email]).select_from(user.join(address, user.c.id==address.c.user_id))  # 被jion的sql语句需要用 select_from方法配合
>>> s
<sqlalchemy.sql.selectable.Select at 0x2eb63c8; Select object>
>>> print s
SELECT "user".name, address.email 
FROM "user" JOIN address ON "user".id = address.user_id
>>> conn.execute(s).fetchall()
[(u'hello', u'jack@yahoo.com'), (u'hello', u'jack@msn.com'), (u'hello', u'jack@yahoo.com'), (u'hello', u'jack@msn.com'), (u'Jack', u'www@www.org'), (u'Jack', u'wendy@aol.com'), (u'Jack', u'www@www.org'), (u'Jack', u'wendy@aol.com')]

更复杂的连接参考官方的文档了。

排序分组分页

排序使用 order_by 方法，分组是 group_by ，分页自然就是limit 和 offset两个方法配合

>>> s = select([user.c.name]).order_by(user.c.name)  # order_by
>>> print s
SELECT "user".name 
FROM "user" ORDER BY "user".name
>>> s = select([user]).order_by(user.c.name.desc())
>>> print s
SELECT "user".id, "user".name, "user".fullname 
FROM "user" ORDER BY "user".name DESC
>>> s = select([user]).group_by(user.c.name)       # group_by
>>> print s
SELECT "user".id, "user".name, "user".fullname 
FROM "user" GROUP BY "user".name
>>> s = select([user]).order_by(user.c.name.desc()).limit(1).offset(3)  # limit(1).offset(3)
>>> print s
SELECT "user".id, "user".name, "user".fullname 
FROM "user" ORDER BY "user".name DESC
 LIMIT :param_1 OFFSET :param_2
[(4L, u'jack', u'jack Jone')]

更新 update

前面都是一些查询，更新和插入的方法很像，都是表下面的方法，不同的是，update 多了一个 where 方法用来选择过滤
>>> s = user.update()
>>> print s
UPDATE "user" SET id=:id, name=:name, fullname=:fullname
>>> s = user.update().values(fullname=user.c.name) # values 指定了更新的字段
>>> print s
UPDATE "user" SET fullname="user".name
>>> s = user.update().where(user.c.name == 'jack').values(name='ed') # where 进行选择过滤
>>> print s
UPDATE "user" SET name=:name WHERE "user".name = :name_1
>>> r = conn.execute(s)
>>> print r.rowcount # 影响行数
3

还有一个高级用法，就是一次命令执行多个记录的更新，需要用到 bindparam 方法

>>> s = user.update().where(user.c.name==bindparam('oldname')).values(name=bindparam('newname'))   # oldname 与下面的传入的从拿书进行绑定，newname也一样
>>> print s
UPDATE "user" SET name=:newname WHERE "user".name = :oldname
>>> u = [{'oldname':'hello', 'newname':'edd'},
{'oldname':'ed', 'newname':'mary'},
{'oldname':'tom', 'newname':'jake'}]
>>> r = conn.execute(s, u)
>>> r.rowcount
5L

删除 delete

删除比较容易，调用 delete方法即可，不加 where 过滤，则删除所有数据，但是不会drop掉表，等于清空了数据表
>>> r = conn.execute(address.delete()) # 清空表
>>> print r
<sqlalchemy.engine.result.ResultProxy object at 0x0000000002EAF550>
>>> r.rowcount
8L
>>> r = conn.execute(users.delete().where(users.c.name > 'm')) # 删除记录
>>> r.rowcount
3L

至此，sqlalchemy sql表达式的基本用法介绍完毕，更深入的阅读可以查看官方的api SQL Statements and Expressions API

==================================================================

1.版本检查

import sqlalchemy

sqlalchemy.__version__

2.连接

from sqlalchemy import create_engine

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

echo参数为True时，会显示每条执行的SQL语句，可以关闭。create_engine()返回一个Engine的实例，并且它表示通过数据库语法处理细节的核心接口，在这种情况下，数据库语法将会被解释称Python的类方法。

3.声明映像

当使用ORM【1】时，构造进程首先描述数据库的表，然后定义我们用来映射那些表的类。在现版本的SQLAlchemy中，这两个任务通常一起执行，通过使用Declarative方法，我们可以创建一些包含描述要被映射的实际数据库表的准则的映射类。

使用Declarative方法定义的映射类依据一个基类，这个基类是维系类和数据表关系的目录——我们所说的Declarative base class。在一个普通的模块入口中，应用通常只需要有一个base的实例。我们通过declarative_base()功能创建一个基类：

from sqlalchemy.ext.declarativeimportdeclarative_base

Base = declarative_base()

有了这个base，我们可以依据这个base定义任意数量的映射类。一个简单的user例子：

from sqlalchemy import Column, Integer, String

class User(Base):

__tablename__= 'users'

id= Column(Integer, primary_key=True)

name = Column(String)

用Declarative构造的一个类至少需要一个__tablename__属性，一个主键行。

4.构造模式（项目中没用到）

5.创建映射类的实例

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

6.创建会话

现在我们已经准备毫和数据库开始会话了。ORM通过Session与数据库建立连接的。当应用第一次载入时，我们定义一个Session类（声明create_engine()的同时），这个Session类为新的Session对象提供工厂服务。

from sqlalchemy.orm import sessionmaker

Session = sessionmaker(bind=engine)

这个定制的Session类会创建绑定到数据库的Session对象。如果需要和数据库建立连接，只需要实例化一个Session：

session = Session()

虽然上面的Session已经和数据库引擎Engine关联，但是还没有打开任何连接。当它第一次被使用时，就会从Engine维护的一个连接池中检索是否存在连接，如果存在便会保持连接知道我们提交所有更改并且/或者关闭session对象。

7.添加新对象（简略）

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

session.add(ed_user)

至此，我们可以认为，新添加的这个对象实例仍在等待中；ed_user对象现在并不代表数据库中的一行数据。直到使用flush进程，Session才会让SQL保持连接。如果查询这条数据的话，所有等待信息会被第一时间刷新，查询结果也会立即发行。

session.commit()

通过commit()可以提交所有剩余的更改到数据库。

8.回滚

session.rollback()

9.查询

通过Session的query()方法创建一个查询对象。这个函数的参数数量是可变的，参数可以是任何类或者是类的描述的集合。下面是一个迭代输出User类的例子：

for instance in session.query(User).order_by(User.id):

print instance.name,instance.fullname

Query也支持ORM描述作为参数。任何时候，多个类的实体或者是基于列的实体表达都可以作为query()函数的参数，返回类型是元组：

for name, fullname in session.query(User.name,User.fullname): 

print name, fullname

Query返回的元组被命名为KeyedTuple类的实例元组。并且可以把它当成一个普通的Python数据类操作。元组的名字就相当于属性的属性名，类的类名一样。

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

print row.User,row.name

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

label()不知道怎么解释，看下例子就明白了。相当于row.name

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

print(row.name_label)

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数组切片和ORDERBY结合可以让操作变得很方便。

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

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

9.1使用关键字变量过滤查询结果，filter 和 filter_by都适用。【2】使用很简单，下面列出几个常用的操作：

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

9.2.返回列表和数量（标量？）

all()返回一个列表：可以进行Python列表的操作。

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

first()适用于限制一个情况，返回查询到的第一个结果作为标量？：好像只能作为属性，类

query.first()

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

one()完全获取所有行，并且如果查询到的不只有一个对象或是有复合行，就会抛出异常。

from sqlalchemy.orm.exc import MultipleResultsFound

user = query.one()

try:

　　user = query.one()

except
　　MultipleResultsFound, e:

　　print e

Multiple rows were found for one()

如果一行也没有：

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

one()方法对于想要解决“no items found”和“multiple items found”是不同的系统是极好的。（这句有语病啊）例如web服务返回，本来是在no results found情况下返回”404“的，结果在多个results found情况下也会跑出一个应用异常。

scalar()作为one()方法的依据，并且在one()成功基础上返回行的第一列。

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

query.scalar()

7

9.3.使用字符串SQL

字符串能使Query更加灵活，通过text()构造指定字符串的使用，这种方法可以用在很多方法中，像filter()和order_by()。

from sqlalchemy import text

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

绑定参数可以指定字符串，用params()方法指定数值。

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()更高级一点【3】

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 R ational Patterns。

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

假设声明的方法已经开始使用，relationship()中和其他类关联的参数可以通过strings指定。在上文的User类中，一旦所有映射成功，为了产生实际的参数，这些字符串会被当做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')

转自链接：

https://www.jianshu.com/p/e6bba189fcbd
https://blog.csdn.net/Lotfee/article/details/57406450

posted @ 2018-10-12 15:50 一直爬行的蜗牛牛阅读(1513) 评论(0) 编辑收藏举报

刷新页面返回顶部

一直爬行的蜗牛牛