SQLAlchemy中的Query方法

在SQLAlchemy中執行查詢是經過session對象的query方法完成的。query方法很是靈活，你能夠根據須要使用不一樣的查詢方式查找數據，下面一一舉例。
1.直接經過映射類查找：

#Querying user instance
for instance insession.query(User).order_by(User.id):
  print instance.name,instance.fullname

這種方法只要在query方法中，將映射類做爲參數，就能夠查詢出這個映射類表明的數據庫表中的數據。其至關於下面的SQL語句：

SELECTusers.id ASusers_id, users.name ASusers_name,
users.fullname ASusers_fullname, users.password ASusers_password
FROM users ORDERBY users.id

2.經過映射類的屬性字段查詢：

#Querying by ORM-instrument
for name,fullnamein session.query(User.name,User.fullname):
  print name,fullname

這種方法指定了查詢的具體字段，而不是像第一種方法那樣把映射類的全部字段都查詢出來，其至關於執行了下面的SQL語句：

SELECTusers.name ASusers_name, users.fullname ASusers_fullname
FROM users

3.query查詢的結果是保存在一個元組中的，因此咱們能夠在query中指定返回整個的映射類對象和其中的部分屬性字段：

#Querying as a Python object
for row insession.query(User,User.name).all():
  print row.User,row.name

這種查詢方法能夠返回一個User對象以及它的name屬性字段的值，其至關於執行了下面的SQL語句：

SELECTusers.id ASusers_id, users.name ASusers_name, users.fullname ASusers_fullname, users.password ASusers_password
FROM users

其輸出結果爲一個元組和一個字符串：

<</span>user("ed","Ed Jones","f8x902")> ed
<</span>user("Wendy","Wendy Williams","foobar")> Wendy
<</span>user("Marry","Marry Contrary","xxg527")> Marry
<</span>user("Fred","Fred Flinstone","blah")> Fred

4.咱們還能夠給返回的結果起一個別名，或者叫標籤：

#Querying labeled
for row insession.query(User.name.label('name_label')).all():
  print (row.name_label)

這裏的關鍵是label方法，它的意思是把User的name字段改個名字叫name_label，其至關於執行如下的SQL語句：

SELECTusers.name ASname_label
FROM users

6.除了給映射類字段起別名，咱們還能夠給映射類起個別名：

#Querying with aliased
from sqlalchemy.orm import aliased
user_alias=aliased(User,name='user_alias')
for row insession.query(user_alias,user_alias.name).all():
  print row.user_alias

這裏要注意的是，咱們引入了aliased函數，而且給User映射類起了個別名叫user_alias。而後咱們就能夠在query中使用這個別名了，它至關因而User對象。上面的代碼至關於執行了如下SQL語句：

SELECTuser_alias.id ASuser_alias_id, user_alias.name ASuser_alias_name,
user_alias.fullname AS user_alias_fullname,user_alias.password AS user_alias_password
FROM users ASuser_alias

7.因爲query的查詢返回的是一個元組，因此咱們能夠利用Python對數組類對象進行「分片」的操做，來限制返回的結果集範圍：

#Querying with limit and offset
for u insession.query(User).order_by(User.id)[1:3]:
  print u

這裏咱們對返回的結果加上了[1:3]，來限制返回的結果集範圍。其執行至關於下面的SQL語句：

SELECTusers.id ASusers_id, users.name ASusers_name,
users.fullname ASusers_fullname, users.password ASusers_password
FROM users ORDERBY 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語句：

SELECTusers.name ASusers_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語句：

SELECTusers.name ASusers_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語句：

SELECTusers.name ASusers_name
FROM users
WHERE users.fullname = ? AND users.name = ?

完整的示例代碼以下：

fromsqlalchemy.ext.declarative importdeclarative_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 insession.query(User).order_by(User.id):
  print instance.name,instance.fullname
#Querying by ORM-instrument
for name,fullnamein session.query(User.name,User.fullname):
  print name,fullname
#Querying as a Python object
for row insession.query(User,User.name).all():
  print row.User,row.name

#Querying labeled
for row insession.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 insession.query(user_alias,user_alias.name).all():
  print row.user_alias
#Querying with limit and offset
for u insession.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

Python標準函數庫,SQLAlcehemy