Day19-flask-关系模型及分页

1分页

筛选

offset()

limit()

order_by()

get()

first()

paginate()

跳转->在html中的应用

方法一：

跳转
后端函数：
@uesrs_blue.route('/create_ref/')
def create_ref():

方法二：

修改
后端函数：
@uesrs_blue.route('/update_stu/',methods=['GET','POST'])
def update_stu(id):

方法三：

上一页
后端函数：
@uesrs_blue.route('/paginate/')
def paginate():
获取分页的当前页
page=int(request.args.get('page',1))

例子：

跳过offset几个信息，截取limit结果的几个值

按照id降序排列

stus = Student.query.order_by('-s_id')

按照id升序排列

stus = Student.query.order_by('s_id')
stus = Student.query.order_by(asc('s_id'))
stus = Student.query.order_by('s_id asc')

按照id降序获取三个

stus = Student.query.order_by('-s_id').limit(3)
stus = Student.query.order_by('s_id desc').limit(3)

from sqlalchemy import desc
stus = Student.query.order_by(desc('s_id')).limit(3)

获取年龄最大的一个

stus = Student.query.order_by('-s_age').first()

跳过3个数据，查询5个信息

stus = Student.query.order_by('-s_age').offset(3).limit(5)

跳过3个数据

stus = Student.query.order_by('-s_age').offset(3)

获取id等于24的学生

stus = Student.query.filter(Student.s_id==24)
stus = Student.query.get(24)

第一个参数是那一页，第二个参数是一页的条数，第三个参数是是否输出错误信息

students = Student.query.paginate(2, 4, False).items

1）手动实现分页，使用offset和limit

page=int(request.args.get('page',1))
stus = Students.query.offset((page-1)*3).limit(3)

2）使用切片[:]

page=int(request.args.get('page',1))
stus=Students.query.all()[(page-1)3:page3]

3）sql

page=int(request.args.get('page',1))
sql ='select * from students limit %s,%s'%((page-1)*3,3)
stus=db.session.execute(sql)

4）使用paginate

查询第几页的数据

page = int(request.args.get('page', 1))

每一页的条数多少，默认为10条

per_page = int(request.args.get('per_page', 10))

查询当前第几个的多少条数据

paginate = Student.query.order_by('-s_id').paginate(page, per_page, error_out=False)

stus = paginate.items

后端代码：

@uesrs_blue.route('/paginate/')
def paginate():
    # 获取分页的当前页
    page=int(request.args.get('page',1))
    # 1.offset+limit
    stus = Students.query.offset((page-1)*3).limit(3)
    # 2.切片
    stus=Students.query.all()[(page-1)*3:page*3]
    # 3.sql
    sql ='select * from students limit %s,%s'%((page-1)*3,3)
    stus=db.session.execute(sql)
    # 4.paginate()方法
    paginate=Students.query.paginate(page,3)
    stus=paginate.items
    return render_template('page_students.html', stus=stus,paginate=paginate)

前端代码：

{% extends 'base_main.html' %}
{% block title %}
    查询学生
{% endblock %}
{% block content %}

        {% for stu in stus %}
        
        {% endfor %}
    

    

        
序号
        
id
        
姓名
        
年龄
        
操作
    
    

            
{{loop.index0}}
            
{{stu.id}}
            
{{stu.s_name}}
            
{{stu.s_age}}
            
修改|删除
        


    当前{{paginate.page}}页，
    共有{{paginate.pages}}页


    
        {% if paginate.has_prev %}
        上一页
        {% else %}
        第一页
        {% endif %}
        {% for i in paginate.iter_pages() %}
        {{i}}
        {% endfor %}
        {% if paginate.has_next %}
        下一页
        {% else %}
        最后一页
        {% endif %}

    


{% endblock %}

2. 关联关系

2.1 一对多建立模型

学生模型：

class Student(db.Model):

    s_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    s_name = db.Column(db.String(20), unique=True)
    s_age = db.Column(db.Integer, default=18)
    s_g = db.Column(db.Integer, db.ForeignKey('grade.g_id'), nullable=True)

    __tablename__ = 'student'

