Flask 使用Flask-SQLAlchemy操作数据库

小鱼儿 2022-12-24 11:57 337阅读 0赞

### 安装 ###

Flask-SQLAlchemy是一个Flask扩展，所以使用之前也需要使用pip命令进行安装

pip install flask-sqlalchemy

### 相关配置 ###

在使用Flask-SQLAlchemy操作数据库之前需要先连接数据库。相关配置如下：

from flask_sqlalchemy import SQLAlchemy
    
    app = Flask(__name__)
    
    # 连接数据库
    # mysql://账号:密码@链接地址:端口/数据库名
    app.config['SQLALCHEMY_DATABASE_URI'] = "mysql+pymysql://root:root@localhost:3306/flaskdemo"
    # 设置是否跟踪数据库的修改情况
    app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
    # 数据库操作时是否显示原始SQL语句，日志
    app.config['SQLALCHEMY_ECHO'] = True
    # 链接超时时间
    app.config['SQLALCHEMY_POOL_TIMEOUT'] = 3000
    
    # 实例SQLAlchemy类，use_native_unicode='utf8'设置编码，必须设置
    db = SQLAlchemy(app, use_native_unicode='utf8');

上面配置的链接url是链接MySQL数据库的，链接其他数据库配置如下：

<table> 
 <thead> 
  <tr> 
   <th>数据库</th> 
   <th>URL</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>MySQL</td> 
   <td>mysql://username:password@hostname/database</td> 
  </tr> 
  <tr> 
   <td>Postgres</td> 
   <td>postgresql://username:password@hostname/database</td> 
  </tr> 
  <tr> 
   <td>SQLite(Unix)</td> 
   <td>sqlite:absolute/path/to/database</td> 
  </tr> 
  <tr> 
   <td>SQLite(Windows)</td> 
   <td>sqlite:c:/absolute/path/to/database</td> 
  </tr> 
 </tbody> 
</table>

在这些url中，hostname表示数据库所在的主机，可以是本地主机(localhost)，也可以是远程服务器。database为要使用的数据库名。username和password表示数据库用户名和密码。

### 定义模型 ###

在ORM中模型一般是一个python类，类中的属性对应数据库表中的列。如下定义了两个模型Role和User。  
User和Role是一对多关系。

class Role(db.Model):
        # 定义表名
        __tablename__ = 'roles';
        # db.Column定义属性，db.Integer设置类型，
        # Primary_key = True设置主键
        # unique = True设置唯一索引
        # index = True创建索引，提示查询效率
        # nullable = True允许为空值
        # default为这列设置默认值
        # autoincrement = True自动递增
        id = db.Column(db.Integer, primary_key=True, autoincrement=True)
        name = db.Column(db.String(64), nullable=False)
    
    
    # 定义一个User类
    class User(db.Model):
        __tablename__ = 'users';
        id = db.Column(db.Integer, primary_key=True, autoincrement=True);
        username = db.Column(db.String(64), unique=True, index=True);
        password = db.Column(db.String(64));
    
        # 建立对应关系
        # 如果是多对多关系就建一张表，关联两个表的id
        role_id = db.Column(db.Integer, db.ForeignKey('roles.id'))
    
        '''
           帮助作关联查询
           relationship()把两个表关联在一起，不添加也是可以的，根据自己的需求
           backref : 在关系的另一模型中添加反向引用
                      相当于给要关联的表添加一个role属性
                      不添加也是可以的，根据自己的需求
       '''
        rol = db.relationship('Role', backref='use')

db.Column类构造函数的第一个参数是数据库列和模型属性的类型。如下表是一些常用的列类型

