Flask-sqlalchemy数据库拓展模块

Flask-sqlalchemy模块是什么？

Flask-SQLAlchemy 是一个 Flask 扩展,简化了在 Flask 程序中使用 SQLAlchemy 的操作。
SQLAlchemy 是一个很强大的关系型数据库框架,支持多种数据库后台。SQLAlchemy 提
供了高层 ORM,也提供了使用数据库原生 SQL 的低层功能。

配置数据库

from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
# 指定数据库
app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://root:redhat@localhost/UserTest'

# 不开启追踪修改
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

# 实例化对象
db = SQLAlchemy(app)

# 附加：当出现连接错误时的解决方法
import pymysql
pymysql.install_as_MySQLdb()

定义模型

class User(db.Model):
	# 默认情况下，表的名称为类名，如果需要修改，则输入下面的命令:
	# __tablename__==your table name   # __tablename__为类变量定义数据库中使用的表名。
	
	# db.Column 类构造函数的第一个参数是数据库列和模型属性的类型。
    # db.Column 中其余的参数指定属性的配置选项。
    id = db.Column(db.Integer, primary_key=True)     # integer为普通整数，primay_key为主键，唯一
    username = db.Column(db.String(30), unique=True, nullable=Flase)  # unique=True 唯一不重复
    password = db.Column(db.String(20), nullable=Flase)     # nullable=False 为不能为空
    email = db.Column(db.String(20), unique=True)

常用SQL列类型

常用SQL列属性

单个数据表的创建以及增删改查

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from datetime import  datetime
import pymysql
pymysql.install_as_MySQLdb()

app = Flask(__name__)

# 配置以及实例化

# 对数据库操作(mysql, redis)
app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://root:redhat@localhost/UserTest'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

# 实例化对象
db = SQLAlchemy(app)

#  定义数据库模型
# user ==== (id, username, password, email)
class User(db.Model):
    __tablename__ = "用户信息"
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(30), unique=True, index=True, nullable=False)
    password = db.Column(db.String(20), nullable=False)
    email = db.Column(db.String(20), unique=True, index=True)
    # default为默认值--当前时间
    add_time = db.Column(db.DateTime, default=datetime.now() )


if __name__ == '__main__':
    # 创建所有的表,db.drop_all()是为了清除上一次运行的结果，删除表中的所有列，方便下一次操作的观察。
    db.drop_all()
    db.create_all()

    # 插入数据(insert)
    u1 = User(username="粉条", password="westos", email="[email protected]")
    u2 = User(username="粉丝", password="westos", email="[email protected]")
    db.session.add(u1)
    db.session.add(u2)
    db.session.commit()

    # 删除数据(delete)
    delete_user = User.query.filter_by(username="粉条").first()
    db.session.delete(delete_user)
    db.session.commit()

    # 更新数据(update)
    update_user = User.query.filter_by(username="粉丝").first()
    update_user.email = '[email protected]'
    db.session.add(update_user)
    db.session.commit()

    # 查看数据(select)
    users = User.query.all()
    print(users)

    # 删除所有的表;
    db.drop_all()

关联性数据表的增删改查与过滤器查询

from datetime import datetime
from flask import Flask, render_template
from flask_sqlalchemy import SQLAlchemy, Pagination
from flask_bootstrap import Bootstrap
import pymysql
from sqlalchemy import desc, func
pymysql.install_as_MySQLdb()

app = Flask(__name__)

app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://root:redhat@localhost/UserTest'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)


### 用户和角色是什么关系?
# 确定关系的目的是：连接两个数据表，外键所写的位置。
#    - 一对一
#    - 一对多: 角色是一， 用户是多，外键写在多的一端，
#   - 多对多

class Role(db.Model):
    __tablename__ = "用户角色"
    # id号递增autoincrement=True
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    name = db.Column(db.String(20))
    # 反向引用, Role表中有属性users， User类中有role这个属性;
    users = db.relationship('User', backref='role')

    def __repr__(self):
        return "<Role %s>" % (self.name)


class User(db.Model):
    __tablename__ = "网站用户"
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(30), unique=True, index=True, nullable=False) 
    password = db.Column(db.String(20), nullable=False)
    email = db.Column(db.String(20), unique=True, index=True)
    # 设置默认值， 位当前用户的创建时间;
    add_time = db.Column(db.DateTime, default=datetime.now())
    # 重要的： 用户角色id不能随便设置， 需要从Role中查询, （外键关联）
    role_id = db.Column(db.Integer, db.ForeignKey('用户角色.id'))

    # 定义了 __repr()__ 方法,返回一个具有可读性的字符串表示模型,可在调试和测试时使用。
    def __repr__(self):
        return "<User %s>" % (self.username)