班级模型：

class Grade(db.Model):

    g_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    g_name = db.Column(db.String(10), unique=True)
    g_desc = db.Column(db.String(100), nullable=True)
    g_time = db.Column(db.Date, default=datetime.now)
    students = db.relationship('Student', backref='stu', lazy=True)

    __tablename__ = 'grade'

官网解释有如下几个lazy的参数：

lazy 决定了 SQLAlchemy 什么时候从数据库中加载数据:，有如下四个值:

select/True: (which is the default) means that SQLAlchemy will load the data as necessary in one go using a standard select statement.

joined/False: tells SQLAlchemy to load the relationship in the same query as the parent using a JOIN statement.

subquery: works like ‘joined’ but instead SQLAlchemy will use a subquery.

dynamic: is special and useful if you have many items. Instead of loading the items SQLAlchemy will return another query object which you can further refine before loading the items. This is usually what you want if you expect more than a handful of items for this relationship

select就是访问到属性的时候，就会全部加载该属性的数据。

joined则是在对关联的两个表进行join操作，从而获取到所有相关的对象。

dynamic则不一样，在访问属性的时候，并没有在内存中加载数据，而是返回一个query对象, 需要执行相应方法才可以获取对象，

代码部署：

1.添加关系

@uesrs_blue.route('/create_ref/')
def create_ref():

    # 方法一：
    # 已知学生添加班级
    stus_ids=[8,9]
    for id in stus_ids:
        stu=Students.query.get(id)
        # 在flask中stu.s_g获取的值为int类型
        # 在Django中stu.s_g获取的值是对象，stu.s_g_id获取到的是int类型
        stu.s_g=7
        stu.save()

    # 方法二：
    # 已知班级添加学生
    # g=Grade.query.get(4)
    # stu=Students.query.filter(Students.id==5).first()
    # g.students.append(stu)
    # stu.save()
    return '添加成功'

2. 通过班级查询学生信息

    @grade.route('/selectstubygrade//')
   
    def select_stu_by_grade(id):
        grade = Grade.query.get(id)
       # 通过班级对象.定义的relationship变量去获取学生的信息
        stus = grade.students
   
        return render_template('grade_student.html',
                               stus=stus,
                               grade=grade
                               )
   
   

3. 通过学生信息查询班级信息

    @stu.route('/selectgradebystu//')
   
    def select_grade_by_stu(id):
   
        stu = Student.query.get(id)
       # 通过学生对象.定义的backref参数去获取班级的信息
        grade = stu.stu
   
        return render_template('student_grade.html',
                               grade=grade,
                               stu=stu)
   
   

注意：表的外键由db.ForeignKey指定，传入的参数是表的字段。db.relations它声明的属性不作为表字段，第一个参数是关联类的名字，backref是一个反向身份的代理,相当于在Student类中添加了stu的属性。例如，有Grade实例dept和Student实例stu。dept.students.count()将会返回学院学生人数;stu.stu.first()将会返回学生的学院信息的Grade类实例。一般来讲db.relationship()会放在一这一边。

2.2. 关联关系---多对多

定义模型：

引入SLALchemy

from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy()

创建中间表

sc = db.Table('sc',#表名
    db.Column('s_id', db.Integer, db.ForeignKey('student.s_id'), primary_key=True),
    db.Column('c_id', db.Integer, db.ForeignKey('courses.c_id'), primary_key=True)
)

创建学生类Student

class Student(db.Model):

    s_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    s_name = db.Column(db.String(20), unique=True)
    s_age = db.Column(db.Integer, default=18)
    s_g = db.Column(db.Integer, db.ForeignKey('grade.g_id'), nullable=True)

    __tablename__ = 'student'

    def __init__(self, name, age):

        self.s_name = name
        self.s_age = age
        self.s_g = None

创建课程表的模型，Course类

