flask 中的ORM

1 响应（response）
    1 什么是响应
        响应就是由服务器端带给客户端的内容，对应着请求，响应可以是普通的字符串，模板 或重定向
        return '普通字符串'
        return render_template('xxx.html')
    2 响应对象
        响应对象：将响应的内容封装到一个对象中，可以完成更多的响应的行为（如：增加cookies,..）
        在Flask中，使用 make_response() 构建响应对象

　　　　　　request.cookies['uname']  　　#'获取cooki'
2 文件上传
    1 注意问题
        表单中如果有文件上传的话，必须遵循以下两个要求
        1 提交方式 method 必须为 post
        2 表单的 enctype 属性值必须为 multipart/form-data
    2 服务器端
        1 通过 request.files 获取文件上传
            f = request.files['文件框的name值']
        2 通过 f.save(保存路径) 将文件保存至指定目录处
            通过 f.filename 获取文件的名称
            f.save('/static')#文件路径
3 模型 - Models
    1 什么是模型
        模型，是根据数据库中表的结构而创建出来的class
        表中的每一个列对应到编程语言中就class中的一个属性
    2 模型的框架- orm
        1 数据表(table)到编程类(class)的映射
            数据库中的每一张表 对应到 编程语言中 都有一个类
            在ORM中：
                允许将数据表 自动生成一个类
                允许将类自动 生成一张数据表
        2 数据类型的映射
            将数据库表中的字段以及数据类型 对应到 编程语言中类的属性
            在ORM中：
                允许将表中的字段和数据类型自动映射到编程语言中
                也允许将类中的属性和数据类型也自动映射到表中
        3 关系映射
            将数据库中表与表之间的关系 对应 到编程语言中类与类之间的关系
            数据库中表与之间的关系
                1 一对一
                    外键，主键，唯一约束
                    A表中的一条数据只能与B表中的一条数据相关联
                2 一对多
                    外键，主键
                    一门课程可以被多个老师所教授

                    A表中的一条数据可以与B表中的任意多条数据相关联，反之，B表中的一条数据只能与A表中的一条数据相关联
                3 多对多
                    通过第三张关联表去关联两张表
                    A 表中的一条数据可以与B表中的任意多条数据相关联，B表中的一条数据也可以与A表中的任意多条数据相关联
    3 ORM优点
        1 封装了数据库中所有的操作，大大提高了开发效率
        2 可以省略庞大的数据访问层，即便不用SQL编码也能完成对数据的CRUD的操作
        3 Flas 中的ORm框架
            1 数据库和框架配置
                在python 和 Flask中，使用的ORM框架是 - SqlAlchemy
                在Flask 中想使用SqlAlchemy的话，需要进行安装
                    pip3 install sqlalchemy
                    pip3 install flask-sqlalchemy
            2 创建数据库
                flask
    from flask import Flask
    from flask_sqlalchemy import SQLAlchemy

    app = Flask(__name__)
    app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://用户名:密码@localhost:3306/数据库名'
    db = SQLAlchemy(app)

app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql+pymysql://root:liu@176.215.155.241:3306/flask?charset=utf8'
app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN']    = True  #指定执行完操作后自动提交
app.config["SECRET_KEY"]='zhelizuibianxie'

