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

(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:[email protected]: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='[email protected]', password='123456', role_id=role1.id)
    us2 = User(name='zhang', email='[email protected]', password='452342', role_id=role2.id)
    us3 = User(name='chen', email='[email protected]', password='782677', role_id=role2.id)
    us4 = User(name='zhou', email='[email protected]', 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]: '[email protected]'

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)]

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

猜你喜欢