class Course(db.Model):

    c_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    c_name = db.Column(db.String(20), unique=True)
    students = db.relationship('Student',#指定关联表
                               #指定中间表
                               secondary=sc,
                               #反向解析
                               backref='cou')

    __tablename__ = 'courses'

    def __init__(self, name):

        self.c_name = name

sc表由db.Table声明，我们不需要关心这张表，因为这张表将会由SQLAlchemy接管，它唯一的作用是作为students表和courses表关联表，所以必须在db.relationship()中指出sencondary关联表参数。lazy是指查询时的惰性求值的方式，这里有详细的参数说明，而db.backref是声明反向身份代理，其中的lazy参数是指明反向查询的惰性求值方式.

2.2.1. 添加学生和课程之间的关系

通过页面中传递学生的id和课程的id，分别获取学生的对象和课程的对象，在使用关联关系append去添加学生对象，并且add以后再commit后，就可以在中间表sc中查看到新增的关联关系了。

    userid = request.form.get('userid')
    courseid = request.form.get('courseid')

    stu = Student.query.get(userid)
    cou = Course.query.get(courseid)

    cou.students.append(stu)
    db.session.add(cou)
    db.session.commit()

2.2.2. 删除学生和课程之间的关系

通过页面获取传递的学生的id和课程的id，分别获取学生对象和课程对象，在使用关联关系remove去删除学生对象，并commit将事务提交到数据库中

stu = Student.query.get(s_id)
cou = Course.query.get(c_id)

cou.students.remove(stu)
db.session.commit()

2.2.3. 通过课程查询学生的信息

以下定义在课程course的模型中，所以通过课程查询学生的信息，语法为课程的对象.studengs。如果知道学生的信息反过来找课程的信息，则使用backref的反向关联去查询，语语法为学生的对象.cou(反向)

students = db.relationship('Student',secondary=sc,backref='cou')

cou = Course.query.get(2)
stus = cou.students

2.2.4. 通过学生去查询课程的信息

stu = Student.query.get(id)
cous = stu.cou

3. 数据库迁移

在django中继承了makemigrations，可以通过migrate操作去更新数据库，修改我们定义的models，然后在将模型映射到数据库中。

在flask中也有migrate操作，它能跟踪模型的变化，并将变化映射到数据库中

3.1 安装migrate

pip install flask-migrate

3.2 配置使用migrate

3.2.1 初始化，使用app和db进行migrate对象的初始化

from flask_migrate import Migrate

#绑定app和数据库
Migrate(app=app, db=db)

3.2.2 安装了flask-script的话，可以在Manager()对象上添加迁移指令

from flask_migrate import Migrate, MigrateCommand

app = Flask(__name__)

manage = Manager(app=app)

manage.add_command('db', MigrateCommand)

操作：

python manage.py db init  初始化出migrations的文件，只调用一次

python manage.py db migrate  生成迁移文件

python manage.py db upgrade 执行迁移文件中的升级

python manage.py db downgrade 执行迁移文件中的降级

python manage.py db --help 帮助文档

代码区：

manage.py

from flask import Flask
from flask_debugtoolbar import DebugToolbarExtension
from flask_script import Manager
from flask_session import Session

from users.models import db
from users.views import uesrs_blue

app=Flask(__name__)
# 蓝图、设置前缀
app.register_blueprint(blueprint=uesrs_blue,url_prefix='/users')

# 设置秘钥
app.config['SECRET_KEY']='secret_key'

# 数据库设置
app.config['SQLALCHEMY_DATABASE_URI']='mysql+pymysql://root:[email protected]:3306/flask5'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS']=False

# 开启debug模式
app.debug=True

# 绑定数据库
db.init_app(app)

# 初始化debugtoolbar和app
toolbar=DebugToolbarExtension()
toolbar.init_app(app)

# manager
manager=Manager(app=app)

if __name__=='__main__':
    manager.run()

uers->views.py

from flask import Blueprint, render_template, request, redirect, url_for
from sqlalchemy import or_, not_

from users.models import Students, db, Grade, Course

