flask sqlalchemy

pip install flask-sqlalchemy

pip install flask-mysqldb

pip install pymysql

flask-sqlalchemy所作的操作只是把模型类转换为 sql 语句，然后通过数据库驱动访问mysql，在获取到结果后再把数据转换为模型对象

Flask的数据库设置：

app.config[‘SQLALCHEMY_DATABASE_URI’] = ‘mysql://root:root@127.0.0.1:3306/test’

设置每次请求结束后会自动提交数据中的更改，官方不推荐设置

app.config[‘SQLALCHEMY_COMMIT_ON_TEARDOWN’] = True

#如果一旦在数据库中把表结构修改，那么在sqlalchemy中的模型类也进行修改

app.config[‘SQLALCHEMY_TRACK_MODIFICATIONS’] = True

查询时显示原始SQL语句

app.config[‘SQLALCHEMY_ECHO’] = True

db = SQLAlchemy(app)

创建daemo_db.py内容如下

# coding:utf-8
from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)


class Config(object):
    SQLALCHEMY_DATABASE_URI = "mysql://root:root@127.0.0.1:3306/db_python04"
    # 设置sqlalchemy自动跟踪数据库
    SQLALCHEMY_TRACK_MODIFICATIONS = True


app.config.from_object(Config)

# 表名的常见规范，并不是以数据库模型名称命名
# ihome -> ih_user    数据库名缩写_表名
# tbl_user            tbl_表名
# 创建数据库sqlalchemy工具对象
db = SQLAlchemy(app)


# 创建数据库模型类
class Role(db.Model):
    __tablename__ = "tbl_roles"
    # 数据库中真实存在的字段， db.Column
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(64), unique=True)
    # 数据库中不真实存在的,比如模型与模型之间的一种关联，根据角色查询属于这个角色的用户有哪些
    # 这里的设计不像外键是根据表的实际情况考虑，而根据模型考虑的
    # User 是让role对象可以获得user中的属性
    # backref="role"可以让user对象有个role属性获得role中的信息，这个不是必须添加的，如果不添加那么user对象要通过外键role_id获得这个用户的角色信息
    users = db.relationship("User", backref="role")


class User(db.Model):
    __tablename__ = "tbl_users"
    id = db.Column(db.Integer, primary_key=True)  # 整型的主键，会默认设置为自增主键
    name = db.Column(db.String(64), unique=True)
    email = db.Column(db.String(126), unique=True)
    password = db.Column(db.String(128))
    role_id = db.Column(db.Integer, db.ForeignKey("tbl_roles.id"))  # 外键


# @app.route('/')
# def index():

if __name__ == '__main__':
    # app.run()
    # 清除数据库的所有数据
    db.drop_all()
    # 创建表
    db.create_all()
    # 添加数据
    # 创建对象
    role1 = Role(name="admin")
    # 用session记录对象任务
    db.session.add(role1)
    # 提交任务到数据库中
    db.session.commit()

    role2 = Role(name="stuff")
    db.session.add(role2)
    db.session.commit()

    us1 = User(name='zhangsan', email='zhangsan@163.com', password='123', role_id=role1.id)
    us2 = User(name='lisi', email='lisi@163.com', password='123', role_id=role2.id)
    us3 = User(name='wangwu', email='wangwu@163.com', password='123', role_id=role2.id)
    us4 = User(name='zhaoliu', email='zhaoliu@163.com', password='123', role_id=role1.id)

    # 一次保存多条数据
    db.session.add_all([us1, us2, us3, us4])
    db.session.commit()

在pycharm中通过终端进入虚拟环境

进入python，并导入daemon_db

# 使用db.session查询指定对象的所有记录

# 这是sqlalchemy提供的最底层的方法

db.session.query(Role).all()

db.session.query(Role).first()

是flask-sqlalchemy查询

# 查询Role对象的所有数据，结果是一个列表

# 这是flask-sqlalchemy封装sqlalchemy后的方法

li = Role.query.all()

# 获得一个role类型的对象

r = li[0]

# 获得对象的一个属性值

r.name

>>> li = Role.query.all()
>>> r = li[0]
>>> r
<Role 1>
>>> r.name
'admin'
>>>

