Flask用模型类对数据库操作

1. 在视图函数中定义模型类

   # coding:utf-8
   from flask import Flask
   from flask_sqlalchemy import SQLAlchemy
   
   app = Flask(__name__)
   
   class Config(object):
       """配置参数"""
       # sqlalchemy的配置参数              用户名 密码     ip       port   database
       SQLALCHEMY_DATABASE_URI = "mysql://root:123456@127.0.0.1:3306/db_flask_python2"
   
       # 设置sqlalchemy自动跟踪数据库(意思是自动同步)
       SQLALCHEMY_TRACK_MODIFICATIONS = True
   
   
       app.config.from_object(Config)
   
   
       # 创建数据库sqlalchemy工具对象 (SQLAlchemy会自动去config把Config里的属性提取出来)
       db = SQLAlchemy(app)
   
   
     class Role(db.Model):
         """用户角色/身份表"""
         # 在数据库的名字 tbl_roles
         __tablename__ = "tbl_roles"
         # db.Column表示在数据库中出现的字段
         # primary_key：主键
         # db.Integer：在数据库里 int类型
         # db.String(32)：在数据库里是varchar(32)
         # unique: 如果为True，代表这列不允许出现重复的值
         id = db.Column(db.Integer, primary_key=True)
         name = db.Column(db.String(32), unique=True)
   
         # db.relationship表示关系,不存在数据库里面的字段
         # users到地是返回的那个模型类的对象,那就把那个表传递进来
         # backref反推 backref="role"相当于给User这张表添加了一个role属性
         users = db.relationship("User", backref="role")
   
         def __repr__(self):
           """定义之后, 可以让显示对象的时候更直观"""
           return "Role object: name=%s"%self.name
   
   
       # 表名的常见规范
       # ihome ---> ih_user  数据库名缩写_表名
       # tbl_user  tbl_表名
       # 创建数据库模型类
       # 继承db这个对象里面的父类
       class User(db.Model):
           """用户表"""
           # 指明数据库的表明
           __tablename__ = "tbl_users"
   
           # 整形的主键会, 会默认设置为自增主键
           # flask跟django不同 flask主键要自己定义
           id = db.Column(db.Integer, primary_key=True)
           # db.Column表示这个字段实在数据库中存在的
           # db.String字符串类型长度为64 unique=True唯一约束 name不能重复
           name = db.Column(db.String(64), unique=True)
           email = db.Column(db.String(128), unique=True)
           password = db.Column(db.String(128))
           # 创建外键 db.ForeignKey
           role_id = db.Column(db.Integer, db.ForeignKey("tbl_roles.id"))
   
           def __repr__(self):
             """定义之后, 可以让显示对象的时候更直观"""
             return "User object: name=%s"%self.name
   
   
         if __name__ == '__main__':
             #　app.run(debug=True)
             # 第一次房间数据库时, 防止有脏数据, 所以用这个方法清空这个数据库里面所有表
             # 清楚数据库里的所有数据
             # 千万记住 只有第一次才能用,要是在公司,不是第一次你用这条命令, 你就可以卷铺盖走人了
             db.drop_all()
   
             # 创建所有的表
             db.create_all()
   
             # 把数据保存在数据库中
             # 创建对象
             role1 = Role(name="admin")
             # 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 ='201512', role_id=role2.id)
             us3 = User(name='chen', email='chen@126.com', password ='987654', role_id=role2.id)
             us4 = User(name='zhou', email='zhou@163.com', password ='456789', role_id=role1.id)
             # 一次保存多条数据
             db.session.add_all([us1,us2,us3,us4])
             db.session.commit()
   

2. 常用的SQLAlchemy查询过滤器

    过滤器							说明
    filter()						把过滤器添加到原查询上，返回一个新查询
    filter_by()				把等值过滤器添加到原查询上，返回一个新查询
    limit							使用指定的值限定原查询返回的结果
    offset()						偏移原查询返回的结果，返回一个新查询
    order_by()					根据指定条件对原查询结果进行排序，返回一个新查询
    group_by()					根据指定条件对原查询结果进行分组，返回一个新查询
   

3. 常用的SQLAlchemy查询执行器

    方法							   说明
    all()						  以列表形式返回查询的所有结果
    first()						返回查询的第一个结果，如果未查到，返回None
    first_or_404()			返回查询的第一个结果，如果未查到，返回404
    get()							返回指定主键对应的行，如不存在，返回None
    get_or_404()				返回指定主键对应的行，如不存在，返回404
    count()						返回查询结果的数量
    paginate()					返回一个Paginate对象，它包含指定范围内的结果
   

4. 创建表

   db.create_all()
   

5. 删除表

   db.drop_all()
   

6. 插入一条数据

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

7. 一次插入多条数据

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

8. 查询:filter_by精确查询-返回名字等于wang的所有人

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

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

   User.query.first()
   

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

    User.query.all()
    

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

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

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

    User.query.filter(User.name.like("%" + "哈哈" + "%" )).all()
    

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

    User.query.get()
    

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

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

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

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

16. 逻辑或，需要导入or_

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

17. not_ 相当于取反

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

18. 查询数据后删除

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

19. 更新数据

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

20. 使用update

    User.query.filter_by(name='zhang').update({'name':'li'})
    

21. 关联查询示例：角色和用户的关系是一对多的关系，一个角色可以有多个用户，一个用户只能属于一个角色。
    查询角色的所有用户：

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

22. 查询用户所属角色：

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