模型 ：
    1 定义模型
        模型：数据库中的表在编程语言中的体现，其本质就是一个python类（模型类 或实体类）
        class MODELMANE(db.Models)
            __tablename__= 'TABLENAME'
            COLUMN_NAME = db.Column(db.TYPE,OPTIONS)
        1 MODELMANE : 定义模型类的名称，根据表名设定
        2 TABLENAME : 映射到数据库中表的名称
        3 COLUMN_NAME: 属性名，映射到数据表就是列名
        4 TYPE : 映射到列的数据类型
        5 OPTIONS：列选项
            db.TYPE如下
             类型名            python类型            说明
             Integer        int                    普通整数，32位
             SamllInteger    int                    小范围整数，通常16位
             BigInteger        int或long            不限精度整数
             float            float                浮点数
             Numeric        decimal.Decimal        定点数
             String            str                    变长字符串
             Text            str                    变长字符串，优化
             Unicode            unicode                变长Unicode字符串
             UnicodeText        unicode                优化后的变长Unicode串2
             Date            datetime.date        日期
             Time            datetime.time        时间
             DateTime        datetime.datetime    日期和时间

            OPTIONS 列选项
            选项名                说明
            primary_key            如果设置为True表示该列为主键
            unique                如果设置为True表示该列值唯一
            index                如果设置为True表示该列要创建索引
            mullable            如果设置为True表示该列允许为空
            default                表示该列的默认值

        出错选项【no modul name mysql_db】
            解决1 ：
                import pymysql
                pymysql.install_as_MySQLdb()
            解决2：
                在连接路径上
                'mysql+pymysql://root:liu@176.215.155.241:3306/flask?charset=utf8'  # 在mysql后面 添加【'+pymysql'】

        1 数据库操作 - 插入
            1 创建实体对象
            2 完成插入
                db.session.add(实体对象)
                db.session.commit()
        2 数据库操作--查询
            1 基于db.session进行查询
                1 db.session.query()
                    该函数会返回一个query对象，类型为BaseQuery
                    该对象中包含了实体类对应的表中的所有的数据
                    该函数可以接收一个或多个参数，参数们表示的是查询的实体对象是谁
                2 查询执行函数
                    目的：在query()的基础上得到最终想要的结果
                    语法：db.session.query(),查询执行函数()
                    函数            说明
                    all()            以列表的方式返回query()中所有查询的结果
                    first()            返回查询结果中的第一个结果，如果没有结果，则返回None
                    first_or_404()    返回查询结果中的第一个结果，如果没有结果，则终止并返回404

                3 查询过滤器函数
                    作用：在查询的基础上，筛选部分行数据
                    语法：db.session.query().过滤器函数().查询执行函数（）
                    过滤器函数            说明
                    filter()            按指定条件进行过滤（多表，单表，定位）
                    filter_by()            按等值条件过滤时使用
                    limit()                按限制行数获取
                    order_by()            根据指定条件进行排序
                    group_by()            根据指定条件进行分组
                    过滤器函数详解
                    1 filter()
                        注意：条件必须由 模型类，属性 构成
                        1 查询年龄大于30的User的信息
                            db.session.query(User).filter(User.age>30)
                        2 查询年龄大于30并且ID大于1的User的信息
                            db.session.query(User).filter(User.age>30,User.id>1)
                        3 查询年龄大于30或者id 大于1的Users的信息
                            注意：查询或的操作，要借助于 or_
                            db.session.query(Users).filter(or_(Users.age>30,Users.id>2))
                        4 查询ID等于2 的信息的必须用 ==
                        5 查询email 中包含‘w’的Users的信息，模糊查询
                            注意：模糊查询like需要使用实体类中属性提供的like()
                            db.session.query(Users).filter(Users.email.like('%w'))
                        6 查询尖id在[32,33]的值
                            需要使用实体类中属性提供的in_([])
                            db.session.query(Users).filter(Users.age.in_([32,33]))
                    2 聚合函数
                        db.session.query(func.聚合函数('列名').label('别名'))
                        聚合函数：
                            sum()
                            count()
                            max()
                            min()
                            avg()
                    3 filter_by()
                        查询 id =5 的 Users的信息
                        db.session.query(Users).filter_by(id=5).all()
                    4 limit()
                        db.session.query(Users).limit(2)
                        db.session.query(Users).limit(2).offset(1)
                    5 order_by()
                        #按照id 列的值降序排列
                        db.session.query(Users).order_by('id desc')
                        # 按照age列 的值降序排序，二级排序按照id升序排序
                        db.session.query(Users).order_by('id desc,id asc').all()

            2 基于Models 类进行查询
                Models.query.查询过滤器函数（条件参数），查询执行函数（）
            3 删除
                1 查询出要删除的实体对象
                    db.session.query(Models).filter_by(xxx).first()
                2  根据提供的 删除方法进行删除
                    db.session.delete(u)
                    注意：
                        真正的删除并不是通过删除操作完成，而是通过修改完成的
            4 修改
                1 查
                    将 要修改的信息查询出来
                2 改
                    实体对象。属性 = 值
                3 保存
                    db.session.add(实体对象)
        2 关系映射
            1 一对多
                语法：db
                 1 在：“多”的实体中
                    增加一个列，引用自’一‘表的主键列，外键列名 = db.Column()
                     外键列名 = db.Column(db.Integer,db.ForeignKey('主键表.列'))
                2 在‘一’的实体中
                    增加关联属性以及反向引用关系
                    et:
                        关联属性：
                            在course对象中，通过一个属性能够得到对应的所有的teacher们
                            关联属性，是应该加载Course的实体类中
                        反向引用：
                            在 student对象中，通过一个属性能够得到对应的course
                            反向引用关系属性，是应该加在 Teacher 的实体类中
                    增加关联属性和反向引用关系：
                    属性名= db.relationship('多表实体类名',关系选项)
                    关系选项
                    选项名                说明
                    backref                在关系的另一个模型中添加的反向引用属性名
                       （准备在“多”的实体中增加对“一”的实体引用的属性名）
                    lazy                指定如何加载当前的相关记录
                        ...                select:首次访问时加载记录
                                        immediate:源对象加载后马上加载相关数据
                                        subquery:效果同上，利用子查询方式加载记录  （数据量大的时候，这个子查询效果更好）
                                        noload: 永不加载记录
                                        dynamic:默认不加载记录，但会提供加载记录的查询
                    uselist                如果设置为 Flase ,表示不使用列表表示关联数据，而使用标量
                    secondary            指定多对多关系映射中的关联表的名字