<table> 
 <thead> 
  <tr> 
   <th>类型名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Integer</td> 
   <td>普通整数，一般是32位</td> 
  </tr> 
  <tr> 
   <td>SmallInteger</td> 
   <td>取值范围小的整数，一般是16位</td> 
  </tr> 
  <tr> 
   <td>Float</td> 
   <td>浮点数</td> 
  </tr> 
  <tr> 
   <td>Numeric</td> 
   <td>定点数</td> 
  </tr> 
  <tr> 
   <td>String</td> 
   <td>字符串</td> 
  </tr> 
  <tr> 
   <td>Text</td> 
   <td>文本字符串</td> 
  </tr> 
  <tr> 
   <td>Boolean</td> 
   <td>布尔值</td> 
  </tr> 
  <tr> 
   <td>Date</td> 
   <td>日期</td> 
  </tr> 
  <tr> 
   <td>Time</td> 
   <td>时间</td> 
  </tr> 
  <tr> 
   <td>DateTime</td> 
   <td>日期和时间</td> 
  </tr> 
 </tbody> 
</table>

db.Column中其余的参数指定属性的配置选项，如下是一些可用的选项

<table> 
 <thead> 
  <tr> 
   <th>选项名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>primary_key</td> 
   <td>如果设为True，这列就是表的主键</td> 
  </tr> 
  <tr> 
   <td>unique</td> 
   <td>如果设为True，唯一索引</td> 
  </tr> 
  <tr> 
   <td>index</td> 
   <td>如果设为True，为这列创建索引</td> 
  </tr> 
  <tr> 
   <td>nullable</td> 
   <td>如果设为True，允许为空值</td> 
  </tr> 
  <tr> 
   <td>default</td> 
   <td>为这列定义默认值</td> 
  </tr> 
  <tr> 
   <td>autoincrement</td> 
   <td>如果设为True，自动递增</td> 
  </tr> 
 </tbody> 
</table>

常用的关系配置选项

<table> 
 <thead> 
  <tr> 
   <th>选项名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>backref</td> 
   <td>在关系的另一个模型中添加反向引用</td> 
  </tr> 
  <tr> 
   <td>order_by</td> 
   <td>指定关系中记录的排序方式</td> 
  </tr> 
  <tr> 
   <td>secondary</td> 
   <td>指定多对多关系中关系表的名字</td> 
  </tr> 
 </tbody> 
</table>

### 操作数据库 ###

#### 创建和删除表 ####

表的模型创建好后，可以使用db.create\_all()函数根据模型在数据库中创建对应的表。

# 根据类创建表
    db.create_all()
    # 删除所有表
    db.drop_all()

#### 增删改查 ####

**添加**

创建两个添加数据的视图函数，一次可以添加一条或多条数据。

# 新增一条数据
    @app.route('/add')
    def createOne():
        # 构造模型，使用关键字参数指定的模型属性初始值
        role = Role(name = "管理员1");
        # 把准备写入数据库的对象，先添加到会话中
        db.session.add(role);
        # 调用commit()方法提交会话，保存
        db.session.commit();
        return "添加成功！";
    
    # 添加多条数据
    @app.route("/adds")
    def createAll():
        role = Role(name = "管理员2");
        roles = [
            Role(name="管理员3"),
            Role(name="管理员4"),
            Role(name="管理员5")
        ]
        db.session.add_all(roles);
        db.session.add(role);
        db.session.commit();
        return "添加成功"

访问上述两个视图函数后，数据库中添加了对应的数据，如下所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjA1MTE2_size_16_color_FFFFFF_t_70]  
上面给roles表中添加了五条数据，下面这个视图函数给users表添加一条数据，关联roles表。

# 添加用户表数据
    @app.route("/addUser")
    def addUser():
        user = User(username = "admin1", password="admin", role_id=6)
        db.session.add(user);
        db.session.commit();
        return "添加成功"

上面视图函数中是直接给出的roles表中的id值的，开发中可以根据某一属性查询出roles某一条数据进行关联。访问视图函数后，效果如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjA1MTE2_size_16_color_FFFFFF_t_70 1]  
**查询全部结果**

定义一个视图查询出roles表中的所有数据。

