在Python程序和Flask框架中使用SQLAlchemy的教程

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

ORM 江湖 何时,技师因为恐怖SQL而在开垦的时候严刻的写着sql,心中总是尤为重要惊慌,万一相当大心sql语句出错,搞坏了数据库如何做?又恐怕为了赢得一些数据,什么左右左右三番五次,函数存款和储蓄进度等等。无可否认,不搞懂那么些,怎么都觉着变扭,说不许某天就跳进了坑里,叫每一日不应,喊地地不答。

ORM 的现身,让畏惧SQL的开垦者,在坑里见到了爬出去的缆索,就疑似天上并非那么乌黑,起码再暗,大家也可以有了眼睛。望文生义,ORM 对象关系映射,同理可得,就是把数据库的八个个table(表),映射为编制程序语言的class(类)。

python中相比较闻名的ORM框架有超级多,大名顶顶的 SQLAlchemy 是python世界里责无旁贷的ORM框架。江湖中peewee,strom, pyorm,SQLObject 各领风骚,不过最终如故SQLAlchemy 昂首望天。

SQLAlchemy 简介 SQLAlchemy 分为多少个部分,一个用以 ORM 的靶子映射,此外三个是中央的 SQL expression 。第二个很好驾驭,纯粹的ORM,后边那么些不是 ORM,而是DBAPI的卷入,当然也提供了重重主意,制止了直白写sql,而是经过一些sql表达式。使用 SQLAlchemy 则能够分成二种方法。

  • 运用 sql expression ,通过 SQLAlchemy 的法门写sql表达式,简单介绍的写sql
  • 使用 raw sql, 直接书写 sql
  • 利用 ORM 避开直接书写 sql

正文先探求 SQLAlchemy的 sql expresstion 部分的用法。主要依旧接着官方的 SQL Expression Language Tutorial.介绍

为何要学习 sql expresstion ,而不间接上 ORM?因为背后这些八个是 orm 的底蕴。而且,正是不利用orm,前面那四个也能很好的达成专门的学问,何况代码的可读性更加好。纯粹把SQLAlchemy当成dbapi使用。首先SQLAlchemy 内建数据库连接池,肃清了连接操作相关冗杂的拍卖。其次,提供方便的无敌的log成效,最终,复杂的查询语句,依赖单纯的ORM相比较难达成。

实战
三番一遍数据库
先是须要导入 sqlalchemy 库,然后塑造数据库连接,这里运用 mysql。通过create_engine方法进行

from sqlalchemy import create_engine
engine = create_engine("mysql://root:@localhost:3306/webpy?charset=utf8",encoding="utf-8", echo=True)

create_engine 方法举办数据库连接,重返二个 db 对象。里面包车型地铁参数表示

数据库类型://顾客名:密码(没有密码则为空,不填卡塔 尔(阿拉伯语:قطر‎@数据库主机地址/数据库名?编码
echo = True 是为了方便 调整台 logging 输出一些sql音信,默认是False
经过这些engine对象足以直接execute 进行查询,举个例子 engine.execute("SELECT * FROM user") 也足以透过 engine 获取连接在查询,举个例子 conn = engine.connect() 通过 conn.execute()方法实行查询。两者有哪些差异吗?

一贯利用engine的execute实践sql的不二诀窍, 叫做connnectionless试行,
依据于 engine.connect()获取conn, 然后通过conn实行sql, 叫做connection实行
重视差距在于是或不是使用transaction形式, 假如不涉及transaction, 三种办法效果是风华正茂致的. 官方网址推荐使用前者。
定义表 概念数据表,技术开展sql表达式的操作,终归sql表明式的表的鲜明,是sqlalchemy制定的,要是数据库已经存在了数据表还索要定义么?当然,这里其实是四个辉映关系,假使不内定,查询表明式就不知道是外加在老大表的操作,当然定义的时候,注意表名和字段名,代码和数指标必需保持豆蔻梢头致。定义好现在,就会成立数据表,大器晚成旦创造了,再一次运转创制的代码,数据库是不会创制的。