if __name__ == '__main__':
    db.drop_all()
    db.create_all()

    # 添加数据
    # 1). 添加角色，实例化Role
    role1 = Role(name="普通用户")
    role2 = Role(name="会员")
    role3 = Role(name="管理员")

    db.session.add_all([role1, role2, role3])
    db.session.commit()
    
    # 2). 添加用户，实例化User
    user1 = User(username="westos1", password="westos1",
                 email="[email protected]", role_id=1)
    db.session.add(user1)
    db.session.commit()

    # 查看数据信息
    print(User.query.all())
    print(Role.query.all())

    # 批量添加用户100个是普通用户， 50个是VIP用户， 10个管理员，用于测试
    for item in range(100):
        user = User(
            username="fentiao%s" % (item),
            password="fentiao",
            email="fentiao%s" % (item),
            role_id=1
        )
        db.session.add(user)

    for item in range(50):
        user = User(
            username="vip%s" % (item),
            password="vip",
            email="vip%s" % (item),
            role_id=2
        )
        db.session.add(user)

    for item in range(10):
        user = User(
            username="admin%s" % (item),
            password="admin",
            email="admin%s" % (item),
            role_id=3
        )
        db.session.add(user)

    # 将批量添加的用户提交到数据库中.
    db.session.commit()

    # 获取所有的普通用户
    common_users = User.query.filter_by(role_id='1').all()
    print(common_users)
    vip_users = User.query.filter_by(role_id='2').all()
    print(vip_users)

    # 获取所有的普通用户转化成的sql语句查看;
    print(User.query.filter_by(role_id='1'))
    print(User.query)

    # filter过滤器的使用（更偏向于SQL语句）
    common_users = User.query.filter(User.role_id == 1).all()
    print(common_users)

    # limit过滤器, 只显示返回结果的前几条数据;
    common_users_limit = User.query.filter(User.role_id == 1).limit(5).all()
    print(common_users_limit)

    # offset过滤器: 偏移显示，例子：从第三个数据开始，显示3条数据
    common_users_offset = User.query.filter(User.role_id == 1).offset(2).limit(3).all()
    print(common_users_offset)

    # order_by排序过滤器, 默认是升序的， 如果要降序desc(属性名)
    common_users_order = User.query.order_by(User.role_id).all()
    print(common_users_order)
    # 降序
    common_users_desc_order = User.query.order_by(desc(User.role_id)).all()
    print(common_users_desc_order)

    # group_by, 分组统计
    users_analysis = User.query.add_columns(func.count(User.role_id)).group_by(User.role_id).all()
    print(users_analysis)

    # get方法
    print(User.query.get(1))
    # print(User.query.get_or_404(1000))

    # count
    print(User.query.filter_by(role_id=1).count())
    print(User.query.filter_by(role_id=2).count())
    print(User.query.filter_by(role_id=3).count())

    # paginate分页的对象
    # page=2： 要显示第2页的数据， per_page=5： 每页显示数据的条数
    # 101+50+10
    usersPageObj = User.query.paginate(page=2, per_page=5)

    print("当前页面的记录数:", usersPageObj.items)
    print("分页查询的源sql语句:", usersPageObj.query)
    print("当前显示的页数:", usersPageObj.page)
    print("上一页的页数:", usersPageObj.prev_num)
    print("下一页的页数:", usersPageObj.next_num)
    print("是否包含上一页:", usersPageObj.has_prev)
    print("是否包含下一页:", usersPageObj.has_next)
    print("总页数:", usersPageObj.pages)
    print("每页记录的数量:", usersPageObj.per_page)
    print("记录总数:", usersPageObj.total)

    # *********************
    print("页码显示:", list(usersPageObj.iter_pages()))
    print("上一页的数据:", usersPageObj.prev().items)
    print("下一页的数据:", usersPageObj.next().items)



    # Role表反向引用
    admin_role = Role.query.filter_by(name="管理员").first()
    print(admin_role.id)
    print(admin_role.name)
    print(admin_role.users)


    # User表中
    admin_user = User.query.filter_by(username='admin1').first()
    admin_user_id = admin_user.role_id
    print(Role.query.filter_by(id=admin_user_id).first().name)

查询过滤器的总结

sqlalchemy执行函数总结

分页对象拥有的属性

分页对象拥有的方法

补充：用户信息安全性设置_使用werkzeug散列密码

设计 Web 程序时,人们往往会高估数据库中用户信息的安全性。
大多数用户都在不同的网站中使用相同的密码,获得密码之后, 访问用户在其他网站中的账户。

什么是hash密码

用户密码的安全,关键在于不能存储密码本身,而要存储密码的散列
值。

如何使用

计算密码散列值的函数接收密码作为输入,使用一种或多种加密算法转换密码,最终
得到一个和原始密码没有关系的字符序列。
核对密码时,密码散列值可代替原始密码,因为计算散列值的函数是可复现的:只要输入一样,结果就一样。

在需要加密的类中，加入：

    @property
    def password(self):
        """u.password"""
        raise  AttributeError("密码属性不可以读取")

    @password.setter
    def password(self, password):
        """u.password = xxxxx """
        self.password_hash = generate_password_hash(password)


    def verify_password(self, password):
        """验证密码是否正确"""
        return  check_password_hash(self.password_hash, password)

项目代码的结构化设计（tree命令）

在做项目的时候，做到项目条理清晰，每个py文件的功能最好一目了然，在命令行中cd到需要列出的目录中，使用tree显示。
标准格式：

├── app
│   ├── forms.py
│   ├── __init__.py
│   ├── models.py
│   ├── __pycache__
│   │   ├── __init__.cpython-36.pyc
│   │   ├── models.cpython-36.pyc
│   │   └── views.cpython-36.pyc
│   ├── static
│   ├── templates
│   │   └── list.html
│   └── views.py
├── app.py