uesrs_blue=Blueprint('users',__name__)


# @uesrs_blue.route('/register/',methods=['GET','POST'])
# def register():
#     if request.method=='GET':
#         return render_template('register.html')
#     if request.method=='POST':
#         pass
@uesrs_blue.route('/create_table/')
def create_table():
    # 用于初次创建模型
    db.create_all()
    return "创建成功"


@uesrs_blue.route('/drop_table/')
def drop_table():
    db.drop_all()
    return "删除成功"


@uesrs_blue.route('/add_students/',methods=['GET','POST'])
def add_students():
    if request.method=='GET':
        return render_template('students.html')
    if request.method=='POST':
        name=request.form.get('name')
        age=int(request.form.get('age'))
        # 单个创建
        stu=Students()
        stu.s_name=name
        stu.s_age=age
        stu.save()
        return '添加学生成功'


@uesrs_blue.route('/add_grade/',methods=['GET','POST'])
def add_grade():
    if request.method=='GET':
        return render_template('grade.html')
    if request.method=='POST':
        name=request.form.get('grade_name')
        # 单个创建
        g=Grade()
        g.g_name=name
        g.save()
        return '添加班级成功'


@uesrs_blue.route('/add_course/',methods=['GET','POST'])
def add_course():
    # 批量添加
    # courses=['java','python','css','javascript','数学']
    # c_list=[]
    # for course in courses:
    #     cou=Course()
    #     cou.c_name=course
    #     c_list.append(cou)
    #     # db.session.add(cou)
    #     # db.session.commit()
    # db.session.add_all(c_list)
    # db.session.commit()
    # return '添加课程成功'

    if request.method=='GET':
        return render_template('course.html')
    if request.method=='POST':
        name=request.form.get('course_name')
        # 单个创建
        cou=Course()
        cou.c_name=name
        cou.save()
        return '添加课程成功'



@uesrs_blue.route('/add_all_students/')
def add_all_students():
    # 批量创建 add_all()
    names=['小王','小图','小坑','小进','老金','小人','小建','小国','老刘']
    stu_list=[]
    for name in names:
        stu=Students()
        stu.s_name=name
        stu_list.append(stu)
    db.session.add_all(stu_list)
    db.session.commit()
    return '批量创建成功'


@uesrs_blue.route('/select_students/')
def select_students():
    # 方法一：
    stu=Students.query.filter(Students.s_name=='小王')
    stu=Students.query.filter(Students.s_name=='小建').first()

    # 方法二：
    stu=Students.query.filter_by(s_name='老刘')
    stu=Students.query.filter_by(s_name='老刘').first()

    # 方法三：
    stus=Students.query.all()

    # 方法四：
    sql='select * from students;'
    stu=db.session.execute(sql)

    # 模糊查询
    # select * from students where s_name like '%王%'
    # select * from students where s_name like '王%'
    # select * from students where s_name like '_王%'  第二位为王
    # select * from students where s_name like '%王'
    stu=Students.query.filter(Students.s_name.contains('小'))
    stu=Students.query.filter(Students.s_name.startswith('小'))
    stu=Students.query.filter(Students.s_name.endswith('王'))

    # 查询id在某个范围之内的学生信息
    # select * from students where id in (2,3,4,5,6)
    stu=Students.query.filter(Students.id.in_([2,3,4,5,6]))

    # 运算符查询
    # 查询年龄大于19的学生信息
    stu=Students.query.filter(Students.s_age>19)
    stu=Students.query.filter(Students.s_age.__gt__(19))

    # get方法，获取主键对应的行数据
    stu=Students.query.get(2)

    # offset+limit
    stu=Students.query.limit(3)
    stu=Students.query.offset(1).limit(3)

    # 排序order_by
    stu=Students.query.order_by('-id')

    # 查询姓名中包含王的，并且年龄等于23
    stu=Students.query.filter(Students.s_name.contains('王'),
                              Students.s_age==19)
    # 查询姓名中包含王的，或年龄等于23
    # Django中：filter(Q(A)|Q(B))
    # flask中：filter(or_(A,B))
    stu=Students.query.filter(or_(Students.s_name.like('%王%'),
                              Students.s_age==19))
    # 查询姓名中不包含王的，且年龄等于23
    stu = Students.query.filter(not_(Students.s_name.like('%王%')),
                                    Students.s_age == 19)



    return render_template('select_students.html',stus=stus)