# -*- coding: utf-8 -*-
__author__ = 'ghost'

from sqlalchemy import create_engine, Table, Column, Integer, String, MetaData, ForeignKey
# 连接数据库 
engine = create_engine("mysql://root:@localhost:3306/webpy?charset=utf8",encoding="utf-8", echo=True)
# 获取元数据
metadata = MetaData()
# 定义表
user = Table('user', metadata,
  Column('id', Integer, primary_key=True),
  Column('name', String(20)),
  Column('fullname', String(40)),
 )

address = Table('address', metadata,
  Column('id', Integer, primary_key=True),
  Column('user_id', None, ForeignKey('user.id')),
  Column('email', String(60), nullable=False)
 )
# 创建数据表,如果数据表存在,则忽视
metadata.create_all(engine)
# 获取数据库连接
conn = engine.connect()

插入 insert 有了数据表和连接对象,对应数据库操作就大致了。

>>> i = user.insert() # 使用查询
>>> i 
<sqlalchemy.sql.dml.Insert object at 0x0000000002637748>
>>> print i # 内部构件的sql语句
INSERT INTO "user" (id, name, fullname) VALUES (:id, :name, :fullname)
>>> u = dict(name='jack', fullname='jack Jone')
>>> r = conn.execute(i, **u) # 执行查询,第一个为查询对象,第二个参数为一个插入数据字典,如果插入的是多个对象,就把对象字典放在列表里面
>>> r
<sqlalchemy.engine.result.ResultProxy object at 0x0000000002EF9390>
>>> r.inserted_primary_key # 返回插入行 主键 id
[4L]
>>> addresses
[{'user_id': 1, 'email': 'jack@yahoo.com'}, {'user_id': 1, 'email': 'jack@msn.com'}, {'user_id': 2, 'email': 'www@www.org'}, {'user_id': 2, 'email': 'wendy@aol.com'}]
>>> i = address.insert()
>>> r = conn.execute(i, addresses) # 插入多条记录
>>> r
<sqlalchemy.engine.result.ResultProxy object at 0x0000000002EB5080>
>>> r.rowcount #返回影响的行数
4L

>>> i = user.insert().values(name='tom', fullname='tom Jim')
>>> i.compile()
<sqlalchemy.sql.compiler.SQLCompiler object at 0x0000000002F6F390>
>>> print i.compile()
INSERT INTO "user" (name, fullname) VALUES (:name, :fullname)
>>> print i.compile().params
{'fullname': 'tom Jim', 'name': 'tom'}
>>> r = conn.execute(i)
>>> r.rowcount
1L

查询 select 查询情势很灵巧,超级多时候利用 sqlalchemy.sql 上边包车型大巴 select方法

>>> s = select([user]) # 查询 user表
>>> s
<sqlalchemy.sql.selectable.Select at 0x25a7748; Select object>
>>> print s
SELECT "user".id, "user".name, "user".fullname 
FROM "user"

假如需求查询自定义的字段,可是使用 user 的cloumn 对象,举例

>>> user.c # 表 user 的字段column对象
<sqlalchemy.sql.base.ImmutableColumnCollection object at 0x0000000002E804A8>
>>> print user.c
['user.id', 'user.name', 'user.fullname']
>>> s = select([user.c.name,user.c.fullname])
>>> r = conn.execute(s)
>>> r
<sqlalchemy.engine.result.ResultProxy object at 0x00000000025A7748>
>>> r.rowcount # 影响的行数
5L
>>> ru = r.fetchall() 
>>> ru
[(u'hello', u'hello world'), (u'Jack', u'Jack Jone'), (u'Jack', u'Jack Jone'), (u'jack', u'jack Jone'), (u'tom', u'tom Jim')]
>>> r 
<sqlalchemy.engine.result.ResultProxy object at 0x00000000025A7748>
>>> r.closed # 只要 r.fetchall() 之后,就会自动关闭 ResultProxy 对象
True

何况询问五个表

