零、SQLAlchemy是什么？
SQLAlchemy的官網上寫著它的介紹文字:
SQLAlchemy is the Python SQL toolkit and Object Relational Mapper that gives
application developers the full power and flexibility of SQL.
SQLAlchemy 是一個非常強大的ORM和數據庫工具，但是它龐大的文檔和復雜的功能總是讓很 多人望而生畏。而Django的ORM相對來說就讓很多人覺得簡單實用。
事實上，SQLAlchemy其實也沒有那么復雜，光使用它一些比較高級的功能其實并沒有比 使用Django ORM復雜多少，而它豐富的功能則能讓你在遇到更復雜的問題時處理起來得心應手。
寫作本文的主要目的在于：
- 通過對比SQLAlchemy ORM和Django ORM的主要使用方法， 盡量簡單直觀的讓Django用戶能夠快速了解和上手SQLAlchemy這款強大的工具。
- 不牽扯到SQLAlchemy具體的技術細節，包括Engine連接池、Session的具體工作原理等等
SQLAlchemy相對于Django內建的ORM來說，有幾處非常明顯的優點：
- 可獨立使用，任何使用Python的項目都可以用它來操作數據庫
- 和直接使用原始的DBAPI相比，提供了非常豐富的特性：連接池、auto-map等等
- 提供了更底層的SQL抽象語言，能用原始sql解決的問題基本上都可以用SQLAlchemy解決
- 接下來我們針對日常的數據庫操作來對比一下Django ORM和SQLAlchemy。
文中使用的 SQLAlchemy 版本為 0.9.8
一、Django VS SQLAlchemy
SQLAlchemy的安裝：
|
1
2
3
4
|
wget http://peak.telecommunity.com/dist/ez_setup.pypython ez_setup.pysudo easy_install sqlalchemysudo easy_install ipython |
1.建立數據表
首先，我們需要先建立幾個表。
（1）Django
在Django中，如果要建表，就是在models.py中定義你的數據類型：
|
1
2
3
4
5
6
7
|
from django.db import modelsclass Game(models.Model): ... ...class GameCompany(models.Model): ... ... |
因為文章主要面向有經驗的Django用戶，所以此處不寫出詳細的定義代碼。定義Model以后 我們還需要在settings.py中DATABASES處設置需要連接的數據庫地址。最后，使用syncdb來 完成數據庫表的創建。
（2）SQLAlchemy
在SQLAlchemy中，定義表結構的過程和Django類似：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
from sqlalchemy import create_enginefrom sqlalchemy.ext.declarative import declarative_basefrom sqlalchemy import Column, Integer, String, ForeignKey, Datefrom sqlalchemy.orm import relationship, backrefBase = declarative_base()# 定義表結構class GameCompany(Base): __tablename__ = 'game_company' id = Column(Integer, primary_key=True) name = Column(String(200), nullable=False) country = Column(String(50))class Game(Base): __tablename__ = 'game' id = Column(Integer, primary_key=True) company_id = Column(Integer, ForeignKey('game_company.id'), index=True) category = Column(String(10)) name = Column(String(200), nullable=False) release_date = Column(Date) # 和Django不同，外鍵需要顯式定義，具體好壞見仁見智 # 此處的relation可以為lazy加載外鍵內容時提供一些可配置的選項 company = relationship('GameCompany', backref=backref('games'))# 此處定義要使用的數據庫engine = create_engine('mysql://root:root@localhost:5379/sqlalchemy_tutorial?charset=utf8')# 調用create_all來創建表結構，已經存在的表將被忽略Base.metadata.create_all(engine) |
2.插入一些數據
接下來，我們往表中插入一些數據
（1）Django
Django中比較常用的插入數據方法就是使用 .save() 了。
|
1
2
3
4
5
6
7
8
9
10
11
12
|
nintendo = GameCompany(name="nintendo", country="Japan")nintendo.save()game1 = Game( company=nintendo, category="ACT", name="Super Mario Bros", release_date='1985-10-18')game1.save()# 或者使用createGame.objects.create(... ...) |
（2）SQLAlchemy
在SQLAlchemy ORM中，有一個非常關鍵的對象 session ，所有對于數據的操作都是 通過session來進行的，所以要插入數據之前，我們得先初始化一個session：
|
1
2
3
|
from sqlalchemy.orm import sessionmakerSession = sessionmaker(bind=engine)session = Session() |
之后插入數據的方法也和Django比較相似：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
# 添加數據nintendo = GameCompany(name="Nintendo", country="Japan")capcom = GameCompany(name="Capcom", country="Japan")game1 = Game( company=nintendo, category="ACT", name="Super Mario Bros", release_date='1985-10-18')game2 = Game( company=capcom, category="ACT", name="Devil May Cry 3: Dante's Awakening", release_date="2005-03-01",)game3 = Game( company=nintendo, category="RPG", name="Mario & Luigi: Dream Team", release_date="2013-08-11",)# 使用add_all來讓這些objects和session產生關系session.add_all([nintendo, capcom, game1, game2])# 在沒有開啟autocommit的模式下，不要忘了調用commit來讓數據寫到數據庫中session.commit() |
除了commit之外，session還有rollback()等方法，你可以把session對象簡單看成是一次 transaction，所以當你對內容進行修改時，需要調用 session.commit() 來提交這些修改。
去文檔可以了解更多session相關內容：http://docs.sqlalchemy.org/en/rel_0_9/orm/session.html
二、常用操作
1.簡單查詢
（1）批量查詢
|
1
2
3
4
5
6
7
|
# -- Django --Game.objects.filter(category="RPG")# -- SQLAlchemy --# 使用filter_by是和django ORM比較接近的方式session.query(Game).filter_by(category="RPG")session.query(Game).filter(Game.category == "RPG") |
（2）查詢單個對象
|
1
2
3
4
5
6
7
|
# -- Django --Game.objects.get(name="Super Mario Bros")# -- SQLAlchemy --session.query(Game).filter_by(name="Super Mario Bros").one()# `get_objects_or_None()`session.query(Game).filter_by(name="Super Mario Bros").scalar() |
Django中得各種 > 、< 都是使用在字段名稱后面追加 "__gt"、"__lt" 來實現的，在SQLAlchemy 中這樣的查詢還要更直觀一些
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
# -- Django --Game.objects.filter(release_date__gte='1999-01-01')# 取反Game.objects.exclude(release_date__gte='1999-01-01')# -- SQLAlchemy --session.query(Game).filter(Game.release_date >= '1999-01-01').count()# 取反使用 ~ 運算符session.query(Game).filter(~Game.release_date >= '1999-01-01').count()通過外鍵組合查詢# -- Django --Game.objecs.filter(company__name="Nintendo")# -- SQLAlchemy --session.query(Game).join(GameCompany).filter(GameCompany.name == "Nintendo") |
2.多條件或查詢
|
1
2
3
4
5
6
7
8
|
# -- Django --from django.db.models import QGame.objects.filter(Q(category="RPG") | Q(category="ACT"))# -- SQLAlchemy --from sqlalchemy import or_session.query(Game).filter(or_(Game.category == "RPG", Game.category == "ACT"))session.query(Game).filter((Game.category == "RPG") | (Game.category == "ACT")) |
（1）in查詢
|
1
2
3
4
5
|
# -- Django --Game.objects.filter(category__in=["GAL", "ACT"])# -- SQLAlchemy --session.query(Game).filter(Game.category.in_(["GAL", "ACT"])) |
（2）like查詢
|
1
2
3
4
5
|
# -- Django --Game.objects.filter(name__contains="Mario")# -- SQLAlchemy --session.query(Game.name.contains('Mario')) |
3.統計個數
簡單統計總數：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
# -- Django --Game.objects.filter(category="RPG").count()# -- SQLAlchemy --session.query(Game).filter_by(category="RPG").count()分組統計個數# -- Django --from django.db.models import CountGame.objects.values_list('category').annotate(Count('pk')).order_by()# -- SQLAlchemy --from sqlalchemy import funcsession.query(Game.category, func.count(Game.category)).group_by(Game.category).all() |
4.結果排序
對查詢結果進行排序：
|
1
2
3
4
5
6
7
8
9
10
11
|
# -- Django --Game.objects.all().order_by('release_date')Game.objects.all().order_by('-release_date')# 多字段排序Game.objects.all().order_by('-release_date', 'category')# -- SQLAlchemy --session.query(Game).order_by(Game.release_date)session.query(Game).order_by(Game.release_date.desc())# 多字段排序session.query(Game).order_by(Game.release_date.desc(), Game.category) |
5.修改數據
|
1
2
3
4
5
6
7
8
9
|
# -- Django --game = Game.objects.get(pk=1)game.name = 'Super Mario Brothers'game.save()# -- SQLAlchemy --game = session.query(Game).get(1)game.name = 'Super Mario Brothers'session.commit() |
6.批量修改
|
1
2
3
4
5
|
# -- Django --Game.objects.filter(category="RPG").update(category="ARPG")# -- SQLAlchemy --session.query(Game).filter_by(category="RPG").update({"category": "ARPG"}) |
7.批量刪除
|
1
2
3
4
5
|
# -- Django --Game.objects.filter(category="ARPG").delete()# -- SQLAlchemy --session.query(Game).filter_by(category="ARPG").delete() |
三、SQLAlchemy其他一些值得關注的功能
上面簡單列了一些SQLAlchemy ORM和Django ORM的使用方法對比，SQLAlchemy同時還提供了一些 其他非常有用的功能，比如Automap~
假如你有一個Django項目，通過ORM創建了一大堆Model。這時來了一個新項目，需要操作 這些表，應該怎么辦？拷貝這些Models？使用原始的DB-API加上sql來操作？
其實使用SQLAlchemy的Automap可以讓你的工作變得非常的方便，你只要在新項目連接到舊數據庫，然后 稍微配置一下Automap，就可以使用SQLAlchemy的ORM操作那些通過別的系統創建的表了。
就像這樣：
|
1
2
3
4
5
6
7
8
9
10
11
|
from sqlalchemy.ext.automap import automap_basefrom sqlalchemy.orm import Sessionfrom sqlalchemy import create_engineBase = automap_base()engine = create_engine("sqlite:///mydatabase.db")Base.prepare(engine, reflect=True)# user和address就是表明，通過這樣的語句就可以把他們分別映射到User和Address類User = Base.classes.userAddress = Base.classes.address |
更多信息可以參考詳細文檔：http://docs.sqlalchemy.org/en/rel_0_9/orm/extensions/automap.html
附：Django與SQLAlchemy結合的實例演示
譬如，以下gumi/db.py代碼，其中gumi制作Django項目名，項目中使用的唯一的數據庫連接的包裝，作為py調用。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
# -*- coding: utf-8 -*- from django.conf import settings from django.core import signals from django.dispatch import dispatcher import sqlalchemy from sqlalchemy.orm import scoped_session, sessionmaker from sqlalchemy.engine.url import URL __all__ = ['Session', 'metadata'] def create_engine(): url = URL(drivername=settings.DATABASE_ENGINE, database=settings.DATABASE_NAME, username=settings.DATABASE_USER, password=settings.DATABASE_PASSWORD, host=settings.DATABASE_HOST, port=settings.DATABASE_PORT or None, query = getattr(settings, 'DATABASE_OPTIONS', {}) ) options = getattr(settings, 'SQLALCHEMY_OPTIONS', {}) engine = sqlalchemy.create_engine(url, **options) return engine def end_request(signal, sender): Session.remove() dispatcher.connect(receiver=end_request, signal=signals.request_finished) metadata = sqlalchemy.MetaData() Session = scoped_session(sessionmaker(autoflush=True, transactional=True, bind=create_engine())) |
模塊代碼
|
1
2
3
4
5
6
7
8
9
10
|
from sqlalchemy.orm import *from gumi.db import Session, metadata some_table = Table('some_table', metadata, Column('id', Integer, primary_key=True), Column('some_value', String(100), nullable=False, mysql_engine='InnoDB', ) class SomeObject(object): passmapper(SomeObject, some_table) |
視圖代碼
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
import django.newforms as forms from gumi.db import Session class SomeForm(forms.Form): # newform pass def some_action(req): if req.method != "POST": form = SomeForm() else: form = SomeForm(req.POST) if form.is_valid(): data = form.clean() obj = SomeObject() obj.some_param = data['a'] obj.another_param = data['b'] Session.save(obj) Session.commit() return HttpResponseRedirect('/') return render_to_response('some/template.html') |
