Flask框架(SQLAlchemy(python3版本)中查询数据的方法，以及定义显示信息 )_flask_sqlalchemy query.all()

(SQLAlchemy中添加数据 )https://blog.csdn.net/wei18791957243/article/details/85256848 

    添加数据，添加好的表

     

SQlalchemy数据库查询

1. 查询数据

     (1) 查询表中的所有数据：    模型类.query.all()    # 返回每个数据的对象的列表

           例如：   li = Role.query.all()    # 保存的是数据的对象，列表形式      Role 是一个模型类

                          li[0]   #   取第一个数据对象

                        li[0].name   # 就取出了第一个数据对象的name属性，即在数据库中的列名为name的第一个值

    （2）查询第一条数据：

               r = Role.query.first()     #   查询到第一个条数据的对象

               r.name                 #  然后取出相应的值

              还有一种方法：  按照主键的值来进行查询一条数据

              r = Role.query.get(2)           #    2  即查询出主键为2  的那条数据的对象

              r.name     #  然后取出相应的值

    （3）  利用db.session 的方式查询       

          查询多条

               db.session.query(模型类).all()         # 返回的是一个数据对象列表   、

         查询第一条

               db.session.query(模型类).first()         # 返回的是第一个数据对象

         查询其中的一条

            db.session.query(模型类).get(主键的值)         # 返回的是一个数据对象

    2.   查询数据的时候进行过滤

       (1)  模型类.query_filter_by(name="wang").all   # 查询出name为wang的数据对象，返回的是一个列表，然后可以根                    据属性来获取相应的值                 也可以.first()  

               如果还有其他的条件，直接以逗号分隔在filter_by()里面添加就行

              如果查询的数据不存在返回None

     （2） 模型类.query_filter(模型类.name=="wang").all    #   需要指名  模型类.属性    ，并且是双等号

     （3）   查询时使用    “或”  以及模糊查询endswith()

                   导入模块  ：  from sqlalchemy import or_

                 #   如下：   查询出 User模型类中的name属性等于“wang”或者email属性是以163.com结尾的数据对象

                 User.query.filter(or_(User.name=="wang",User.email.endswith("163.com"))).all()      #  返回列表

      （4）offset()   # 偏移：从第几条开始查询，  limit  ()  #   表示取几条

         User.query.offset(2).limit(2).all     #   查询，从表中第二条数据开始查询，查询出的结果取两个，返回数据对象列表

       可以一起用，也可分开来用

     （5） flask中的排序查询

      默认是升序(asc()可以不用写：      User.query.order_by(User.id).all()     #  User 是模型类，通过User中的id进行排序

       降序：  desc()   

           User.query.order_by(User.id.desc()).all()       #  直接在要按什么排序的后面,desc()  的方式，进行降序排序

      （6）  查询时，group_by 的使用

               如果要 用到聚合函数   则要导入     

               from sqlalchemy import func

             #   分组统计出  User模型类中 表中的 role_id的每个数据的次数

              db.session.query(User.role_id,func.count(User.role_id)).group_by(User.role_id).all()    # 返回查询的结果列                表不是数据的对象了

      (7)  关联查询

            在模型类里面添加了relationship(), 关联了另外一模型类，

           在Role的模型类中，创建了属性  users = db.relationship("User",backref="role") ,关联了另外一个User的模型类

                  （ 1）从Role往User里面查询

                              ro = Role.query.get(1)  # 获取到了，Role中的一 个数据对象

                             直接 ro.user  就可以把Role表中的相对应在User中数据对象取出来

                   （2 ） 从User往Role里面查询

                              user = User.query.get(1)

                              直接在user.role就可以查询到Role表中相对应的数据对象

       （8）定义显示信息

               在模型类中，重写   __repr__   方法，  

    def __repr__(self):
        """定义之后，可以让显示对象的时候更直观"""
        return "User object : name=%s" % self.name

 

 db_demp.py

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
 
app = Flask(__name__)
 
 
class Config(object):
    """配置参数"""
    '''sqlalchemy的配置参数'''
    SQLALCHEMY_DATABASE_URI = "mysql+mysqlconnector://root:123456@127.0.0.1:3306/db_python"
    '''设置sqlalchemy自动跟踪数据库'''
    SQLALCHEMY_TRACK_MODIFICATIONS = True
 
 
# 设置参数
app.config.from_object(Config)
 
'''创建数据库 sqlalchemy 工具对象'''
db = SQLAlchemy(app)
 
"""
    创建数据库模型类(继承 sqlalchemy 工具对象中的Model类),一个模型类对应一张模型表
    数据库表名的常见规范：
        (1) 数据库名缩写_表名   (2) tbl_表名
"""
 
 
class Role(db.Model):
    """用户身份表"""
    __tablename__ = "tbl_roles"
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(32), unique=True)
    '''
        relationship() :第一个参数表明这个关系的另一端是哪个模型（类）
           把两个表关联在一起，不添加也是可以的，根据自己的需求
        backref : 在关系的另一模型中添加反向引用
                   相当于给要关联的表添加一个role属性
                   不添加也是可以的，根据自己的需求 
    '''
    user = db.relationship("User", backref="rpp")  # 从模型类中
 
    def __repr__(self):
        """定义之后，可以让显示对象的时候更直观"""
        return "Role object : name=%s" % self.name
 
 
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(128), unique=True)
    password = db.Column(db.String(128))
    # db.ForeignKey  外键关联
    # User类中添加了一个role_id变量，数据类型db.Integer,第二个参数指定外键是哪个表中哪个id。
    role_id = db.Column(db.Integer, db.ForeignKey("tbl_roles.id"))  # 从底层中
 
    def __repr__(self):
        """定义之后，可以让显示对象的时候更直观"""
        return "User object : name=%s" % self.name
 
 