@uesrs_blue.route('/delete_stu/')
def delete_stu(id):
    stu=Students.query.filter(Students.id==id).first()
    db.session.delete(stu)
    db.session.commit()
    return '删除成功'


@uesrs_blue.route('/update_stu/',methods=['GET','POST'])
def update_stu(id):
    if request.method=='GET':
        return render_template('update_stu.html')
    if request.method=='POST':
        name = request.form.get('name')
        age = int(request.form.get('age'))
        stu = Students.query.filter_by(id=id).first()
        if name:
            stu.s_name = name
        if age:
            stu.s_age = age
        stu.save()
        return redirect(url_for('users.select_students'))


@uesrs_blue.route('/paginate/')
def paginate():
    # 获取分页的当前页
    page=int(request.args.get('page',1))
    # 1.offset+limit
    stus = Students.query.offset((page-1)*3).limit(3)
    # 2.切片
    stus=Students.query.all()[(page-1)*3:page*3]
    # 3.sql
    sql ='select * from students limit %s,%s'%((page-1)*3,3)
    stus=db.session.execute(sql)
    # 4.paginate()方法
    paginate=Students.query.paginate(page,3)
    stus=paginate.items
    return render_template('page_students.html', stus=stus,paginate=paginate)


@uesrs_blue.route('/create_ref/')
def create_ref():

    # 方法一：
    # 已知学生添加班级
    stus_ids=[8,9]
    for id in stus_ids:
        stu=Students.query.get(id)
        # 在flask中stu.s_g获取的值为int类型
        # 在Django中stu.s_g获取的值是对象，stu.s_g_id获取到的是int类型
        stu.s_g=7
        stu.save()

    # 方法二：
    # 已知班级添加学生
    # g=Grade.query.get(4)
    # stu=Students.query.filter(Students.id==5).first()
    # g.students.append(stu)
    # stu.save()
    return '添加成功'


@uesrs_blue.route('/sel_sut_g/')
def sel_sut_g():
    # 通过学生查看班级
    stu=Students.query.filter(Students.s_name=='小建').first()
    # stu=Students.query.get(4)
    # g返回的是一个对象
    g=stu.grade
    return g.g_name


@uesrs_blue.route('/sel_g_sut/')
def sel_g_sut():
    # 通过班级查看学生
    g=Grade.query.get(6)
    # stu返回的是一个列表，列表里是多个对象
    # 一对多，通过主键找外键返回的是一个列表，通过外键找主键返回的是对象
    stu=g.students
    return stu[0].s_name


@uesrs_blue.route('/add_stu_cou/')
def add_stu_cou():
    # 方法一：
    # 通过学生对象查找课程信息，stu.cou
    # stu=Students.query.get(9)
    # course_id=[3,7]
    # for id in course_id:
    #     course=Course.query.get(id)
    #     stu.cou.append(course)
    # stu.save()
    # 方法二：
    # 通过课程对象添加学生信息，g.students
    # c=Course.query.get(1)

    # 单个添加
    # stu=Students.query.get(3)
    # c.students.append(stu)

    # 批量添加
    # stu_id=[4,6]
    # for id in stu_id:
    #     stu = Students.query.get(id)
    #     c.students.append(stu)

    # c.save()

    return '添加多对多关联关系成功'


@uesrs_blue.route('/sel_c_stu/')
def sel_c_stu():
    # 通过学生查询课程
    stu=Students.query.get(1)
    c=stu.cou
    return c[0].c_name


@uesrs_blue.route('/sel_stu_c/')
def sel_stu_c():
    # 通过课程查询学生
    c=Course.query.filter(Course.c_name == 'python').first()
    stu=c.students
    return stu[0].s_name

