Flask框架知识系列之二

最新推荐文章于 2023-08-19 21:35:22 发布

ITxiaoke

最新推荐文章于 2023-08-19 21:35:22 发布

阅读量513

点赞数

分类专栏： Flask框架学习文章标签：数据库 SQLALchemy Flask数据库

本文链接：https://blog.csdn.net/u014745194/article/details/78688881

版权

Flask框架学习专栏收录该内容

4 篇文章 0 订阅

订阅专栏

1,SQLALchemy数据库

SQLALchemy是一个关系型数据库框架，它提供了高层的ORM和底层的原生数据库的操作。
flask-sqlalchemy是一个简化了SQLALchemy操作的flask扩展。

2,使用Flask-SQLAlchemy管理数据库

在Flask-SQLAlchemy中，数据库使用URL指定，而且程序使用的数据库必须保存到Flask配置对象的SQLALCHEMY_DATABASE_URI键中。

Flask的数据库设置：

 app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://root:mysql@127.0.0.1:3306/test'

3,常用的SQLAlchemy字段类型

这里写图片描述

4,常用的SQLAlchemy列选项

这里写图片描述

5,常用的SQLAlchemy关系选项

这里写图片描述

6,常用的SQLAlchemy查询过滤器

这里写图片描述

7,常用的SQLAlchemy查询执行器

这里写图片描述

8,模型之间的关联

一对多

class Role(db.Model):
    ...
    #关键代码
    us = db.relationship('User', backref='role', lazy='dynamic')
    ...

class User(db.Model):
    ...
    role_id = db.Column(db.Integer, db.ForeignKey('roles.id'))

其中realtionship描述了Role和User的关系。
在此文中，第一个参数为对应参照的类”User”;
第二个参数backref为类User申明新属性的方法；
第三个参数lazy决定了什么时候SQLALchemy从数据库中加载数据,
如果设置为子查询方式(subquery),则会在加载完User对象后,就立即加载与其关联的对象,这样会让总查询数量减少,但如果返回的条目数量很多,就会比较慢,
另外,也可以设置为动态方式(dynamic),这样关联对象会在被使用的时候再进行加载,并且在返回前进行过滤,如果返回的对象数很多,或者未来会变得很多,那最好采用这种方式

多对多

registrations = db.Table('registrations',  
    db.Column('student_id', db.Integer, db.ForeignKey('students.id')),  
    db.Column('course_id', db.Integer, db.ForeignKey('courses.id'))  
)  

class Course(db.Model):
    ...

class Student(db.Model):
    ...
    classes = db.relationship(  'Course',
                                secondary=registrations,  
                                backref='student',  
                                lazy='dynamic')

表设计的一些总结

一对多的关系是：房屋表和房屋图片表
在一种写关系db.relationship()，
在多种写外键db.ForeignKey().

例如：
在类名House中：创建字段
images = db.relationship('HouseImage')  # 房屋的图片
在类名HouseImage中，创建外键
house_id = db.Column(db.Integer, db.ForeignKey('ih_house_info.id', nullable=False)) # 房屋编号

多对多的关系是：房屋表和设施表
在其中一个表中创建secondary=””,来创建关联的中间表，且中间表中两个字段都为主键

例如：
在其中一个类名House中：创建字段
facilities = db.relationship('Facility', secondary=house_facility)  # 房屋的设施
在中间关联表中：

house_facility = db.Table(
    '''房屋设施表，建立房屋与设施的多对多关系表'''
    'ih_house_facility',
    db.Column('house_id', db.Integer, db.ForeignKey('ih_house_info.id'), primary_key=True),
    db.Column('facility_id', db.Integer, db.ForeignKey('ih_facility_info.id'), primary_key=True)
)
另外那张表就不需要做过多的设置

9,数据库模型中指定加载记录的几种方式

lazy决定了 SQLAlchemy 什么时候从数据库中加载数据:

'select' (默认值) 就是说 SQLAlchemy 会使用一个标准的 select 语句必要时一次加载数据。
也就是说访问到属性的时候，就会全部加载该属性的数据

'joined' 告诉 SQLAlchemy 使用 JOIN 语句作为父级在同一查询中来加载关系。
也就是说在对关联的两个表进行join操作，从而获取到所有相关的对象

'subquery' 类似 'joined' ，但是 SQLAlchemy 会使用子查询。

'dynamic' 在有多条数据的时候是特别有用的。不是直接加载这些数据，
也就是说在访问属性的时候，并没有在内存中加载数据，而是返回一个query对象,
 需要执行相应方法才可以获取对象，比如.all().

lazy="dynamic"只可以用在一对多和多对多关系中，不可以用在一对一和多对一中

10,增删改查的案例

将数据添加到会话中示例：

user = User(name='python')
db.session.add(user)
db.session.commit()

创建表：

db.create_all()

删除表

db.drop_all()

插入一条数据

ro1 = Role(name='admin')
db.session.add(ro1)
db.session.commit()
#再次插入一条数据
ro2 = Role(name='user')
db.session.add(ro2)
db.session.commit()

一次插入多条数据

us1 = User(name='wang',email='wang@163.com',pswd='123456',role_id=ro1.id)
us2 = User(name='zhang',email='zhang@189.com',pswd='201512',role_id=ro2.id)
us3 = User(name='chen',email='chen@126.com',pswd='987654',role_id=ro2.id)
us4 = User(name='zhou',email='zhou@163.com',pswd='456789',role_id=ro1.id)
db.session.add_all([us1,us2,us3,us4])
db.session.commit()

查询:filter_by精确查询

返回名字等于wang的所有人

User.query.filter_by(name='wang').all()

first()返回查询到的第一个对象

User.query.first()

all()返回查询到的所有对象

User.query.all()

filter模糊查询，返回名字结尾字符为g的所有数据。

User.query.filter(User.name.endswith('g')).all()

get():参数为主键，如果主键不存在没有返回内容

User.query.get()

逻辑非，返回名字不等于wang的所有数据

User.query.filter(User.name!='wang').all()

逻辑与，需要导入and，返回and()条件满足的所有数据

from sqlalchemy import and_
User.query.filter(and_(User.name!='wang',User.email.endswith('163.com'))).all()

逻辑或，需要导入or_

from sqlalchemy import or_
User.query.filter(or_(User.name!='wang',User.email.endswith('163.com'))).all()

not_ 相当于取反

from sqlalchemy import not_
User.query.filter(not_(User.name=='chen')).all()

查询数据后删除

user = User.query.first()
db.session.delete(user)
db.session.commit()
User.query.all()

更新数据

user = User.query.first()
user.name = 'dong'
db.session.commit()
User.query.first()

关联查询示例：

角色和用户的关系是一对多的关系，一个角色可以有多个用户，一个用户只能属于一个角色

查询角色的所有用户

#查询roles表id为1的角色
ro1 = Role.query.get(1)
#查询该角色的所有用户
ro1.us.all()

查询用户所属角色

#查询users表id为3的用户
us1 = User.query.get(3)
#查询用户属于什么角色
us1.role

11,数据库的迁移

1,python 文件名 db init
2,python 文件名 db migrate -m "版本名"
3,python 文件名 db upgrade 然后观察表结构
4,根据需求修改模型
5,python 文件名 db migrate -m"新版本名"
6,python 文件名 db upgrade 然后观察表结构
7,若返回版本,则利用 python 文件名 db history ，就可以查看版本号
8,python 文件名 db downgrade 版本号