>>> s = select([user.c.name, address.c.user_id]).where(user.c.id==address.c.user_id) # 使用了字段和字段比较的条件
>>> s
<sqlalchemy.sql.selectable.Select at 0x2f03390; Select object>
>>> print s
SELECT "user".name, address.user_id 
FROM "user", address 
WHERE "user".id = address.user_id

操作符

>>> print user.c.id == address.c.user_id # 返回一个编译的字符串
"user".id = address.user_id
>>> print user.c.id == 7
"user".id = :id_1 # 编译成为带参数的sql 语句片段字符串
>>> print user.c.id != 7
"user".id != :id_1
>>> print user.c.id > 7
"user".id > :id_1
>>> print user.c.id == None
"user".id IS NULL
>>> print user.c.id   address.c.id # 使用两个整形的变成  
"user".id   address.id
>>> print user.c.name   address.c.email # 使用两个字符串 变成 ||
"user".name || address.email

操作连接 此处的连天指条件查询的时候,逻辑运算符的连续几天,即 and or 和 not

>>> print and_(
  user.c.name.like('j%'),
  user.c.id == address.c.user_id,
  or_(
   address.c.email == 'wendy@aol.com',
   address.c.email == 'jack@yahoo.com'
  ),
  not_(user.c.id>5))
"user".name LIKE :name_1 AND "user".id = address.user_id AND (address.email = :email_1 OR address.email = :email_2) AND "user".id <= :id_1
>>> 

收获的结果为 编译的sql语句片段,下边看三个安然无事的例子

>>> se_sql = [(user.c.fullname  ", "   address.c.email).label('title')]
>>> wh_sql = and_(
    user.c.id == address.c.user_id,
    user.c.name.between('m', 'z'),
    or_(
     address.c.email.like('%@aol.com'),
     address.c.email.like('%@msn.com')
    )
   )
>>> print wh_sql
"user".id = address.user_id AND "user".name BETWEEN :name_1 AND :name_2 AND (address.email LIKE :email_1 OR address.email LIKE :email_2)
>>> s = select(se_sql).where(wh_sql)
>>> print s
SELECT "user".fullname || :fullname_1 || address.email AS title 
FROM "user", address 
WHERE "user".id = address.user_id AND "user".name BETWEEN :name_1 AND :name_2 AND (address.email LIKE :email_1 OR address.email LIKE :email_2)
>>> r = conn.execute(s)
>>> r.fetchall()

使用 raw sql 方式

相遇担负的sql语句的时候,能够应用 sqlalchemy.sql 上边包车型客车 text 函数。将字符串的sql语句包装编写翻译成为 execute推行供给的sql对象。举例:、

>>> text_sql = "SELECT id, name, fullname FROM user WHERE id=:id" # 原始sql语句,参数用( :value)表示
>>> s = text(text_sql)
>>> print s
SELECT id, name, fullname FROM user WHERE id=:id
>>> s
<sqlalchemy.sql.elements.TextClause object at 0x0000000002587668>
>>> conn.execute(s, id=3).fetchall() # id=3 传递:id参数
[(3L, u'Jack', u'Jack Jone')]

连接 join 接连几日有join 和 outejoin 四个议程,join 有八个参数,第4个是join 的表,第二个是on 的尺度,joing之后必须求协作select_from 方法:

>>> print user.join(address)
"user" JOIN address ON "user".id = address.user_id # 因为开启了外键 ,所以join 能只能识别 on 条件
>>> print user.join(address, address.c.user_id==user.c.id) # 手动指定 on 条件
"user" JOIN address ON address.user_id = "user".id

>>> s = select([user.c.name, address.c.email]).select_from(user.join(address, user.c.id==address.c.user_id)) # 被jion的sql语句需要用 select_from方法配合


>>> s
<sqlalchemy.sql.selectable.Select at 0x2eb63c8; Select object>
>>> print s
SELECT "user".name, address.email 
FROM "user" JOIN address ON "user".id = address.user_id
>>> conn.execute(s).fetchall()
[(u'hello', u'jack@yahoo.com'), (u'hello', u'jack@msn.com'), (u'hello', u'jack@yahoo.com'), (u'hello', u'jack@msn.com'), (u'Jack', u'www@www.org'), (u'Jack', u'wendy@aol.com'), (u'Jack', u'www@www.org'), (u'Jack', u'wendy@aol.com')]

