Day6 --- SQLAlchemy进阶

单表数据查询操作

在model.py文件中创建模型类

from flask_sqlalchemy import SQLAlchemy  #导入

db=SQLAlchemy()  #实例化数据库连接对象

#创建模型类
class UserModel(db.Model):
    # primary_key主键   autoincrement自增  default默认
    id=db.Column(db.Integer,primary_key=True,autoincrement=True,comment='ID')
    name=db.Column(db.String(32),default='',comment='名字')
    age=db.Column(db.Integer,default=0,comment='年龄')
    balance=db.Column(db.DECIMAL(10,2),comment='资产') # DECIMAL浮点型
1
2
3
4
5
6
7
8
9
10
11

迁移数据

初始化迁移文件
python manage.py db init
生成迁移文件
python manage.py db migrate
执行迁移
python manage.py db upgrade
迁移完成
1
2
3
4
5
6
7

在蓝图中实现对模型类的数据添加及单表查询

from flask import Blueprint  #导入蓝图
from flask_restful import Api,Resource,fields,marshal
from models.model import UserModel, db
# # url_prefix  # 指定当前蓝图下所有路由的前缀
user_dp=Blueprint('user_dp',__name__,url_prefix='/users') #实例化蓝图对象
api=Api(user_dp)  #实例化蓝图收集器#实例化一个Api对象 Api对象的作用是用来搜集路由的
#定义类视图 继承自Resource类，通过Api的实例化对象进行搜集
class UserView(Resource):
    def get(self):       #测试是否成功
    #添加数据
        u1=UserModel(
            name='思聪',age=12,balance=100,
        )
        u2=UserModel(
            name='小马',age=17,balance=100,
        )
        u3=UserModel(
            name='老马',age=19,balance=1030,
        )
        db.session.add_all([u1,u2,u3])
        db.session.commit()
        return 'ssss'

#添加路由
api.add_resource(UserView,'/user') #完整地址是 /users/user
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

filter(), filter_by实现过滤查询操作

class UserView(Resource):
    def get(self):       #测试是否成功
    	#lst=UserModel.query.all()  #查询全部
        #filter(), filter_by实现过滤操作  两个方法效果一样
        #lst=UserModel.query.filter(UserModel.name=='老马').first() #filter()实现过滤操作
        lst=UserModel.query.filter_by(name='老马').first()  #filter_by实现过滤操作
        print(lst)
1
2
3
4
5
6
7

分页与排序

class UserView(Resource):
    def get(self):       #测试是否成功
    	#分页 排序 数据
        # 第一页 0,2   #页数-1 * 每页条数
        # 第二页 2,2
        # 第三页 4,2
        # page=2
        # page_size=2
        ## 跳过二条开始查询，限制输出2条
        # UserModel.query.offset(offset).limit(page_size).all()
        ## 排序
        ## (1).按照年龄升序排序, 默认升序, 可以省略".asc()"
        # UserModel.query.order_by(UserModel.age.asc()).all()
        # (2).按照年龄降序排序
        UserModel.query.order_by(UserModel.age.desc()).all()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

逻辑运算

class UserView(Resource):
    def get(self):       #测试是否成功
    	from sqlalchemy import or_,and_,not_ #导包
        ##逻辑运算
        lst=UserModel.query.filter(or_(UserModel.name=='老马',UserModel.name=='小马')).all() #或
        lst=UserModel.query.filter(and_(UserModel.name=='老马',UserModel.age==19)).all()   #与
        lst=UserModel.query.filter(not_(UserModel.name=='老马')).all()     #非
        print(lst)
1
2
3
4
5
6
7
8

比较查询

class UserView(Resource):
    def get(self):       #测试是否成功
    	## 比较查询
        lst=UserModel.query.filter(UserModel.age.__lt__(18)).all() #小于
        lst=UserModel.query.filter(UserModel.age.__le__(18)).all() #小于等于
        lst=UserModel.query.filter(UserModel.age.__gt__(18)).all() #大于
        lst=UserModel.query.filter(UserModel.age.__ge__(18)).all() #大于等于
        print(lst)
1
2
3
4
5
6
7
8

in查询TODO in 操作

class UserView(Resource):
    def get(self):       #测试是否成功
    	# in查询TODO in 操作
        lst=UserModel.query.filter(UserModel.name.in_(('小马',))).all() #必须是元祖或者列表形式
        return marshal(lst,{
            'id':fields.Integer,
            'name':fields.String,
            'age':fields.Integer,
            'balance':fields.Float
        })
1
2
3
4
5
6
7
8
9
10

#聚合查询

class UserView(Resource):
    def get(self):       #测试是否成功
    	from sqlalchemy import func  #导包
        #聚合查询
        lst=db.session.query(func.count(UserModel.id)).first()[0] #统计数据行数
        lst=db.session.query(func.sum(UserModel.age)).first()[0] #统计数据总和
        lst=db.session.query(func.avg(UserModel.age)).first()[0] #统计数据请均值
        print(lst)
1
2
3
4
5
6
7
8

关系查询 一对多关系

一对多关系的建立: 一方建立关系, 多方建立外键
创建两个表 主表绑定副表
在model.py文件中创建模型类
创建完成后进行迁移

from flask_sqlalchemy import SQLAlchemy  #导入

db=SQLAlchemy()  #实例化数据库连接对象
# 专业模型   一对多模型创建
class Sub(db.Model):
    id=db.Column(db.Integer,primary_key=True,autoincrement=True,comment='专业ID')
    name=db.Column(db.String(32),comment='专业名称')
    stu=db.relationship('Stu',backref='sub')  #声明与那个模型建立关系，不会在数据库产生实质操作

