Python的Django框架中使用SQLAlchemy操作數(shù)據(jù)庫的教程

更新時間：2016年06月02日 15:53:41 作者：劉天斯

SQLAlchemy是Python一個專門的數(shù)據(jù)庫管理工具,如果對Django ORM覺得有些生疏的話完全可以結(jié)合SQLAlchemy,這里我們就來總結(jié)一下Python的Django框架中使用SQLAlchemy操作數(shù)據(jù)庫的教程

零、SQLAlchemy是什么？
SQLAlchemy的官網(wǎng)上寫著它的介紹文字:

SQLAlchemy is the Python SQL toolkit and Object Relational Mapper that gives
application developers the full power and flexibility of SQL.
SQLAlchemy 是一個非常強大的ORM和數(shù)據(jù)庫工具，但是它龐大的文檔和復(fù)雜的功能總是讓很多人望而生畏。而Django的ORM相對來說就讓很多人覺得簡單實用。

事實上，SQLAlchemy其實也沒有那么復(fù)雜，光使用它一些比較高級的功能其實并沒有比使用Django ORM復(fù)雜多少，而它豐富的功能則能讓你在遇到更復(fù)雜的問題時處理起來得心應(yīng)手。

寫作本文的主要目的在于：

通過對比SQLAlchemy ORM和Django ORM的主要使用方法，盡量簡單直觀的讓Django用戶能夠快速了解和上手SQLAlchemy這款強大的工具。
不牽扯到SQLAlchemy具體的技術(shù)細(xì)節(jié)，包括Engine連接池、Session的具體工作原理等等

SQLAlchemy相對于Django內(nèi)建的ORM來說，有幾處非常明顯的優(yōu)點：

可獨立使用，任何使用Python的項目都可以用它來操作數(shù)據(jù)庫
和直接使用原始的DBAPI相比，提供了非常豐富的特性：連接池、auto-map等等
提供了更底層的SQL抽象語言，能用原始sql解決的問題基本上都可以用SQLAlchemy解決
接下來我們針對日常的數(shù)據(jù)庫操作來對比一下Django ORM和SQLAlchemy。

文中使用的 SQLAlchemy 版本為 0.9.8

一、Django VS SQLAlchemy

SQLAlchemy的安裝：

 wget http://peak.telecommunity.com/dist/ez_setup.py
 python ez_setup.py
 sudo easy_install sqlalchemy
 sudo easy_install ipython

1.建立數(shù)據(jù)表

首先，我們需要先建立幾個表。

（1）Django

在Django中，如果要建表，就是在models.py中定義你的數(shù)據(jù)類型：

from django.db import models

class Game(models.Model):
 ... ...

class GameCompany(models.Model):
 ... ...

因為文章主要面向有經(jīng)驗的Django用戶，所以此處不寫出詳細(xì)的定義代碼。定義Model以后我們還需要在settings.py中DATABASES處設(shè)置需要連接的數(shù)據(jù)庫地址。最后，使用syncdb來完成數(shù)據(jù)庫表的創(chuàng)建。

（2）SQLAlchemy

在SQLAlchemy中，定義表結(jié)構(gòu)的過程和Django類似：

from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, Date
from sqlalchemy.orm import relationship, backref

Base = declarative_base()

# 定義表結(jié)構(gòu)
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加載外鍵內(nèi)容時提供一些可配置的選項
 company = relationship('GameCompany', backref=backref('games'))


# 此處定義要使用的數(shù)據(jù)庫
engine = create_engine('mysql://root:root@localhost:5379/sqlalchemy_tutorial?charset=utf8')
# 調(diào)用create_all來創(chuàng)建表結(jié)構(gòu)，已經(jīng)存在的表將被忽略
Base.metadata.create_all(engine)

2.插入一些數(shù)據(jù)

接下來，我們往表中插入一些數(shù)據(jù)

（1）Django

Django中比較常用的插入數(shù)據(jù)方法就是使用 .save() 了。

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

# 或者使用create
Game.objects.create(... ...)

（2）SQLAlchemy

在SQLAlchemy ORM中，有一個非常關(guān)鍵的對象 session ，所有對于數(shù)據(jù)的操作都是通過session來進(jìn)行的，所以要插入數(shù)據(jù)之前，我們得先初始化一個session：

