1.单表数据查询操作

1.1 all(), first(), get()的使用

# all():用户查询所有数据
User.query.all()

# first(): 用户查询第一条数据
User.query.first() 

# get(): 需要传递, 查询主键与参数相同的数据
User.query.get(1)

1.2filter(), filter_by实现过滤操作

条件查询提供了filter()与filter_by来实现, filter_by可以看做是filter的简写方式.
# 1.实现如下:
    # (1).filter()实现的条件查询
    User.query.filter(User.username=‘name‘).first()
    # (2).filter_by()实现的条件查询
    User.query.filter_by(username="name").first)

1.3 分页与排序

# 1.限制查询(分页)
User.query.filter(age=18).offset(2).limit(3)  # 跳过二条开始查询，限制输出3条
注意: offset与limit先后顺序调换, 不影响插叙结果

# 2.排序
    # (1).按照年龄升序排序, 默认升序, 可以省略".asc()"
    User.query.order_by(User.age.asc()).all()
    # (2).按照年龄降序排序
	User.query.order_by(User.age.desc).all() 

1.4 逻辑运算与聚合

# 1.逻辑运算
from sqlalchemy import or_, and_, not_
# (1).or_: 或, 查询名字为jeremy或年龄为19的
User.query.filter(or_(User.username ==‘jeremy‘,User.age==18)).all()
# (2).and_: 与, 查询名字为j2或年龄为19
User.query.filter(and_(User.name=="j2", User.age==19)).all()
# (3).not_: 非, 查询年龄不是18岁的
User.query.filter(not_(User.age==18)).all()

# 2.比较查询
User.query.filter(User.id.__lt__(5)) # 小于5
User.query.filter(User.id.__le__(5)) # 小于等于5
User.query.filter(User.id.__gt__(5)) # 大于5
User.query.filter(User.id.__ge__(5)) # 大于等于5

# 3.in查询
User.query.filter(User.username.in_(‘A‘,‘B‘,‘C‘,‘D‘))

# 4.聚合查询
from sqlalchemy import func
class Index(Resource):
    def get(self):
        ret1 = db.session.query(func.count(Stu.age)).all()
        ret2 = db.session.query(func.sum(Stu.age)).all()
        ret3 = db.session.query(func.avg(Stu.age)).all()
        print(‘统计数量: ‘, ret1[0][0])
        print(‘年龄总和:‘, ret2[0][0])
        print(‘年龄平均值:‘, ret3[0][0])
        return json.dumps({‘msg‘: ‘ok‘})

2.关系查询与优化查询

2.1 一对多关系

# 1.一对多关系的建立: 一方建立关系, 多方建立外键
from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy()

# 专业模型
class Sub(db.Model):
    __tablename__ = ‘sub‘
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(32))
    stu = db.relationship(‘Stu‘, backref=‘stu‘)  # 一方定义关系, 关联Stu模型, Stu为类名, 不是表名哦; backref的值是给"多方"用来查询"一方"的

    def __repr__(self):
        return self.name

# 学生模型
class Stu(db.Model):
    __tablename__ = ‘stu‘
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(32))
    age = db.Column(db.Integer)
    snum = db.Column(db.Integer, unique=True)
    sub_id = db.Column(db.Integer, db.ForeignKey(‘sub.id‘))
    # 多方定义外键, 关联sub.id

    def __repr__(self):
        return self.name

# 2.一对多关系的查询:
从一查多:
    sub = Sub.query.get(1)
    stus = sub.stu
    
从多差一:
    stu = Stu.query.get(2)
    sub = stu.sub  # stu.sub中的sub为backref的值

2.2 多对多关系

# 多对多关系的建立
	1. 先把两个需要做多对多的模型定义出来
	2. 使用Table定义一个中间表，中间表一般就是包含两个模型的外键字段就可以了，并且让他们两个来作为一个“复合主键”。
	3. 在两个需要做多对多的模型中随便选择一个模型，定义一个relationship属性，来绑定三者之间的关系，在使用relationship的时候，需要传入一个secondary=中间表模型名。 
    
# 以博客文章与标签为例, 示例如下:
# 中间表
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):
    __tablename__ = ‘article‘
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(64))
    tags = db.relationship(‘Tag‘, secondary=article_tag, backref=db.backref(‘articles‘))

    def __repr__(self):
        return self.title

# 标签表
class Tag(db.Model):
    __tablename__ = ‘tag‘
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(32))

    def __repr__(self):
        return self.name

# 多对多关系的查询
# 1.查询文章所有的标签:
article = Article.query.filter(Article.title="xxx").first()
tags = article.tags

# 2.查询一个标签涉及的所有文章:
tag = Tag.query.get(2)
print(‘标签: ‘, tag)
articles = tag.articles  # tag.articles中的articles是Article表中关系中backref的值
print(‘文章: ‘, articles)

3.Flask-SQLAlchemy执行自定义SQL语句

# 定义SQL语句
sql = ‘select name from stu where id=3‘
# 指定SQL语句
db.session.excute(sql)

SQLAlchemy进阶 （Flask的单表和多表）