from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
db = SQLAlchemy(app)
app.config['SQLALCHEMY_DATABASE_URI']= 'mysql+pymysql://root:liu@176.215.155.241:3306/flask'
app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN'] = True

class Course(db.Model):
    __tablename__='course'
    id = db.Column(db.Integer,primary_key=True)
    cname = db.Column(db.String(30),nullable=True)
    #增加关联属性和反向引用关系
    # 关联属性在course对象中通过哪个属性能够得到对应的所有的teacher
    #反向引用关系：在teacher对象中通过哪个属性能找到它对应的course
    teachers = db.relationship('Teacher',backref ='course',lazy ='dynamic')

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

    def __repr__(self):
        return '<Coure:%r>'%self.cname

class Teacher(db.Model):
    __tablename__='teacher'
    id = db.Column(db.Integer,primary_key=True)
    tname = db.Column(db.String(30),nullable=True)
    tage = db.Column(db.Integer)
    course_id = db.Column(db.Integer,db.ForeignKey('course.id'))
    def __repr__(self):
        return '<Teacher %r>'%self.name

db.create_all()

@app.route('/')
def hello_world():
    return 'Hello World!'

@app.route('/01-addcourse')
def add_course():
    course1 = Course('python基础')
    course2 = Course('python高级')
    course3 = Course('数据基础')
    db.session.add(course1)
    db.session.add(course2)
    db.session.add(course3)
    return '1'

@app.route('/02-register')
def register_teacher():
    teacher = Teacher()
    teacher.tname='吕老师'
    teacher.tage = 28
    course = Course.query.filter_by(id=3).first()
    # teacher.course = course #通过关联属性course对象赋值
    teacher.course_id = 1
    db.session.add(teacher)
    return '1'

@app.route('/03-query-teacher')
def query_teacher():
    # 通过 course 查找对应的所有的老师们
    # 查找course_id 为1的course对象
    # course = Course.query.filter_by(id=1).first()
    # print(course.cname)
    # for tea in course.teachers.all():
    #     print(tea.tname)

    #通过teacher 查找对应的course
    teacher = Teacher.query.filter_by(id=1).first()
    print('老师姓名',teacher.tname)
    course = teacher.course
    print(course.cname)

    pass

if __name__ == '__main__':
    app.run(debug=True)

--反向映射并查询

　　　　　　　　2 一对一
　　　　　　　　　　1 什么是一对一
　　　　　　　　　　　　A表中的一条记录只能与B表中的一条记录相关联
　　　　　　　　　　　　B表中的一条记录只能与A表中的一条记录相关联
　　　　　　　　　　2 在SQLALchemy 中的体现
　　　　　　　　　　　　1 在任意一个类中增加
　　　　　　　　　　　　　　外键列名 = db.Column(db.Integer,db.ForeignKey('主键表.主键列'))
　　　　　　　　　　　　2 在另外一个类中增加
　　　　　　　　　　　　　　关联属性和 反向引用关系属性
　　　　　　　　　　　　　　属性 = db.relationship('关联的实体类',backref='反向引用属性名'，uselist=False)

    数据库中的一行：实体
    实体完整性：表中的实体不能完全重复-主键