# 查询表中全部数据
    @app.route("/findAll")
    def findAll():
        # 返回一个列表，all()函数返回所有结果
        result = Role.query.all();
        print(result)
        for item in result:
            print(item.id, item.name)
        return "查询成功"

查询结果如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjA1MTE2_size_16_color_FFFFFF_t_70 2]  
上述中查询使用了all()函数，返回查询的所有结果，下表是SQLAlchemy查询一些常用的函数。

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>all()</td> 
   <td>以列表形式返回查询的所有结果</td> 
  </tr> 
  <tr> 
   <td>first()</td> 
   <td>返回查询的第一个结果，如果没有结结果，则返回None</td> 
  </tr> 
  <tr> 
   <td>frist_or_404</td> 
   <td>返回查询的第一个结果，如果没有结果，则重则请求，返回404错误响应</td> 
  </tr> 
  <tr> 
   <td>get()</td> 
   <td>返回指定主键对应的行，如果没有对应的行，则返回None</td> 
  </tr> 
  <tr> 
   <td>get_or_404</td> 
   <td>返回指定主键对应的行，如果没找到指定的主键，则终止请求，返回404错误响应</td> 
  </tr> 
  <tr> 
   <td>count()</td> 
   <td>返回查询结果的数量</td> 
  </tr> 
  <tr> 
   <td>paginate()</td> 
   <td>返回一个Paginate对象，它包含指定范围内的结果</td> 
  </tr> 
 </tbody> 
</table>

**根据条件查询**

在上述查询全部数据中，使用filter进行条件查询  
如下视图函数根据username属性查询。

# 根据用户名查询数据
    @app.route("/findByUsername/<username>")
    def findByUsername(username):
    	# filter过滤器，根据条件查询
        obj = User.query.filter(User.username == username).all();
        print(obj);
        return "查询成功";

在SQLAlchemy中除了filter过滤器还有一些其他的查询过滤器。如下

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

**删除**

先根据id查询出需要参数的数据，在使用delete进行删除。

# 根据条件删除
    @app.route("/deleteById/<id>")
    def deleteById(id):
        # 根据id查询数据，filter条件查询
        role = Role.query.filter(Role.id == id).first();
        db.session.delete(role);
        db.session.commit();
        return "删除成功";

**修改**

查询出表中的第一条数据，对其name属性进行修改，之后在保存。

# 修改
    @app.route("/update")
    def update():
        role = Role.query.first();
        role.name = "系统管理员";
        db.session.commit();
        return "修改成功"

上述案例完整代码如下：