排序 分组 分页 排序使用 order_by 方法,分组是 group_by ,分页自然就是limit 和 offset五个主意合营

>>> s = select([user.c.name]).order_by(user.c.name) # order_by
>>> print s
SELECT "user".name 
FROM "user" ORDER BY "user".name
>>> s = select([user]).order_by(user.c.name.desc())
>>> print s
SELECT "user".id, "user".name, "user".fullname 
FROM "user" ORDER BY "user".name DESC
>>> s = select([user]).group_by(user.c.name)  # group_by
>>> print s
SELECT "user".id, "user".name, "user".fullname 
FROM "user" GROUP BY "user".name
>>> s = select([user]).order_by(user.c.name.desc()).limit(1).offset(3) # limit(1).offset(3)
>>> print s
SELECT "user".id, "user".name, "user".fullname 
FROM "user" ORDER BY "user".name DESC
 LIMIT :param_1 OFFSET :param_2
[(4L, u'jack', u'jack Jone')]

更新 update 近些日子都以意气风发对查询,更新和插入的措施很像,都是表下边的艺术,不一样的是,update 多了叁个 where 方法 用来选拔过滤

>>> s = user.update()
>>> print s
UPDATE "user" SET id=:id, name=:name, fullname=:fullname
>>> s = user.update().values(fullname=user.c.name)   # values 指定了更新的字段
>>> print s
UPDATE "user" SET fullname="user".name
>>> s = user.update().where(user.c.name == 'jack').values(name='ed') # where 进行选择过滤
>>> print s 
UPDATE "user" SET name=:name WHERE "user".name = :name_1
>>> r = conn.execute(s)
>>> print r.rowcount   # 影响行数
3

还应该有贰个高端用法,就是叁回命令实施八个记录的校订,需求用到 bindparam 方法

>>> s = user.update().where(user.c.name==bindparam('oldname')).values(name=bindparam('newname')) # oldname 与下面的传入的从拿书进行绑定,newname也一样
>>> print s
UPDATE "user" SET name=:newname WHERE "user".name = :oldname
>>> u = [{'oldname':'hello', 'newname':'edd'},
{'oldname':'ed', 'newname':'mary'},
{'oldname':'tom', 'newname':'jake'}]
>>> r = conn.execute(s, u)
>>> r.rowcount
5L

删除 delete 除去比较简单,调用 delete方法就可以,不加 where 过滤,则删除全部数据,不过不会drop掉表,等于清空了数据表

>>> r = conn.execute(address.delete()) # 清空表
>>> print r
<sqlalchemy.engine.result.ResultProxy object at 0x0000000002EAF550>
>>> r.rowcount
8L
>>> r = conn.execute(users.delete().where(users.c.name > 'm')) # 删除记录
>>> r.rowcount
3L


**
flask-sqlalchemy
**SQLAlchemy已经济体制改正成了python世界中间orm的正统,flask是贰个翩翩的web框架,能够放肆的行使orm,在那之中flask-sqlalchemy是特别为flask钦命的插件。

安装flask-sqlalchemy

pip install flask-sqlalchemy

初始化sqlalchemy

from flask import Flask
from flask.ext.sqlalchemy import SQLAlchemy


app = Flask(__name__)

#     dialect driver://username:password@host:port/database?charset=utf8
# 配置 sqlalchemy 数据库驱动://数据库用户名:密码@主机地址:端口/数据库?编码
app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://root:@localhost:3306/sqlalchemy?charset=utf8'
# 初始化
db = SQLAlchemy(app)

定义model

class User(db.Model):
 """ 定义了三个字段, 数据库表名为model名小写
 """
 id = db.Column(db.Integer, primary_key=True)
 username = db.Column(db.String(80), unique=True)
 email = db.Column(db.String(120), unique=True)

 def __init__(self, username, email):
  self.username = username
  self.email = email

 def __repr__(self):
  return '<User %r>' % self.username

 def save(self):
  db.session.add(self)
  db.session.commit()