# 查询第一条记录

>>> r = Role.query.first()
>>> r.name
'admin'
>>>

# 获取一个具体对象，必须接受一个参数，必须是主键的值

>>> r = Role.query.get(2)
>>> r.name
'stuff'

# 常用的sqlalchemy查询过滤器

过滤器 说明

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

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

limit 使用知道的值限定原查询返回的结果

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

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

group_by() 根据指定条件对原查询结果进行分组，返回一个新查询

# 只针对user表进行查询，那么user的字段就可以进行简写操作

# 返回一个查询，如果要获得结果还需要在结尾加 all() 或first()

# 只针对user表进行查询，那么user的字段就可以进行简写操作

# 返回一个查询，如果要获得结果还需要在结尾加 all() 或first()

# 完整查询语法

User.query.filter().order_by().offset().limit().all()

>>> u1 = User.query.filter_by(name='zhangsan').all()
>>> u1
[<User 1>]
>>> u1[0].name
'zhangsan'
>>> u1[0].email
'zhangsan@163.com'
>>> u2 = User.query.filter_by(name='zhangsan').first()
>>> u2.name
'zhangsan'
>>> u2.id
1
>>> u2.email
'zhangsan@163.com'

# 查询条件两个，以 and 的方式拼接，并且匹配方式必须是完全匹配 =，不能使用模糊查询,filter_by是filter的简写形式

>>> u1 = User.query.filter_by(name='zhangsan', role_id=1).all()
>>> u1[0]
<User 1>

#filter是万能过滤器，但是即使只差一张表，字段名都要加上对象名称

>>> user = User.query.filter(User.name=='zhangsan', User.role_id==1).all()
>>> user[0].name
'zhangsan'

# 执行或操作

# 查询名字为zhangsan 或邮箱以 163.com 结尾,返回一个列表

>>> from sqlalchemy import or_
>>> li = User.query.filter(or_(User.name=='zhangsan',User.email.endswith("163.com"))).all()
>>> li[0].name
'zhangsan'
>>> li[1].name
'lisi'

#(跳过两条记录）从第3条记录开始取

>>> li=User.query.offset(2).all()
>>> li[0].name
'wangwu'
>>> li[1].name
'zhaoliu'

#(跳过1条，取两条）

>>> User.query.offset(1).limit(2).all()
[<User 2>, <User 3>]

# 根据id反向排序，不推荐

>>> User.query.order_by("-id").all()
C:\Users\Administrator\.virtualenvs\flask-0VgPQDMY\lib\site-packages\sqlalchemy\sql\compiler.py:763: SAWarning: Can't resolve label reference '-id'; converting to text() (this warning may be suppressed after 10 oc
currences)
  util.ellipses_string(element.element),
[<User 4>, <User 3>, <User 2>, <User 1>]

# 根据id反向排序，官方推荐

>>> User.query.order_by(User.id.desc()).all()
[<User 4>, <User 3>, <User 2>, <User 1>]

#group_by语句不能用flask-sqlalchemy的对象进行操作，必须用sqlalchemy最原始的方式进行操作，并要冲sqlalchemy中导入func这个工具

#进行分组查询，query中必须包含分组后必须显示出的字段

>>> from sqlalchemy import func
>>> db.session.query(User.role_id,func.count(User.role_id)).group_by(User.role_id).all()
[(1, 2), (2, 2)]

# 对应 的sql语句

select role_id,count(role_id) from tbl_users group by role_id;

##############

更新操作

# 先获取对象

# 修改对象属性

# 将对象修改后更新到数据库

>>> user = User.query.get(1)
>>> user.name = "python"
>>> db.session.add(user)
>>> db.session.commit()
>>> User.query.get(1)
>>> u1=User.query.get(1)
>>> u1.name
'python'

# 查询出结果过直接更新

>>> User.query.filter_by(name="wangwu").update({"name":"linux","email":"linux@163.com"})
1
>>> db.session.commit()

#删除操作

>>> user = User.query.get(3)
>>> db.session.delete(user)
>>> db.session.commit()
>>> User.query.all()
[<User 1>, <User 2>, <User 4>]