【python】Flask-SQLAlchemy的使用_python的flask框架中使用flask-sqlalchemy管理数据库的教程

一、ORM

Object-Relation Mapping，中文意为对象-关系映射
主要实现模型对象到关系数据库数据的映射

1.1 优点

• 只需要面向对象编程, 不需要面向数据库编写代码
  a. 对数据库的操作都转化成对类属性和方法的操作
  b. 不用编写各种数据库的sql语句.

• 实现了数据模型与数据库的解耦, 屏蔽了不同数据库操作上的差异
  a. 不再需要关注当前项目使用的是哪种数据库
  b. 通过简单的配置就可以轻松更换数据库, 而不需要修改代码

1.2 缺点

• 相比较直接使用SQL语句操作数据库,有性能损失
• 根据对象的操作转换成SQL语句，根据查询的结果转化成对象, 在映射过程中有性能损失

二、Flask-SQLAlchemy使用

flask默认提供模型操作，但是并没有提供ORM，所以一般都会采用flask-SQLAlchemy模块来实现ORM操作

SQLAlchemy是一个关系型数据库框架，它提供了高层的 ORM 和底层的原生数据库的操作

flask-sqlalchemy是一个简化了SQLAlchemy操作的flask扩展

2.1 安装依赖

安装 flask-sqlalchemy

pip install flask-sqlalchemy
1

如果连接的是mysql数据库，需要安装mysqldb驱动

pip install flask-mysqldb
1

2.2 数据库连接配置

config/dev.py中配置数据库连接信息

class DevConfig(object):
	USERNAME = "lluozh"
	PASSWORD = "123456"
	HOST = '172.18.20.53'
	PORT = 3306
	DATABASE = 'swqaserver'
	DB_URI = 'mysql+pymysql://{}:{}@{}:{}/{}?charset=utf8'.format(USERNAME,PASSWORD,HOST,PORT,DATABASE)
	SQLALCHEMY_DATABASE_URI = DB_URI
	SQLALCHEMY_TRACK_MODIFICATIONS = False
	SQLALCHEMY_ECHO = True
	
	SQLALCHEMY_POOL_RECYCLE = 100
	SQLALCHEMY_POOL_TIMEOUT = 20
1
2
3
4
5
6
7
8
9
10
11
12
13

在dao/__init__.py中实例化db

from config import dbConf
from flask import Flask
from flask_sqlalchemy import SQLAlchemy


app = Flask(__name__)

app.config.from_object(dbConf)
db = SQLAlchemy(app)  # 数据库连接
1
2
3
4
5
6
7
8
9

2.3 模型表

在dao/orm/User中声明模型类User

from dao import db

# 创建数据模型必须继承db.Model
class User(db.Model):
    # 表选项
    __tablename__ = 'users' # 设置表名
    # 声明字段
    # db.Column(字段类型,选项)
    id = db.Column(db.Integer,primary_key=True)
    name = db.Column(db.String(64),unique=True)
    born = db.Column(db.Date, index=True)
    email = db.Column(db.String(64), unique=True)
    password = db.Column( db.String(64) )
    # 设置外键
    role_id = db.Column(db.Integer, db.ForeignKey("roles.id"))

    # __repr__方法类似于django的__str__，用于打印模型对象时显示的字符串信息
    def __repr__(self):
        return 'User:%s'% self.name
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

在dao/orm/Role中声明模型类Role

from dao import db

class Role(db.Model):
    # 定义表名
    __tablename__ = 'roles' # 定义表名
    # 定义列对象
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(64), unique=True)
    # 设置外键[用于1查询多的情况]
    us = db.relationship('User', backref='role',lazy='dynamic')
    # repr()方法类似于django的__str__，用于打印模型对象时显示的字符串信息
    def __repr__(self):
        return 'Role:%s'% self.name
1
2
3
4
5
6
7
8
9
10
11
12
13

2.4 数据库操作

2.4.1 添加数据

• 添加一条数据

role1 =Role(name='实习生')
    db.session.add(role)
    db.session.commit()
db.session.add(role1)
db.session.commit()
1
2
3
4
5

• 添加多条数据

us1 = User(name='liu', email='liu@163.com', password='867322', role_id=2)
us2 = User(name='li', email='li@163.com', password='4526342', role_id=3)
us3 = User(name='sun', email='sun@163.com', password='235523', role_id=2)

db.session.add_all([us1,us2,us3])
db.session.commit()
1
2
3
4
5
6

2.4.2 查询数据

• filter_by精确查询

返回名字等于wang的所有人

User.query.filter_by(name='wang').all()
1

• first()返回查询到的第一个对象

User.query.first()
1

• all()返回查询到的所有对象

User.query.all()
1

• filter模糊查询

返回名字结尾字符为g的所有数据

User.query.filter(User.name.endswith('g')).all()
1

• get()主键

参数为主键，如果主键不存在没有返回内容

User.query.get(1)
1

• 逻辑非

返回名字不等于wang的所有数据

User.query.filter(User.name!='wang').all()
1

• not_相当于取反

from sqlalchemy import not_
User.query.filter(not_(User.name=='chen')).all()
1
2

• 逻辑与

需要导入and，返回and()条件满足的所有数据

from sqlalchemy import and_
User.query.filter(and_(User.name!='wang',User.email.endswith('163.com'))).all()
1
2

• 逻辑或

需要导入or_

from sqlalchemy import or_
User.query.filter(or_(User.name!='wang',User.email.endswith('163.com'))).all()
1
2

2.4.3 更新数据

# 1.执行查询语句, 获取目标模型对象
user = User.query.filter_by(name='wang').first()
# 2.对模型对象的属性进行赋值 (更新数据)
user.name = 'lluozh'
# 3.提交会话
db.session.commit()
1
2
3
4
5
6

2.4.4 删除数据

user = User.query.filter_by(name='wang').first()
db.session.delete(user)
db.session.commit()
1
2
3

三、常见的操作语句

db.session.add(obj) 添加对象
db.session.add_all([obj1,obj2,..]) 添加多个对象
db.session.delete(obj) 删除对象
db.session.commit() 提交会话
db.session.rollback() 回滚
db.session.remove() 移除会话
1
2
3
4
5
6

四、常用的SQLAlchemy查询过滤器

用来过滤数据，返回查询的结果集

# 把过滤器添加到原查询上，返回一个新查询
filter()

# 把等值过滤器添加到原查询上，返回一个新查询
filter_by()

# 使用指定的值限定原查询返回的结果
limit

# 偏移原查询返回的结果，返回一个新查询
offset()

# 根据指定条件对原查询结果进行排序，返回一个新查询
order_by()

# 根据指定条件对原查询结果进行分组，返回一个新查询
group_by()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

五、常用的SQLAlchemy查询执行器

用来执行结果集，得到具体数据

# 以列表形式返回查询的所有结果
all()

# 返回查询的第一个结果，如果未查到，返回None
first()

# 返回查询的第一个结果，如果未查到，返回404
first_or_404()

# 返回指定主键对应的行，如不存在，返回None
get()

# 返回指定主键对应的行，如不存在，返回404
get_or_404()

# 返回查询结果的数量
count()

# 返回一个Paginate对象，它包含指定范围内的结果
paginate()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20