之前做查詢一直覺得直接拼 SQL 比較方便，用了 SQLAlchemy 的 ORM 查詢之后，發現也還可以，還提高了可讀性。
這篇文章主要說說 SQLAlchemy 常用的 ORM 查詢方式，偏實踐。看了之后，對付開發中的查詢需求，我覺得可以滿足不少。
為方便說明，假設有如下數據
圖書表 books
+----+--------+--------------------------+-------+
| id | cat_id | name | price | +----+--------+--------------------------+-------+ | 1 | 1 | 生死疲勞 | 40.40 | | 2 | 1 | 皮囊 | 31.80 | | 3 | 2 | 半小時漫畫中國史 | 33.60 | | 4 | 2 | 耶路撒冷三千年 | 55.60 | | 5 | 2 | 國家寶藏 | 52.80 | | 6 | 3 | 時間簡史 | 31.10 | | 7 | 3 | 宇宙簡史 | 22.10 | | 8 | 3 | 自然史 | 26.10 | | 9 | 3 | 人類簡史 | 40.80 | | 10 | 3 | 萬物簡史 | 33.20 | +----+--------+--------------------------+-------+ 分類表 categories
+----+--------------+
| id | name | +----+--------------+ | 1 | 文學 | | 2 | 人文社科 | | 3 | 科技 | +----+--------------+ ORM 對象定義如下
注意：本文 Python 代碼在以下環境測試通過
- Python 3.6.0
- PyMySQL 0.8.1
- SQLAlchemy 1.2.8
# coding=utf-8 from sqlalchemy import create_engine from sqlalchemy.ext.declarative import declarative_base from sqlalchemy import Column, Integer, String, Numeric from sqlalchemy.orm import sessionmaker Base = declarative_base() engine = create_engine('mysql+pymysql://username:password' '@127.0.0.1:3306/db_name?charset=utf8') Session = sessionmaker(bind=engine) session = Session() def to_dict(self): return {c.name: getattr(self, c.name, None) for c in self.__table__.columns} Base.to_dict = to_dict class Book(Base): __tablename__ = 'books' id = Column(Integer, primary_key=True) cat_id = Column(Integer) name = Column('name', String(120)) price = Column('price', Numeric) class Category(Base): __tablename__ = 'categories' id = Column(Integer, primary_key=True) name = Column('name', String(30)) 好了，下面進入正題。
1 根據主鍵獲取記錄
當我們獲取圖書的詳情時，很容易用到。
book_id = 1 book = session.query(Book).get(book_id) print(book and book.to_dict()) 直接 get(primary_key) 就得到結果
{'id': 1, 'cat_id': 1, 'name': '生死疲勞', 'price': Decimal('40.40')} 當然，這樣也可以
book_id = 1 book = session.query(Book) \ .filter(Book.id == book_id) \ .first() print(book and book.to_dict()) 不過，還是前一種方式簡潔一些。
2 AND 查詢
我們最常用到的就是這種查詢，比如我要獲取 cat_id 為 1 且價格大於 35 的書
books = session.query(Book) \
.filter(Book.cat_id == 1,
Book.price > 35) \
.all()
print([v.to_dict() for v in books]) 執行后，得到結果
[{'id': 1, 'cat_id': 1, 'name': '生死疲勞', 'price': Decimal('40.40')}] filter() 里面的條件默認是使用 AND 進行連接，畢竟這最常用嘛。所以說，換成這樣用也是沒有問題的
from sqlalchemy import and_ books = session.query(Book) \ .filter(and_(Book.cat_id == 1, Book.price > 35)) \ .all() print([v.to_dict() for v in books]) 不過，通常來說，如果條件全是用 AND 連接的話，沒必要顯式的去用 and_。
如果條件都是等值比較的話，可以使用 filter_by() 方法，傳入的是關鍵字參數。
查詢 cat_id 等於 1 且價格等於 31.8 的圖書，可以這樣
books = session.query(Book) \
.filter_by(cat_id=1, price=31.8) \
.all()
print([v.to_dict() for v in books]) 結果
[{'id': 2, 'cat_id': 1, 'name': '皮囊', 'price': Decimal('31.80')}] 這種方式相對於 filter() 來說，書寫要簡潔一些，不過條件都限制在了等值比較。
不同情況選擇合適的就好。
3 常用方法
除了上面使用的 get()、first()、all() 外，還有下面的一些方法比較常用。
- one() 只獲取一條記錄，如果找不到記錄或者找到多條都會報錯
# 找不到記錄會拋如下錯誤 # sqlalchemy.orm.exc.NoResultFound: No row was found for one() book = session \ .query(Book).filter(Book.id > 10) \ .one() print(book and book.to_dict()) # 找到多條記錄會拋如下錯誤 # sqlalchemy.orm.exc.MultipleResultsFound: Multiple rows were found for one() book = session \ .query(Book).filter(Book.id < 10) \ .one() print(book and book.to_dict()) # 正常，得到如下結果 # {'id': 10, 'cat_id': 3, 'name': '萬物簡史', # 'price': Decimal('33.20')} book = session \ .query(Book).filter(Book.id == 10) \ .one() print(book and book.to_dict()) - count() 返回記錄條數
count = session \
.query(Book) \
.filter(Book.cat_id == 3) \
.count()
print(count) 結果
5
- limit() 限制返回的記錄條數
books = session \
.query(Book) \
.filter(Book.cat_id == 3) \
.limit(3) \ .all() print([v.to_dict() for v in books]) 結果
[{'id': 6, 'cat_id': 3, 'name': '時間簡史', 'price': Decimal('31.10')}, {'id': 7, 'cat_id': 3, 'name': '宇宙簡史', 'price': Decimal('22.10')}, {'id': 8, 'cat_id': 3, 'name': '自然史', 'price': Decimal('26.10')}] - distinct() 與 SQL 的 distinct 語句行為一致
books = session \
.query(Book.cat_id) \
.distinct(Book.cat_id) \
.all()
print([dict(zip(v.keys(), v)) for v in books]) 結果
[{'cat_id': 1}, {'cat_id': 2}, {'cat_id': 3}] order_by()將記錄按照某個字段進行排序
# 圖書按 ID 降序排列 # 如果要升序排列，去掉 .desc() 即可 books = session \ .query(Book.id, Book.name) \ .filter(Book.id > 8) \ .order_by(Book.id.desc()) \ .all() print([dict(zip(v.keys(), v)) for v in books]) 結果
[{'id': 10, 'name': '萬物簡史'}, {'id': 9, 'name': '人類簡史'}] - scalar() 返回調用 one() 后得到的結果的第一列值
book_name = session \
.query(Book.name) \
.filter(Book.id == 10)\
.scalar()
print(book_name) 結果
萬物簡史
- exist() 查看記錄是否存在
# 查看 ID 大於 10 的圖書是否存在 from sqlalchemy.sql import exists is_exist = session \ .query(exists().where(Book.id > 10)) \ .scalar() print(is_exist) 結果
False 4 OR 查詢
通過 OR 連接條件的情況也多，比如我要獲取 cat_id 等於 1 或者價格大於 35 的書
from sqlalchemy import or_ books = session.query(Book) \ .filter(or_(Book.cat_id == 1, Book.price > 35)) \ .all() print([v.to_dict() for v in books]) 執行，得到結果
[{'id': 1, 'cat_id': 1, 'name': '生死疲勞', 'price': Decimal('40.40')}, {'id': 2, 'cat_id': 1, 'name': '皮囊', 'price': Decimal('31.80')}, {'id': 4, 'cat_id': 2, 'name': '耶路撒冷三千年', 'price': Decimal('55.60')}, {'id': 5, 'cat_id': 2, 'name': '國家寶藏', 'price': Decimal('52.80')}, {'id': 9, 'cat_id': 3, 'name': '人類簡史', 'price': Decimal('40.80')}] 使用方式和 AND 查詢類似，從 sqlalchemy 引入 or_，然后將條件放入就 OK 了。
5 AND 和 OR 並存的查詢
現實情況下，我們很容易碰到 AND 和 OR 並存的查詢。比如，我現在要查詢價格大於 55 或者小於 25，同時 cat_id 不等於 1 的圖書
from sqlalchemy import or_ books = session.query(Book) \ .filter(or_(Book.price > 55, Book.price < 25), Book.cat_id != 1) \ .all() print([v.to_dict() for v in books]) 結果
[{'id': 4, 'cat_id': 2, 'name': '耶路撒冷三千年', 'price': Decimal('55.60')}, {'id': 7, 'cat_id': 3, 'name': '宇宙簡史', 'price': Decimal('22.10')}] 又如，查詢圖書的數量，圖書滿足兩個要求中的一個即可：一是 cat_id 大於 5；二是 cat_id 小於 2 且價格大於 40。可以這樣
from sqlalchemy import or_, and_ count = session.query(Book) \ .filter(or_(Book.cat_id > 5, and_(Book.cat_id < 2, Book.price > 40))) \ .count() print(count) 結果
1
6 巧用列表或者字典的解包給查詢方法傳參
開發中，我們經常會碰到根據傳入的參數構造查詢條件進行查詢。比如
- 如果接收到非 0 的
cat_id，需要限制cat_id等於 0 - 如果接收到非 0 的 price，需要限制 price 等於傳入的 price
- 如果接收到非 0 的
min_price，需要限制 price 大於等於min_price - 如果接收到非 0 的
max_price，需要限制 price 小於等於max_price
我們就可以編寫類似的代碼
# 請求參數，這里只是占位，實際由用戶提交的請求決定 params = {'cat_id': 1} conditions = [] if params.get('cat_id', 0): conditions.append(Book.cat_id == params['cat_id']) if params.get('price', 0): conditions.append(Book.price == params['price']) if params.get('min_price', 0): conditions.append(Book.price >= params['min_price']) if params.get('max_price', 0): conditions.append(Book.price <= params['max_price']) books = session.query(Book).filter(*conditions).all() print([v.to_dict() for v in books]) 結果
[{'id': 1, 'cat_id': 1, 'name': '生死疲勞', 'price': Decimal('40.40')}, {'id': 2, 'cat_id': 1, 'name': '皮囊', 'price': Decimal('31.80')}] OR 查詢類似，將列表解包傳給 or_() 即可。
如果需求更復雜，AND 和 OR 都可能出現，這個時候根據情況多建幾個列表實現。這里只向大家說明大致的思路，就不舉具體的例子了。
當然，如果都是等值查詢的話，比如只有這兩種情況
- 如果接收到非 0 的
cat_id，需要限制cat_id等於 0 - 如果接收到非 0 的 price，需要限制 price 等於傳入的 price
可以使用字典的解包給 filter_by() 傳參
# 請求參數，這里只是占位，實際由用戶提交的請求決定 params = {'price': 31.1} condition_dict = {} if params.get('cat_id', 0): condition_dict['cat_id'] = params['cat_id'] if params.get('price', 0): condition_dict['price'] = params['price'] books = session.query(Book) \ .filter_by(**condition_dict) \ .all() print([v.to_dict() for v in books]) 結果
[{'id': 6, 'cat_id': 3, 'name': '時間簡史', 'price': Decimal('31.10')}] 7 其它常用運算符
除了上面看到的 ==、>、>=、<、<=、!= 之外，還有幾個比較常用
- IN
# 查詢 ID 在 1、3、5 中的記錄 books = session.query(Book) \ .filter(Book.id.in_([1, 3, 5])) \ .all() - INSTR()
# 查詢名稱包含「時間簡史」的圖書 books = session.query(Book) \ .filter(Book.name.contains('時間簡史')) \ .all() FIN_IN_SET()
# 查詢名稱包含「時間簡史」的圖書 # 這里顯然應該用 INSTR() 的用法 # FIND_IN_SET() 一般用於逗號分隔的 ID 串查找 # 這里使用 FIND_IN_SET()，旨在說明用法 from sqlalchemy import func books = session.query(Book) \ .filter(func.find_in_set('時間簡史', Book.name)) \ .all() - LIKE
# 查詢名稱以「簡史」結尾的圖書 books = session.query(Book) \ .filter(Book.name.like('%簡史')) \ .all() - NOT
上面的 IN、INSTR、FIN_IN_SET、LIKE 都可以使用 ~ 符號取反。比如
# 查詢 ID 不在 1 到 9 之間的記錄 books = session.query(Book) \ .filter(~Book.id.in_(range(1, 10))) \ .all() 8 查詢指定列
查詢名稱包含「簡史」的圖書的 ID 和名稱。如下
books = session.query(Book.id, Book.name) \
.filter(Book.name.contains('簡史')) \ .all() print([dict(zip(v.keys(), v)) for v in books]) 結果
[{'id': 6, 'name': '時間簡史'}, {'id': 7, 'name': '宇宙簡史'}, {'id': 9, 'name': '人類簡史'}, {'id': 10, 'name': '萬物簡史'}] 9 內連接、外連接
9.1 內連接
獲取分類為「科技」，且價格大於 40 的圖書
# 如果 ORM 對象中定義有外鍵關系 # 那么 join() 中可以不指定關聯關系 # 否則，必須要 books = session \ .query(Book.id, Book.name.label('book_name'), Category.name.label('cat_name')) \ .join(Category, Book.cat_id == Category.id) \ .filter(Category.name == '科技', Book.price > 40) \ .all() print([dict(zip(v.keys(), v)) for v in books]) 結果
[{'id': 9, 'book_name': '人類簡史', 'cat_name': '科技'}] 統計各個分類的圖書的數量
from sqlalchemy import func books = session \ .query(Category.name.label('cat_name'), func.count(Book.id).label('book_num')) \ .join(Book, Category.id == Book.cat_id) \ .group_by(Category.id) \ .all() print([dict(zip(v.keys(), v)) for v in books]) 結果
[{'cat_name': '文學', 'book_num': 2}, {'cat_name': '人文社科', 'book_num': 3}, {'cat_name': '科技', 'book_num': 5}] 9.2 外連接
為方便說明，我們僅在這一小節中向 books 表中加入如下數據
+----+--------+-----------------+-------+
| id | cat_id | name | price | +----+--------+-----------------+-------+ | 11 | 5 | 人性的弱點 | 54.40 | +----+--------+-----------------+-------+ 查看 ID 大於等於 9 的圖書的分類信息
# outerjoin 默認是左連接 # 如果 ORM 對象中定義有外鍵關系 # 那么 outerjoin() 中可以不指定關聯關系 # 否則，必須要 books = session \ .query(Book.id.label('book_id'), Book.name.label('book_name'), Category.id.label('cat_id'), Category.name.label('cat_name')) \ .outerjoin(Category, Book.cat_id == Category.id) \ .filter(Book.id >= 9) \ .all() print([dict(zip(v.keys(), v)) for v in books]) 結果
[{'book_id': 9, 'book_name': '人類簡史', 'cat_id': 3, 'cat_name': '科技'}, {'book_id': 10, 'book_name': '萬物簡史', 'cat_id': 3, 'cat_name': '科技'}, {'book_id': 11, 'book_name': '人性的弱點', 'cat_id': None, 'cat_name': None}] 注意最后一條記錄。
10 打印 SQL
當碰到復雜的查詢，比如有 AND、有 OR、還有連接查詢時，有時可能得不到預期的結果，這時我們可以打出最終的 SQL 幫助我們來查找錯誤。
以上一節的外連接為例說下怎么打印最終 SQL
q = session \
.query(Book.id.label('book_id'), Book.name.label('book_name'), Category.id.label('cat_id'), Category.name.label('cat_name')) \ .outerjoin(Category, Book.cat_id == Category.id) \ .filter(Book.id >= 9) raw_sql = q.statement \ .compile(compile_kwargs={"literal_binds": True}) print(raw_sql) 其中，q 為 sqlalchemy.orm.query.Query 類的對象。
結果
SELECT books.id AS book_id, books.name AS book_name, categories.id AS cat_id, categories.name AS cat_name FROM books LEFT OUTER JOIN categories ON books.cat_id = categories.id WHERE books.id >= 9filter 查詢小結：
1. filter_by 查詢：查詢條件都是等號，一般都是and的
def query_filter_by(self, dbt, **kwargs): try: tb = session.query(dbt).filter_by(**kwargs) # raw_sql = tb.statement.compile(compile_kwargs={'literal_binds': True}) # print raw_sql return tb except Exception as e: print 'error' return str(e) finally: session.remove() xx = query_filter_by(Student, id = 1，name = '123') for x in xx: print x.id, x.name, x.age, x.sex
2. filter 查詢：很靈活，寫好查詢條件后，直接查詢
def query_filter(self, dbt, *args): try: tb = session.query(dbt).filter(*args) return tb except Exception as e: print 'error' return str(e) finally: session.remove() conditions = { and_( Student.id == 1, or_( Student.name == 'zang', Student.id >= 1 ) ) } xx = query_filter(Student, *conditions) for x in xx: print x.id, x.name, x.age, x.sex