# 学生模型
class Stu(db.Model):
    id=db.Column(db.Integer,primary_key=True,autoincrement=True,comment='学生ID')
    name=db.Column(db.String(32),comment='学生名称')
    age=db.Column(db.Integer,comment='学生年龄')
    sub_id=db.Column(db.Integer,db.ForeignKey('sub.id')) #声明一个字段，且字段为外键，外键与那个表关联
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

蓝图实现添加跟查询数据

from flask import Blueprint  #导入蓝图
from flask_restful import Api,Resource,fields,marshal
from models.model import UserModel, db, Sub, Stu

# # url_prefix  # 指定当前蓝图下所有路由的前缀
user_dp=Blueprint('user_dp',__name__,url_prefix='/users') #实例化蓝图对象

api=Api(user_dp)  #实例化蓝图收集器#实例化一个Api对象 Api对象的作用是用来搜集路由的

#定义类视图 继承自Resource类，通过Api的实例化对象进行搜集
class UserView(Resource):
    def get(self):       #测试是否成功
    	s1=Sub(name='人工智能')
        s2=Sub(name='切图的')
        s3=Sub(name='复制的')
        stu1=Stu(name='哈哈',age=18,sub=s1)
        stu2=Stu(name='嘿嘿',age=12,sub=s2)
        stu3=Stu(name='霍霍',age=16,sub=s3)
        db.session.add_all([s1,s2,s3])
        db.session.add_all([stu1,stu2,stu3])
        db.session.commit()
        return 'sd'
#添加路由
api.add_resource(UserView,'/user') #完整地址是 /users/user
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

.一对多关系的查询
正向查询&反向查询

class UserView(Resource):
    def get(self):       #测试是否成功
    	# 正向查询 一方查询多方信息
        sub_info=Sub.query.filter(Sub.name=='人工智能').first()
        print(sub_info.id)
        for i in sub_info.stu:     # 遍历出绑定的数据   
            print(i.name,i.age)

        # 反向查询 从多方查询出一方信息
        stu_info=Stu.query.filter(Stu.name=='哈哈').first()
        print(stu_info.name,stu_info.age,stu_info.sub_id)  #显示出查询到的各个数据
        print(stu_info.sub.name) #打印出绑定外键的名称
1
2
3
4
5
6
7
8
9
10
11
12

关系查询 多对多关系

多对多关系的建立

1. 先把两个需要做多对多的模型定义出来
2. 使用Table定义一个中间表，中间表一般就是包含两个模型的外键字段就可以了，并且让他们两个来作为一个“复合主键”。
3. 在两个需要做多对多的模型中随便选择一个模型，定义一个relationship属性，来绑定三者之间的关系，在使用relationship的时候，需要传入一个secondary=中间表模型名。 
1
2
3

在model.py文件里创建模型类
创建完成后进行迁移

#创建中间表
article_tag=db.Table(
    'article_tag',
    db.Column('article_id',db.Integer,db.ForeignKey('article.id'),primary_key=True),
    db.Column('tag_id',db.Integer,db.ForeignKey('tag.id'),primary_key=True)
)

#文章表    多对多关系
class Article(db.Model):
    id=db.Column(db.Integer,primary_key=True,autoincrement=True,comment='Id')
    title = db.Column(db.String(32), comment='文章名')
    #指明两个表
    tags=db.relationship('Tag',secondary=article_tag,backref='articles')
#标签表
class Tag(db.Model):
    id=db.Column(db.Integer,primary_key=True,autoincrement=True,comment='Id')
    name = db.Column(db.String(32), comment='标签名')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

蓝图实现数据的添加跟查询
多对多添加数据

from flask import Blueprint  #导入蓝图
from flask_restful import Api,Resource,fields,marshal
from models.model import UserModel, db, Sub, Stu, Article, Tag

# # url_prefix  # 指定当前蓝图下所有路由的前缀
user_dp=Blueprint('user_dp',__name__,url_prefix='/users') #实例化蓝图对象

api=Api(user_dp)  #实例化蓝图收集器#实例化一个Api对象 Api对象的作用是用来搜集路由的

#定义类视图 继承自Resource类，通过Api的实例化对象进行搜集
class UserView(Resource):
    def get(self):       #测试是否成功
    	## 多对多数据添加
        t1=Tag(name='python')   #先添加外键数据 再添加绑定数据
        t2=Tag(name='java')

        # db.session.commit()  #添加完之后把这注释了 然后在运行下边的
        # return ''

        a1=Article(title='人工',tags=[t1])
        a2=Article(title='数据',tags=[t2])
        a3=Article(title='全栈',tags=[t1,t2])
		# db.session.add_all([t1,t2])
        db.session.add_all([a1,a2,a3])
        db.session.commit()
#添加路由
api.add_resource(UserView,'/user') #完整地址是 /users/user
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

多对多关系的查询

class UserView(Resource):
    def get(self):       #测试是否成功
    	#多对多查询 查询一个标签涉及的所有文章
        tag_info=Tag.query.filter(Tag.name=='python').first()
        print(tag_info.name)
        print(tag_info.articles)
        for i in tag_info.articles:
            print(i.title)  #就可以查询出绑定的外键名字
		# 查询文章所有的标签
        article_info=Article.query.filter(Article.id==2).first()
        print(article_info.title)
        print(article_info.tags)   # 查看绑定自身的文章表的数据
        for i in article_info.tags:
            print(i.name)   #查询对方的数据
1
2
3
4
5
6
7
8
9
10
11
12
13
14