from sqlalchemy.orm import sessionmaker
Session = sessionmaker(bind=engine)
session = Session()

之后插入數(shù)據(jù)的方法也和Django比較相似：

# 添加數(shù)據(jù)
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產(chǎn)生關(guān)系
session.add_all([nintendo, capcom, game1, game2])
# 在沒有開啟autocommit的模式下，不要忘了調(diào)用commit來讓數(shù)據(jù)寫到數(shù)據(jù)庫中
session.commit()

除了commit之外，session還有rollback()等方法，你可以把session對象簡單看成是一次 transaction，所以當(dāng)你對內(nèi)容進(jìn)行修改時，需要調(diào)用 session.commit() 來提交這些修改。

去文檔可以了解更多session相關(guān)內(nèi)容：http://docs.sqlalchemy.org/en/rel_0_9/orm/session.html

二、常用操作

1.簡單查詢

（1）批量查詢

# -- 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）查詢單個對象

# -- 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" 來實現(xiàn)的，在SQLAlchemy 中這樣的查詢還要更直觀一些

# -- 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.多條件或查詢

# -- Django --
from django.db.models import Q
Game.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查詢

# -- Django --
Game.objects.filter(category__in=["GAL", "ACT"])

# -- SQLAlchemy --
session.query(Game).filter(Game.category.in_(["GAL", "ACT"]))

（2）like查詢

# -- Django --
Game.objects.filter(name__contains="Mario")

# -- SQLAlchemy --
session.query(Game.name.contains('Mario'))

3.統(tǒng)計個數(shù)

簡單統(tǒng)計總數(shù)：

# -- Django --
Game.objects.filter(category="RPG").count()

# -- SQLAlchemy --
session.query(Game).filter_by(category="RPG").count()
分組統(tǒng)計個數(shù)

# -- Django --
from django.db.models import Count
Game.objects.values_list('category').annotate(Count('pk')).order_by()

# -- SQLAlchemy --
from sqlalchemy import func
session.query(Game.category, func.count(Game.category)).group_by(Game.category).all()

4.結(jié)果排序

對查詢結(jié)果進(jìn)行排序：

# -- 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.修改數(shù)據(jù)

# -- 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.批量修改

# -- Django --
Game.objects.filter(category="RPG").update(category="ARPG")

# -- SQLAlchemy --
session.query(Game).filter_by(category="RPG").update({"category": "ARPG"})

7.批量刪除

# -- Django --
Game.objects.filter(category="ARPG").delete()

# -- SQLAlchemy --
session.query(Game).filter_by(category="ARPG").delete()

三、SQLAlchemy其他一些值得關(guān)注的功能
上面簡單列了一些SQLAlchemy ORM和Django ORM的使用方法對比，SQLAlchemy同時還提供了一些其他非常有用的功能，比如Automap~

假如你有一個Django項目，通過ORM創(chuàng)建了一大堆Model。這時來了一個新項目，需要操作這些表，應(yīng)該怎么辦？拷貝這些Models？使用原始的DB-API加上sql來操作？

其實使用SQLAlchemy的Automap可以讓你的工作變得非常的方便，你只要在新項目連接到舊數(shù)據(jù)庫，然后稍微配置一下Automap，就可以使用SQLAlchemy的ORM操作那些通過別的系統(tǒng)創(chuàng)建的表了。

就像這樣：

from sqlalchemy.ext.automap import automap_base
from sqlalchemy.orm import Session
from sqlalchemy import create_engine

Base = automap_base()
engine = create_engine("sqlite:///mydatabase.db")
Base.prepare(engine, reflect=True)

# user和address就是表明，通過這樣的語句就可以把他們分別映射到User和Address類
User = Base.classes.user
Address = Base.classes.address

更多信息可以參考詳細(xì)文檔：http://docs.sqlalchemy.org/en/rel_0_9/orm/extensions/automap.html

附：Django與SQLAlchemy結(jié)合的實例演示
譬如，以下gumi/db.py代碼，其中g(shù)umi制作Django項目名，項目中使用的唯一的數(shù)據(jù)庫連接的包裝，作為py調(diào)用。

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

模塊代碼

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): 
 pass 
mapper(SomeObject, some_table)

視圖代碼

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

您可能感興趣的文章: