mysql flaskalchemy_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

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

[]

>>> 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]

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

[, ]

# 根据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),

[, , , ]

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

>>> User.query.order_by(User.id.desc()).all()

[, , , ]

#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;

#查询指定字段，使用with_entities 关键字

User.query.with_entities(User.name).filter_by(role_id='1').order_by(User.email.desc()).limit(1).all()

# 对应的sql语句

select name from tbl_users where u_id=’1′ order by create_time desc limit 1;

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

更新操作

# 先获取对象

# 修改对象属性

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

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

[, , ]