if __name__ == '__main__':
    '''清除数据库中的所有数据'''
    db.drop_all()
    '''创建所有表'''
    db.create_all()
 
    # 给用户身份表中添加两个数据
    '''创建一个对象'''
    role1 = Role(name="admin")
    '''在Flask-SQLAlchemy中，插入、修改、删除操作，均由数据库会话管理。会话用db.session表示'''
    '''session 记录对象任务 '''
    db.session.add(role1)
    '''提交任务到数据库中'''
    db.session.commit()
 
    role2 = Role(name="stuff")
    db.session.add(role2)
    db.session.commit()
 
    # 给用户表中添加数据
    us1 = User(name='wang', email='wang@163.com', password='123456', role_id=role1.id)
    us2 = User(name='zhang', email='zhang@189.com', password='452342', role_id=role2.id)
    us3 = User(name='chen', email='chen@126.com', password='782677', role_id=role2.id)
    us4 = User(name='zhou', email='zhou@163.com', password='858585', role_id=role1.id)
    '''一次性添加多条数据'''
    db.session.add_all([us1, us2, us3, us4])
    db.session.commit()

 然后在ipython中导入py文件

"""导入相关的py文件"""
In [1]: from db_demo import *
 
In [2]: Role.query.all()
Out[2]: [<Role 1>, <Role 2>]
 
In [3]: li = Role.query.all()
 
In [4]: li
Out[4]: [<Role 1>, <Role 2>]
 
In [5]: r = li[0]
 
In [6]: type(r)
Out[6]: db_demo.Role
 
In [7]: r.name
Out[7]: 'admin'
 
In [8]: Role.query.first()
Out[8]: <Role 1>
 
In [9]: r.name
Out[9]: 'admin'
"""#  根据主键id获取对象"""
In [10]: r = Role.query.get(2)
 
In [11]: r
Out[11]: <Role 2>
 
In [12]: r.name
Out[12]: 'stuff'
 
"""另一种查询方式"""
In [13]: db.session.query(Role).all()
Out[13]: [<Role 1>, <Role 2>]
 
In [14]: db.session.query(Role).get(2)
Out[14]: <Role 2>
 
In [15]: db.session.query(Role).first()
Out[15]: <Role 1>
 
In [16]: User.query.filter_by(name="wang")
Out[16]: <flask_sqlalchemy.BaseQuery at 0x276d8975eb8>
 
In [18]: User.query.filter_by(name="wang").all()
Out[18]: [<User 1>]
 
In [19]: User.query.filter_by(name="wang").first()
Out[19]: <User 1>
 
In [20]: user = User.query.filter_by(name="wang").first()
 
In [21]: user.name
Out[21]: 'wang'
 
In [22]: user.email
Out[22]: 'wang@163.com'
 
In [23]: User.query.filter_by(name="wang", role_id=1).first()
Out[23]: <User 1>
 
In [24]: User.query.filter_by(name="wang", role_id=2).first()
"""没有该数据时，返回的是空"""
In [25]: user = User.query.filter_by(name="wang", role_id=2).first()
 
In [26]: type(user)
Out[26]: NoneType
 
In [27]: user = User.query.filter(User.name=="wang", User.role_id==1).first()
 
In [28]: user
Out[28]: <User 1>
 
In [29]: user.name
Out[29]: 'wang'
 
"""模糊查询"""
In [30]: from sqlalchemy import or_
 
In [31]: User.query.filter(or_(User.name=="wang", User.email.endswith("163.com"))).all()
Out[31]: [<User 1>, <User 4>]
 
In [32]: li = User.query.filter(or_(User.name=="wang", User.email.endswith("163.com"))).all()
 
In [33]: li[0].name
Out[33]: 'wang'
 
In [34]: li[1].name
Out[34]: 'zhou'
"""offset偏移 即跳过几条"""
In [35]: User.query.offset(2).all()
Out[35]: [<User 3>, <User 4>]
 
In [36]: li = User.query.offset(2).all()
 
In [37]: li[0].name
Out[37]: 'chen'
 
In [38]: li[1].name
Out[38]: 'zhou'
 
In [39]: li = User.query.offset(1).limit(2).all()
 
In [40]: li
Out[40]: [<User 2>, <User 3>]
 
In [41]: li[0].name
Out[41]: 'zhang'
 
In [42]: li[1].name
Out[42]: 'chen'
"""排序查询"""
In [43]: User.query.order_by("id").all()
Out[43]: [<User 1>, <User 2>, <User 3>, <User 4>]
 
In [44]: li = User.query.order_by(User.id.desc()).all()
 
In [45]: li
Out[45]: [<User 4>, <User 3>, <User 2>, <User 1>]
 
In [46]: li[0].name
Out[46]: 'zhou'
 
In [47]: li[1].name
Out[47]: 'chen'
 
"""分组查询"""
In [48]: from sqlalchemy import func
 
In [49]: db.session.query(User.role_id, func.count(User.role_id)).group_by(User.role_id).all()
Out[49]: [(1, 2), (2, 2)]