Python的Django框架中选择SQLAlchemy操作数据库的学科

作者: 数据库信息  发布:2019-11-28

零、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的安装:

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

1.确立数据表

第风度翩翩,大家需求先创设多少个表。

(1)Django

在Django中,假如要建表,就是在models.py中定义你的数据类型:

from django.db import models

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

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

因为小说重要面向有经历的Django客商,所以这里不写出详细的概念代码。定义Model今后大家还索要在settings.py中DATABASES处设置需求连接的数据库地址。最终,使用syncdb来 完毕数据库表的创办。

(2)SQLAlchemy

在SQLAlchemy中,定义表构造的进度和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()

# 定义表结构
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() 了。

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中,有贰个非常主要的对象 session ,全数对于数据的操作都以通过session来进展的,所以要插入数据在此之前,我们得先伊始化多少个session:

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

从此插入数据的艺术也和Django相比相仿:

# 添加数据
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相关内容:

二、常用操作

1.差不离询问

(1卡塔 尔(英语:State of Qatar)批量询问

# -- 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" 来贯彻的,在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.计算个数

概括总括总量:

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

# -- SQLAlchemy --
session.query(Game).filter_by(category="RPG").count()
分组统计个数

# -- 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.结出排序

对查询结果进行排序:

# -- 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.校勘数据

# -- 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别的部分值得关切的效劳 地点轻松列了部分SQLAlchemy ORM和Django ORM的施用办法相比,SQLAlchemy同一时间还提供了有些其余特别低价的法力,举例Automap~

如若你有三个Django项目,通过ORM创制了第一次全国代表大会堆Model。当时来了二个新品类,必要操作 这么些表,应该咋做?拷贝这一个Models?使用原本的DB-API加上sql来操作?

实际选拔SQLAlchemy的Automap能够令你的行事变得要命的惠及,你若是在新类型三翻五次到旧数据库,然后 稍稍配置一下Automap,就能够动用SQLAlchemy的ORM操作那一个经过别的系统成立的表了。

就好像那样:

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

越多消息能够参照详细文书档案:

附:Django与SQLAlchemy结合的实例演示 举例说,以下gumi/db.py代码,在那之中gumi制作Django项目名,项目中选拔的必须要经过的路的数据库连接的包裹,作为py调用。

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

你或然感兴趣的篇章:

  • 运用python和Django完毕博客数据库的迁徙方法
  • 在python3条件下的Django中使用MySQL数据库的实例
  • python django 增加和删除改查操作 数据库Mysql
  • Django1.7 python 2.78 pycharm配置mysql数据库
  • 在Python的Django框架中改良数据库数据的措施
  • Python的Django框架中的数据库配置指南
  • Python的Django框架可适配的种种数据库介绍
  • django 定时限查询数据库实例代码

本文由金沙澳门官网发布于数据库信息,转载请注明出处:Python的Django框架中选择SQLAlchemy操作数据库的学科

关键词: 金沙澳门官网