users->models

from flask_sqlalchemy import SQLAlchemy


db=SQLAlchemy()


class Students(db.Model):
    id=db.Column(db.Integer,primary_key=True,autoincrement=True)
    s_name=db.Column(db.String(10),unique=False,nullable=False)
    s_age=db.Column(db.Integer,default=19)
    s_g=db.Column(db.Integer,db.ForeignKey('grade.id'),nullable=True)

    __tablename__='students'

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


class Grade(db.Model):
    id=db.Column(db.Integer,primary_key=True,autoincrement=True)
    g_name=db.Column(db.String(30),unique=True,nullable=False)
    students=db.relationship('Students',backref='grade')

    # 可以不写，系统默认表名为grade
    __tablename__ = 'grade'

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


# django中一对多，主键在多,多对多，主键随意在那一方
# flask中一对多，主键在一,多对多，主键随意在那一方


s_c=db.Table('s_c',
             db.Column('s_id',db.Integer,db.ForeignKey('students.id'),primary_key=True),
             db.Column('c_id',db.Integer,db.ForeignKey('course.id'),primary_key=True)
             )

# 懒加载：lazy='dynamic'时，course.students[0]返回的结果不是对象，而是查询语句，
# 通过course.students[0].all() 加过滤条件才能得到对象，lazy=其他时，course.students[0]返回的是对象
class Course(db.Model):
    id=db.Column(db.Integer,primary_key=True,autoincrement=True)
    c_name=db.Column(db.String(10),unique=True,nullable=False)
    students=db.relationship('Students',
                             secondary=s_c,
                             backref='cou',
                             # lazy='dynamic'
                             lazy=True)

    __tablename__ = 'course'

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

templates->base.html

    
    

    {% block css %}
    {% endblock %}

    {% block js %}
    {% endblock %}


{% block content %}
{% endblock %}

templates->base_main.html

{% extends 'base.html' %}
{% block js %}
    
{% endblock %}

templates->students.html

{% extends 'base_main.html' %}
{% block title %}
    添加学生
{% endblock %}
{% block content %}

    姓名：

    年龄：

    

{% endblock %}

templates->select_students.html

{% extends 'base_main.html' %}
{% block title %}
    查询学生
{% endblock %}
{% block content %}

        {% for stu in stus %}
        
        {% endfor %}
    

    

        
序号
        
id
        
姓名
        
年龄
        
操作
    
    

            
{{loop.index0}}
            
{{stu.id}}
            
{{stu.s_name}}
            
{{stu.s_age}}
            
修改|删除
        

{% endblock %}

templates->update_students.html

{% extends 'base_main.html' %}
{% block title %}
    修改学生
{% endblock %}
{% block content %}

    姓名：

    年龄：

    

{% endblock %}

templates->page_students.html

{% extends 'base_main.html' %}
{% block title %}
    查询学生
{% endblock %}
{% block content %}

        {% for stu in stus %}
        
        {% endfor %}
    

    

        
序号
        
id
        
姓名
        
年龄
        
操作
    
    

            
{{loop.index0}}
            
{{stu.id}}
            
{{stu.s_name}}
            
{{stu.s_age}}
            
修改|删除

        


    当前{{paginate.page}}页，
    共有{{paginate.pages}}页


    
        {% if paginate.has_prev %}
        上一页
        {% else %}
        第一页
        {% endif %}
        {% for i in paginate.iter_pages() %}
        {{i}}
        {% endfor %}
        {% if paginate.has_next %}
        下一页
        {% else %}
        最后一页
        {% endif %}

    


{% endblock %}

templates->grade.html

{% extends 'base_main.html' %}
{% block title %}
    添加学生
{% endblock %}
{% block content %}

    班级名：

    

{% endblock %}

templates->course.html

{% extends 'base_main.html' %}
{% block title %}
    添加学生
{% endblock %}
{% block content %}

    课程名：

    

{% endblock %}