Flask中数据库关联与分页与cache缓存(十二)
1 一对多(One To Many)
表示一对多的关系时，在子表类 Post 中需要通过 foreign key (外键)引用父表类 User
在Post类中指定ForeignKey:
class Post(db.Model):
__tablename__ = 'posts'
id = db.Column(db.String(45), primary_key=True)
title = db.Column(db.String(255))
text = db.Column(db.Text())
publish_date = db.Column(db.DateTime)
# 设置外键ForeignKey
user_id = db.Column(db.String(45),db.ForeignKey('users.id'))
user_id 字段是 posts 表的外键，代表了外键约束。强制规定了字段 user_id 的值必须同时存在于User.id 列中。用来保证每一篇post都能对应找到一个user，而且一个user能够对应多篇 posts
在User父类指定
class User(db.Model):
# 设置表名为users
__tablename__ = 'users'
id = db.Column(db.String(45), primary_key=True)
username = db.Column(db.String(255))
password = db.Column(db.String(255))
# 设置连接posts的并反向查询users
posts = db.relationship('Post',backref='users',lazy='dynamic')
#一对多
#Post设置外键的表,属于多
user_id = db.Column(db.String(45), db.ForeignKey('users.id'))
#User设置关联的表,属于1
posts = db.relationship('Post',backref='users',lazy='dynamic')
注意:
-
db.relationsformat(self.username)： 会在 SQLAlchemy 中创建一个虚拟的列，该列会与 Post.user_id (db.ForeignKey) 建立联系
-
backref：用于指定表之间的双向关系，如果在一对多的关系中建立双向的关系，这样的话在对方看来这就是一个多对一的关系,反向查询的表名
-
lazy：指定 SQLAlchemy 加载关联对象的方式。
lazy=subquery: 会在加载 Post 对象后，将与 Post 相关联的对象全部加载
lazy=dynamic: 只有被使用时，对象才会被加载，并且返回式会进行过滤
2 多对多(Many To Many)
class Posts(db.Model):
__tablename__ = 'posts'
id = db.Column(db.Integer,primary_key=True)
content = db.Column(db.Text)
pid = db.Column(db.Integer,default=0)
path = db.Column(db.String(255),default='0,')
timestamp = db.Column(db.DateTime,default=datetime.utcnow)
#一对多posts为多,设置外键 Foreignkey
uid = db.Column(db.Integer,db.ForeignKey('user.id'))
class User(UserMixin,db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer,primary_key=True)
username = db.Column(db.String(12),index=True)
password_hash = db.Column(db.String(128))
sex = db.Column(db.Boolean,default=True)
age = db.Column(db.Integer)
email = db.Column(db.String(40))
icon = db.Column(db.String(70),default='default.jpg')
#当期账户激活状态
confirm = db.Column(db.Boolean,default=False)
#参数1模型名称 参数2反向引用的字段名 参数3 加载方式 提供对象
#post与user为一对多,一设置反向查询表名user
posts = db.relationship('posts',backref='user',lazy='dynamic')
#post与collect是多对多关系
favorite = db.relationship('Posts',secondary='collections',backref=db.backref('users',lazy='dynamic'),lazy='dynamic')
#中间表collections,多对多
collections = db.Table('collections',
db.Column('user_id',db.Integer,db.ForeignKey('user.id')),
db.Column('posts_id',db.Integer,db.ForeignKey('posts.id'))
)
关于中间表
也可以写成类的形式创建
class Collections(db.Model):
__tablename__ = 'collectionss'
user_id = db.Column('user_id', db.Integer, db.ForeignKey('user.id'))
posts_id = db.Column('posts_id', db.Integer, db.ForeignKey('posts.id'))
注意:
- many to many 的关系仍然是由
db.relationship()来定义 - seconddary(次级)：会告知 SQLAlchemy 该 many to many 的关联保存在 posts_tags 表中
- backref：声明表之间的关系是双向，帮助手册
help(db.backref)。需要注意的是：在 one to many 中的 backref 是一个普通的对象，而在 many to many 中的 backref 是一个 List 对象。
3 数据迁移
from flask_migrate import Migrate
migrate = Migrate(main.app, models.db) #绑定app与db
manager = Manager(main.app)
manager.add_command("db", MigrateCommand) #给数据库迁移重命名db
python3 manage.py db init #初始化 DB Migrate
python3 manage.py db migrate #开始迁移生成migrations 目录,保存所有的更改记录文件
python3 manage.py db upgrade #将需要修改的数据库结构的更新内容，手动的写入到记录文件中，然后执行 upgrade 指令就能够实现数据库的更新
python manage.py db history # 获取 History ID
python manage.py db downgrade <history_id> # 回滚到某个 history
4 paginate分页类
(1) paginate 分页类
返回 pagination分页对象
参数:
page 必须参数 代表当前的页码
per_page 每页显示数据的条数 默认为20条
error_out 当分页查询出现异常的时候 是否抛出错误 默认抛出 改为Flase
(2) pagination分页对象 属性
items 当前分页的所有数据
page 当期页码
pages 总页码数
total 总记录数
per_page 每页显示数据的条数
prev_num 返回上一页的页码
next_num 返回下一页的页码
has_prev 是否存在上一页
has_next 是否存在下一页
(3) pagination分页对象 方法
prev 上一页的分页对象
next 下一页的分页对象
iter_pages 是一个迭代器 返回分页栏上的页码数 如果显示不下 返回None
5 flask-cache 缓存
安装
pip3 install flask-cache
导入使用
#自带simple缓存
from flask_cache import Cache
cache = Cache(app,config={'CACHE_TYPE': 'simple'}) #实例化cache
或者利用工厂函数
cache = Cache(config={'CACHE_TYPE': 'simple'})
def create_app(app): #工厂函数
cache.init_app(app)
#注: simple代表简单的缓存,容易出现问题,一般可以采用redis代替
cache = Cache(app, config={'CACHE_TYPE': 'redis', # Use Redis
'CACHE_REDIS_HOST': 'abc.com', # Host, default 'localhost'
'CACHE_REDIS_PORT': 6379, # Port, default 6379
'CACHE_REDIS_PASSWORD': '111', # Password
'CACHE_REDIS_DB': 2} # DB, default 0
缓存无参数的普通函数 : @ cache.cached(timeout,key_prefix)
@cache.cached(timeout=100,key_prefix='index')
#NOTE 1: 装饰器 @ cache.cached() 的形参数 key_prefix 是必须的, 并且传入的值是唯一的, 这样 Flask-Cache 才能够正确的返回该函数缓存的值.
#NOTE 2: 该函数被缓存的时间设定为100s, 这是因为该函数返回的值不被经常改变, 而且就算是被改变了也不会对整体页面的显示有大的影响.
缓存带参数的普通函数 : @cache.memoize(timeout)
不带参数的装饰器不考虑参数问题,就算函数接受不同的实参还是返回相同的结果,这明显的不科学的.因此采用记忆型的 @cache.memoize(),但是使用与纯函数调用
@cache.memoize(timeout=100)
#NOTE 1: 装饰器 @cache.memoize() 不仅仅会缓存运行的结果, 还缓存调用时的参数, 所以在函数接受到相同的参数时, 就会将缓存中该参数对应的结果返回.
#NOTE 2: @cache.momoize() 非常不适用于返回结果依赖全局变量或依赖数据库查询的函数, 因为在这很容易导致数据竞态, 即输入了相同的参数, 可能会返回不同的结果. 最适合被缓存的函数是纯函数(在传入的参数相同的情况下会输出相同的结果)
缓存无动态参数的视图函数
@blog_blueprint.route('/<int:page>')
@cache.cached(timeout=60)
#NOTE 1: 这里仍然是使用装饰器 @cache.cached(), 但却不必需要指定 key_prefix 形参.
#NOTE 2: timeout 表示该视图函数返回的结果将会被缓存的时长.
缓存带动态参数的视图函数
@blog_blueprint.route('/post/<string:post_id>', methods=('GET', 'POST'))
@cache.cached(timeout=60, key_prefix=make_cache_key)
#NOTE 1: 这里我们仍然使用了 key_prefix 参数来进行定位, 而且该形参除了可以接受 String 类型对象之后, 也可以接收一个函数.
#NOTE 2: 函数 make_cache_key() 会动态的生成一个唯一的缓存键, 用于确定这一次请求的 URL 是否存在缓存, 如果存在则返回, 如果不存在则新建. 所以在该函数中我们使用了请求 path + hash 字符串结合而成的唯一字符串作为缓存键.
删除缓存
(1) 给settings.py 设置参数
CACHE_DEFAULT_TIMEOUT
(2) 给装饰器 添加 timeout参数
@cache.cached(timeout=100)
(3) 清除所有的缓存
cache.clear()
(4) 清除cached的缓存
@cache.cached(timeout=100,key_prefix='index') #当前缓存的前缀
cache.delete('index')
(5) 清除 memoize的缓存
cache.delete_memoized(视图函数的名称)