创设数量表 数据包的成立使用sqlalchemy app,假若表已经存在,则忽视,倘使官样文章,则新建

>>> from yourapp import db, User
>>> u = User(username='admin', email='admin@example.com') # 创建实例
>>> db.session.add(u)          # 添加session
>>> db.session.commit()         # 提交查询
>>> users = User.query.all()        # 查询

急需在意的是,假如要插入普通话,必需插入 unicode字符串

>>> u = User(username=u'人世间', email='rsj@example.com')
>>> u.save()

概念关系 关系型数据库,最珍视的正是涉及。常常涉及分成 大器晚成对豆蔻梢头(举例无限级栏目卡塔尔国,大器晚成对多(小说和栏目卡塔尔,多对多(小说和标签卡塔尔

one to many:
小编们定义贰个Category(栏目卡塔 尔(阿拉伯语:قطر‎和Post(小说卡塔 尔(英语:State of Qatar),两个是后生可畏对多的涉及,二个栏目有不菲稿子,三个文章归属三个栏目。

class Category(db.Model):
 id = db.Column(db.Integer, primary_key=True)
 name = db.Column(db.String(50))

 def __init__(self, name):
  self.name = name

 def __repr__(self):
  return '<Category %r>' % self.name

class Post(db.Model):
 """ 定义了五个字段,分别是 id,title,body,pub_date,category_id
 """
 id = db.Column(db.Integer, primary_key=True)
 title = db.Column(db.String(80))
 body = db.Column(db.Text)
 pub_date = db.Column(db.String(20))
 # 用于外键的字段
 category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
 # 外键对象,不会生成数据库实际字段
 # backref指反向引用,也就是外键Category通过backref(post_set)查询Post
 category = db.relationship('Category', backref=db.backref('post_set', lazy='dynamic'))


 def __init__(self, title, body, category, pub_date=None):
  self.title = title
  self.body = body
  if pub_date is None:
   pub_date = time.time()
  self.pub_date = pub_date
  self.category = category

 def __repr__(self):
  return '<Post %r>' % self.title

 def save(self):
  db.session.add(self)
  db.session.commit()

怎么样利用查询呢?

>>> c = Category(name='Python')
>>> c
<Category 'Python'>
>>> c.post_set
<sqlalchemy.orm.dynamic.AppenderBaseQuery object at 0x0000000003B58F60>
>>> c.post_set.all()
[]
>>> p = Post(title='hello python', body='python is cool', category=c)
>>> p.save()
>>> c.post_set
<sqlalchemy.orm.dynamic.AppenderBaseQuery object at 0x0000000003B73710>
>>> c.post_set.all() # 反向查询
[<Post u'hello python'>]
>>> p
<Post u'hello python'>
>>> p.category
<Category u'Python'>
# 也可以使用category_id 字段来添加
>>> p = Post(title='hello flask', body='flask is cool', category_id=1)
>>> p.save()

many to many (评论已经提议,那样的做法不能关联删除,简书未有去除线格式,多多对例子作废,在这里提醒,防止被误导卡塔尔国
对于多对多的关系,往往是概念叁个几个model的id的其余一张表,比如 Post 和 Tag之间是多对多,须要定义贰个 Post_Tag的表

post_tag = db.Table('post_tag',
     db.Column('post_id', db.Integer, db.ForeignKey('post.id')),
     db.Column('tag_id', db.Integer, db.ForeignKey('tag.id'))
    )

class Post(db.Model):

 id = db.Column(db.Integer, primary_key=True)
 # ... 省略
 # 定义一个反向引用,tag可以通过 post_set查询到 post的集合
 tags = db.relationship('Tag', secondary=post_tag,
       backref=db.backref('post_set', lazy='dynamic'))

class Tag(db.Model):
 id = db.Column(db.Integer, primary_key=True)
 content = db.Column(db.String(10), unique=True)
 # 定义反向查询
 posts = db.relationship('Post', secondary=post_tag,
       backref=db.backref('tag_set', lazy='dynamic'))

 def __init__(self, content):
  self.content = content

 def save(self):
  db.session.add(self)
  db.session.commit()

查询:

>>> tag_list = []
>>> tags = ['python', 'flask', 'ruby', 'rails']
>>> for tag in tags:
  t = Tag(tag)
  tag_list.append(t)
>>> tag_list
[<f_sqlalchemy.Tag object at 0x0000000003B7CF28>, <f_sqlalchemy.Tag object at 0x0000000003B7CF98>, <f_sqlalchemy.Tag object at 0x0000000003B7CEB8>, <f_sqlalchemy.Tag object at 0x0000000003B7CE80>]
>>> p
<Post u'hello python'>
>>> p.tags
[]
>>> p.tags = tag_list # 添加多对多的数据
>>> p.save()
>>> p.tags
[<f_sqlalchemy.Tag object at 0x0000000003B7CF28>, <f_sqlalchemy.Tag object at 0x0000000003B7CF98>, <f_sqlalchemy.Tag object at 0x0000000003B7CEB8>, <f_sqlalchemy.Tag object at 0x0000000003B7CE80>]
>>> p.tag_set   # 反向查询
<sqlalchemy.orm.dynamic.AppenderBaseQuery object at 0x0000000003B7C080>
>>> p.tag_set.all()
[<f_sqlalchemy.Tag object at 0x0000000003B7CF28>, <f_sqlalchemy.Tag object at 0x0000000003B7CF98>, <f_sqlalchemy.Tag object at 0x0000000003B7CEB8>, <f_sqlalchemy.Tag object at 0x0000000003B7CE80>]
>>> t = Tag.query.all()[1]
>>> t
<f_sqlalchemy.Tag object at 0x0000000003B7CF28>
>>> t.content
u'python'
>>> t.posts
[<Post u'hello python'>]
>>> t.post_set
<sqlalchemy.orm.dynamic.AppenderBaseQuery object at 0x0000000003B7C358>
>>> t.post_set.all()
[<Post u'hello python'>]
self one to one

本人民代表大会器晚成对黄金年代也是常用的要求,譬喻Infiniti分级栏目

class Category(db.Model):
 id = db.Column(db.Integer, primary_key=True)
 name = db.Column(db.String(50))
 # 父级 id
 pid = db.Column(db.Integer, db.ForeignKey('category.id'))
 # 父栏目对象
 pcategory = db.relationship('Category', uselist=False, remote_side=[id], backref=db.backref('scategory', uselist=False))

 def __init__(self, name, pcategory=None):
  self.name = name
  self.pcategory = pcategory

 def __repr__(self):
  return '<Category %r>' % self.name

 def save(self):
  db.session.add(self)
  db.session.commit()

查询:

>>> p = Category('Python')
>>> p
<Category 'Python'>
>>> p.pid
>>> p.pcategory # 查询父栏目
>>> p.scategory # 查询子栏目
>>> f = Category('Flask', p)
>>> f.save()
>>> f
<Category u'Flask'>
>>> f.pid
1L
>>> f.pcategory # 查询父栏目
<Category u'Python'>
>>> f.scategory # 查询父栏目
>>> p.scategory # 查询子栏目
<Category u'Flask'>

有关 flask-sqlalchemy 定义models的简要利用就像此多,更加的多的技巧在于咋样询问。

你大概感兴趣的小说:

  • Python的Flask框架中选用Flask-SQLAlchemy管理数据库的教程
  • Python利用flask sqlalchemy完成分页效果
  • Python的Flask框架中SQLAlchemy使用时的乱码难题消弭
  • 在Python的Flask框架下接收sqlalchemy库的简短教程
  • Python的Flask框架与数据库连接的课程
  • Python的Flask框架中央银行使Flask-Migrate扩张迁移数据库的科目
  • Python框架Flask的主干数据库操作方法深入分析
  • Python使用Flask-SQLAlchemy连接数据库操作示例

本文由金沙澳门官网发布于数据库信息,转载请注明出处:在Python程序和Flask框架中使用SQLAlchemy的教程

关键词: 金沙澳门官网