python query_[转载]python 访问数据库 SQLAlchemy中的Query方法

在SQLAlchemy中执行查询是通过session对象的query方法完成的。query方法非常灵活，你可以根据需要使用不同的查询方式查找数据，下面一一举例。

1.直接通过映射类查找：

#Querying user

instance

for instance in

session.query(User).order_by(User.id):

print instance.name,instance.fullname

这种方法只要在query方法中，将映射类作为参数，就可以查询出这个映射类代表的数据库表中的数据。其相当于下面的SQL语句：

SELECT

users.id AS

users_id, users.name AS

users_name,

users.fullname AS

users_fullname, users.password AS

users_password

FROM users ORDER

BY users.id

2.通过映射类的属性字段查询：

#Querying by

ORM-instrument

for name,fullname

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

print name,fullname

这种方法指定了查询的具体字段，而不是像第一种方法那样把映射类的所有字段都查询出来，其相当于执行了下面的SQL语句：

SELECT

users.name AS

users_name, users.fullname AS

users_fullname

FROM users

3.query查询的结果是保存在一个元组中的，所以我们可以在query中指定返回整个的映射类对象和其中的部分属性字段：

#Querying as a

Python object

for row in

session.query(User,User.name).all():

print row.User,row.name

这种查询方法可以返回一个User对象以及它的name属性字段的值，其相当于执行了下面的SQL语句：

SELECT

users.id AS

users_id, users.name AS

users_name, users.fullname AS

users_fullname, users.password AS

users_password

FROM users

其输出结果为一个元组和一个字符串：

<user("ed","Ed

Jones","f8x902")> ed

<user("Wendy","Wendy Williams","foobar")> Wendy

<user("Marry","Marry Contrary","xxg527")> Marry

<user("Fred","Fred Flinstone","blah")> Fred

4.我们还可以给返回的结果起一个别名，或者叫标签：

#Querying

labeled

for row in

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

print (row.name_label)

这里的关键是label方法，它的意思是把User的name字段改个名字叫name_label，其相当于执行以下的SQL语句：

SELECT

users.name AS

name_label

FROM users

6.除了给映射类字段起别名，我们还可以给映射类起个别名：

#Querying with

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

这里要注意的是，我们引入了aliased函数，并且给User映射类起了个别名叫user_alias。然后我们就可以在query中使用这个别名了，它相当于是User对象。上面的代码相当于执行了以下SQL语句：

SELECT

user_alias.id AS

user_alias_id, user_alias.name AS

user_alias_name,

user_alias.fullname AS user_alias_fullname,

user_alias.password AS user_alias_password

FROM users AS

user_alias

7.由于query的查询返回的是一个元组，所以我们可以利用Python对数组类对象进行“分片”的操作，来限制返回的结果集范围：

#Querying with

limit and offset

for u in

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

print u

这里我们对返回的结果加上了[1:3]，来限制返回的结果集范围。其执行相当于下面的SQL语句：

SELECT

users.id AS

users_id, users.name AS

users_name,

users.fullname AS

users_fullname, users.password AS

users_password

FROM users ORDER

BY users.id

LIMIT ? OFFSET ?

8.前面的查询都没有涉及到子查询，也就是SQL的where子句。在SQLAlchemy框架中，query的子查询可以通过filter_by来实现：

#Qyering with

filter by

for name,

in session.query(User.name).filter_by(fullname='Ed Jones'):

print name

上面的查询相当于要找出User映射表中fullname为’Ed Jones’的数据，其相当于执行了下面的SQL语句：

SELECT

users.name AS

users_name

FROM users

WHERE users.fullname = ?

9.除了filter_by之外，我们还可以使用filter方法，这种方式看起来更灵活，我们可以按照映射类对象的属性来指定查询条件：

#Querying with

filter

for name,

in session.query(User.name).filter(User.fullname=='Ed Jones'):

print name

其参数与filter_by不同，这里使用了映射类名加属性字段的方式来指定查询子句参数，其相当于执行了下面的SQL语句：

SELECT

users.name AS

users_name

FROM users

WHERE users.fullname = ?

如果我们想要嵌套多个查询条件，可以嵌套多个filter：

#Querying with

fully generative

for name,

in session.query(User.name).filter(User.fullname=='Ed Jones').filter(User.name=='ed'):

print name

可以看到我们在filter方法后面又嵌套了一个filter，理论上可以嵌套无数个，其相当于执行了下面的SQL语句：

SELECT

users.name AS

users_name

FROM users

WHERE users.fullname = ? AND users.name = ?

完整的示例代码如下：

from

sqlalchemy.ext.declarative import

declarative_base

from sqlalchemy import Column,Integer,String

from sqlalchemy import Sequence

from sqlalchemy.orm import sessionmaker

Base=declarative_base()

from sqlalchemy import create_engine

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

class User(Base):

__tablename__='users'

id=Column(Integer,Sequence('user_id_seq'),primary_key=True)

name=Column(String(50))

fullname=Column(String(50))

password=Column(String(12))

def

__init__(self,name,fullname,password):

self.name=name

self.fullname=fullname

self.password=password

def

__repr__(self):

return '' %(self.name,self.fullname,self.password)

Base.metadata.create_all(engine)

Session=sessionmaker(bind=engine)

session=Session()

#Add on user

ed_user=User('ed','Ed Jones','edpassword')

session.add(ed_user)

#Retrive saved ed_user

our_user=session.query(User).filter_by(name='ed').first()

print 'our_user

is:',our_user

print 'our_user id

is:',our_user.id

print 'our_user is

ed_user',our_user==ed_user

#Add multiple object

session.add_all(

[

User('Wendy','Wendy Williams','foobar'),

User('Marry','Marry Contrary','xxg527'),

User('Fred','Fred Flinstone','blah')

]

)

#Detective the dirty data

ed_user.password='f8x902'

print 'Dirty

data',session.dirty

#Detective the new data

print 'New

data',session.new

#Commit data

session.commit()

#========Querying===============

#Querying user instance

for instance in

session.query(User).order_by(User.id):

print instance.name,instance.fullname

#Querying by ORM-instrument

for name,fullname

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

print name,fullname

#Querying as a Python object

for row in

session.query(User,User.name).all():

print row.User,row.name

#Querying labeled

for row in

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

print (row.name_label)

#Querying with 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

#Querying with limit and offset

for u in

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

print u

#Qyering with filter by

for name,

in session.query(User.name).filter_by(fullname='Ed Jones'):

print name

#Querying with filter

for name,

in session.query(User.name).filter(User.fullname=='Ed Jones'):

print name

#Querying with fully generative

for name,

in session.query(User.name).filter(User.fullname=='Ed Jones').filter(User.name=='ed'):

print name