from flask import Flask
    from flask_sqlalchemy import SQLAlchemy
    
    app = Flask(__name__)
    
    # 配置链接数据库信息
    # mysql://账号:密码@链接地址:端口/数据库名
    app.config['SQLALCHEMY_DATABASE_URI'] = "mysql+pymysql://root:root@localhost:3306/flaskdemo"
    # 设置是否跟踪数据库的修改情况
    app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
    # 数据库操作时是否显示原始SQL语句，日志
    app.config['SQLALCHEMY_ECHO'] = True
    # 链接超时时间
    app.config['SQLALCHEMY_POOL_TIMEOUT'] = 3000
    # 实例SQLAlchemy类，use_native_unicode='utf8'设置编码，必须设置
    db = SQLAlchemy(app, use_native_unicode='utf8');
    
    @app.route('/')
    def hello_world():
        return 'Hello World!'
    
    # 定义Role和User两个类
    class Role(db.Model):
        # 定义表名
        __tablename__ = 'roles';
        # db.Column定义属性，db.Integer设置类型，
        # Primary_key = True设置主键
        # unique = True设置唯一索引
        # index = True创建索引，提示查询效率
        # nullable = True允许为空值
        # default为这列设置默认值
        # autoincrement = True自动递增
        id = db.Column(db.Integer, primary_key=True, autoincrement=True)
        name = db.Column(db.String(64), nullable=False)
    
    
    # 定义一个User类
    class User(db.Model):
        __tablename__ = 'users';
        id = db.Column(db.Integer, primary_key=True, autoincrement=True);
        username = db.Column(db.String(64), unique=True, index=True);
        password = db.Column(db.String(64));
    
        # 这一列的值为roles表中的id值
        # 如果是多对多关系就建一张表，关联两个表的id
        role_id = db.Column(db.Integer, db.ForeignKey('roles.id'))
    
        '''
           帮助作关联查询
           relationship()把两个表关联在一起，不添加也是可以的，根据自己的需求
           backref : 在关系的另一模型中添加反向引用
                      相当于给要关联的表添加一个role属性
                      不添加也是可以的，根据自己的需求
       '''
        rol = db.relationship('Role', backref='use')
    
    # 新增一条数据
    @app.route('/add')
    def createOne():
        # 构造模型，使用关键字参数指定的模型属性初始值
        role = Role(name = "管理员1");
        # 把准备写入数据库的对象，先添加到会话中
        db.session.add(role);
        # 调用commit()方法提交会话
        db.session.commit();
        return "添加成功！";
    
    # 添加多条数据
    @app.route("/adds")
    def createAll():
        role = Role(name = "管理员2");
        roles = [
            Role(name="管理员3"),
            Role(name="管理员4"),
            Role(name="管理员5")
        ]
        db.session.add_all(roles);
        db.session.add(role);
        db.session.commit();
        return "添加成功"
    
    # 查询表中全部数据
    @app.route("/findAll")
    def findAll():
        # 返回一个列表
        result = Role.query.all();
        print(result)
        for item in result:
            print(item.id, item.name)
        return "查询成功"
    
    # 根据条件删除
    @app.route("/deleteById/<id>")
    def deleteById(id):
        # 根据id查询数据，filter条件查询
        role = Role.query.filter(Role.id == id).first();
        db.session.delete(role);
        db.session.commit();
        return "删除成功";
    
    # 修改
    @app.route("/update")
    def update():
        role = Role.query.first();
        role.name = "系统管理员";
        db.session.commit();
        return "修改成功"
    
    # 添加用户表数据
    @app.route("/addUser")
    def addUser():
        user = User(username = "admin1", password="admin", role_id=6)
        db.session.add(user);
        db.session.commit();
        return "添加成功"
    
    # 根据用户名查询数据
    @app.route("/findByUsername/<username>")
    def findByUsername(username):
        obj = User.query.filter(User.username == username).all();
        print(obj);
        return "查询成功";
    
    # 查询所有用户，不显示权限
    @app.route("/findUserAll")
    def findUserAll():
        objs = User.query.all()
        for obj in objs:
            print(obj.id, obj.username, obj.password, obj.role_id);
        return "查询成功"
    
    # 查询所有用户，显示权限
    @app.route("/findUserAll1")
    def findUserAll1():
        objs = User.query.all()
        for obj in objs:
            # 通过类中的relationship调用关联类的属性
            print(obj.id, obj.username, obj.password, obj.rol.name);
        return "查询成功"
    
    # 查询系统管理员权限的所有用户
    @app.route("/findByList")
    def findByList():
        objs = Role.query.filter(Role.name == "系统管理员").first();
        # 获取拥有系统管理员的所有用户，通过User类中relationship关联属性获取
        user_list = objs.use;
        for item in user_list:
            print(item.id, item.username);
        return "查询成功"
    
    # 根据类创建表
    # db.create_all()
    # 删除所有表
    # db.drop_all()
    if __name__ == '__main__':
        app.run()

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjA1MTE2_size_16_color_FFFFFF_t_70]: /images/20221120/821f83f89dd943e0b2e9fb864e7d5dca.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjA1MTE2_size_16_color_FFFFFF_t_70 1]: /images/20221120/cef350b4066045babb32f6ef130d26be.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjA1MTE2_size_16_color_FFFFFF_t_70 2]: /images/20221120/46928f600e5a4193b2d10110cdd5167e.png