1.4 Flask数据模型ORM

最新推荐文章于 2024-06-17 08:48:05 发布
最新推荐文章于 2024-06-17 08:48:05 发布
阅读量1.4k 收藏 8
点赞数 1
分类专栏： Flask 文章标签： flask python 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41256550/article/details/127464510
版权

一、模型model

1、 什么是模型

模型 - 根据数据库中表结构而创建出来的class
数据库中每一张表对应到变成语言中就是一个class
表中的每一个列， 对应到变成语言中就是class的一个属性

2、模型的框架–ORM框架

1) 、 什么是ORM
    ORM---Object Relational Mapping ，简称： ORM 、 O/RM 、 O/R Mapping
    中文名： 对象关系映射

在这里插入图片描述

2) ORM的三大特征
 - 数据表（Table） 到编程类（Class）的映射
 - 数据类型的映射
    数据库中表的字段以及数据类型对应到编程语言中就是类的属性及数据类型
 - 关系映射（ ******）
   将数据库中表与表的关系对应到变成语言中类与类的关系
   【1-1关系】： 
       A表中的一条数据只能与B表中的一条数据关联 ------           A表中的一条数据只能与B表中的一条数据关联
   【1-多关系】
     A表中的一条数据与B表中的多条数据关联 ------           A表中的一条数据只能与B表中的一条数据关联
   【多-多关系】
      A表中的一条数据与B表中的多条数据关联 ------           A表中的一条数据与B表中的多条数据关联
3） ORM的优点
 - 封装了数据库中所有的操作，提升效率
 - 可以省略庞大的数据访问层，即便不用SQL编码也能完成对数据库的CRUD操作
   Create、Retrieve、Update、Delete

二、Flask中ORM框架

1、SQLALchemy 框架

1) 安装SQLALchemy ： pip安装
2) Flask需要使用flask-sqlachemy支持包： pip install flask-sqlalchemy

2、在Flask中配置数据库

# app.config['SQLALCHEMY_DATABASE__URL'] = "mysql://用户名:密码@数据库服务地址:端口号/数据库"
app.config['SQLALCHEMY_DATABASE__URL'] = "mysql://root:123456@localhost:3306/flask"
# 创建SQLALchemy 的实例 -db,以后再程序中通过db来操作数据库
from flask_sqlalchemy import SQLAlchemy
db = SQLAlchemy(app)

3、 拓展

统一资源标识符（Uniform Resource Identifier） ---URL
统一资源标识符（Uniform Resource Identifier） ---URL
create database flask default utf8 collate utf8_general_ci  # 创建数据库
--- Navicat for Mysql 数据库第三方可视化工具
--- Power Designer  数据库建模工具

二、ORM框架熟知+数据库表设计 *****

1、创建模型model

1） Flask-SQLALchemy连接数据库以及创建表

flask应用实例
from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['DEBUG'] = True
app.config["ENV"] = "development"
# 连接数据库
# app.config['SQLALCHEMY_DATABASE__URL'] = "mysql://用户名:密码@数据库服务地址:端口号/数据库"
app.config['SQLALCHEMY_DATABASE_URL'] = "mysql://root:123456@localhost:3306/flask"
# 设置是否跟踪数据库的修改情况，一般不跟踪
app.config['SQLALCHEMY_TRACE_MODIFICATIONS'] = False  # 设置字段+属性
# 数据库操作时是否显示原始SQL语句，一般是打开的，因为需要后台日志
app.config['SQLALCHEMY_ECHO'] = True

# 实例化ORM框架的操作对象，后续数据库操作，都要基于操作对象来完成
db = SQLAlchemy(app)


class Role(db.Model):
    __tablename = "my_users"  # 设置表名
    user_id = db.Column(db.Integer, primary_key=True)
    user_name = db.Column(db.String(10), nullable=False)


@app.route("/index", endpoint="home")
def index():
    return "这是首页"


if __name__ == "__name__":
    # 创建当前应用中声明的所有模型类对应的数据表，db.drop_all()是删除表
    db.create_all()
    app.run(debug=True)
创建模型model-数据库配置
名称                                   说明
SQLALCHEMY_DATABASE_URL               用于链接的数据库URL："mysql://用户名:密码@数据库服务地址:端口号/数据库"
SQLALCHEMY_BINDS                      一个映射binds到链接URL的字典， 更多binds的信息见Binds操作多个数据库 ---- 连接多个数据库
SQLALCHEMY_ECHO                       如果设置为True，SQLALchemy会记录所有发给stderr的语句，这对调试有用（打印sql语句）
SQLALCHEMY_RECORD_QUERIES             可以用于显式的禁用或启用查询记录。查询记录在调试或测试模式自动启用
SQLALCHEMY_NATIVE_UNICODE             可以用于显式禁用原生unicode支持。当使用不合适的指定无编码的数据库默认值时， 这对于
                                      一些数据库适配器时必须的
SQLALCHEMY_POOL_SIZE                  数据库链接池的大小。默认时引擎默认值（通常是5）
SQLALCHEMY_POOL_TIMEOUT               设定链接池的连接超时时间，默认是10
SQLALCHEMY_POOL_RECYCLE               多少秒自动回连连接。对MYsql是必要的。它默认移除闲置多余8小时的连接，注意如果使用了
                                      MYSQL， Flask-SQLALchemy自动设定这个值为2小时
创建模型model-Binds操作多个数据库
示例配置–连接多个数据库

– 创建模型model-binds

SQLALCHEMY_DATABASE_URL = "mysql://root:123456@localhost:3306/flask"
SQLALCHEMY_BINDS = {
   "users_1": SQLALCHEMY_DATABASE_URL,
   "users_2": "mysql://root:123456@localhost:3306/flask2" }

– 创建和删除表

 create_all（） 和drop_all（）方法默认作用域声明的所有bind，包括默认的， ,"__all__"可以指向一个bind名，或者所有binds,默认是： 
bind(SQLALCHEMY_DATABASE_URL) 名为None:
dp。create_all()
dp.create_all（bind=['users_1']）
 dp.drop_all（bind=['users_1']）

– 引用Binds

- 当声明模型时，可以用: __bin_key__属性指定bind
  class Role(db.Model):
      __bind_key__ = "users_1"  
      user_id = db.Column(db.Integer, primary_key=True)
- bind_key内部存储在表的info字典中，作为bind_key键值，：想要创建一个表对象时，可以如下
   user_favorites = db.Table('user_favorites',
                          db.Column('user_id', db.Integer, db.ForeignKey('user_id')),
                          db.Column('message_id', db.Integer, db.ForeignKey('message_id')),
                          info={'bind_key', 'users_1'})
  # 如果在模型上指定了__bind_key__， 你可以用他们准确的做想做的，模型会自行连接到指定的数据库连接

– 总结

  binds? ----可以执行SQL语句并且通常是一个连接或引擎，，在Flask-SQLALchemy中，bind总是背后自动创建好引擎，引擎中的每个之后都会关联
  短键（bind_key），这个键会在模型声明时使用，来把一个模型关联到一个特定引擎----若没有为模型指定bind key,会默认连接：
  SQLALCHEMY_DATABASE_URL配置的值

2、 创建模型model—字段类型

1) 常见的SQLALchemy字段类型

类型名                  Python类型           说明
Integer               int                  普通整数，一般32位
SmallInteger          int                  取值范围小的整数，一般16位
BigInteger            int/long              不限精度的整数
Float                 float                 浮点数
Numeric               decimal.Decimal       普通整数，一般32位
String                str                   变长字符串
Text                  str                   变长字符串，对较长或不限长度的字符串做了优化
Unicode               unicode         
Unicode Text          unicode
Boolean               bool                  布尔
Date                  datetime.data         时间
Time                  datetime.datetime     日期和时间
LargeBinary           str                   二进制文件

2） 常用的SQLALchemy列选项

列选项              说明
primary_key        如果为True,代表表的主键
unique             如果为True,代表这列不允许出现重复值
index              如果为True,为这列创建索引，提高查询效率
nullable           如果为True,允许有空值，如果为False，不允许有空值
default            为这列定义默认值

3、 模型关系映射（一对一）

-   一对一在数据库中的设置
   关联两张表中的任意一张表：  1） 增量外键，引用另一张表主键  2） 并且要实时唯一约束
-   在ORM中实现
    1） 在任意一张表中增加外键和唯一约束
        外键列名 = db.Column(db.Integer, db.ForeignKey(主表.主键),unique=True)
    2） 在另一个实体类中增加关联属性和反向引用关系属性
        属性名 = db.relationship('关联的实体类名'，backref='反向引用关系属性名'，uselist=False)
    uselist: 设置为False， 表示关联属性是一个标量而非一个列表
- 示例 
```
 class Strudent(db.Model):
    __tablename__ = "tb_student"
    id = db.Column(db.Integer, primary_key=True, comment="主键ID")
    name = db.Column(db.String(250), comment="姓名")
    age = db.Column(db.Integer, comment="年龄")

    # 关联属性，是SQLALchemy提供给开发者快速引用外键模型的一个对象属性，不存在mysql中
    # backref反向引用，类似django的related，通过外键模型查询主模型数据时的惯量属性
    info = db.relationship('StrudentInfo', backref='own', uselist=False)

    def __repr__(self):
        return self.name


class StudentInfo(db.Model):
    __tablename__ = "tb_student_info"
    id = db.Column(db.Integer, primary_key=True, comment="主键ID")
    # 外键 -在另一模型中添加外键
    sid = db.Column(db.Integer, db.ForeignKey(Strudent.id), comment="学生ID")
    address = db.Column(db.String(250), nullable=True, comment="家庭住址")
    mobile = db.Column(db.String(15), unique=True, comment="联系电话")

    def __repr__(self):
        return self.own.name
class Config:
    DENUG = True
    JSON_AS_ASCII = False
    SQLALCHEMY_DATABASE_URL = "mysql://root:123456@localhost:3306/flask"
    SQLALCHEMY_TRACK_MODIFICATIONS = True
    SQLALCHEMY_ECHO = True


if __name__ == "__name__":
    # 创建当前应用中声明的所有模型类对应的数据表，db.drop_all()是删除表
    app.config.from_object(Config)
    db = SQLAlchemy(app)
    db.init_app(app) --- 初始化

```

4、 模型关系映射（一对多）

原则

 在“多”的实体中增加外键关系
 在“一”的试题中增加关联属性和反向引用关系属性
在 “多” 的实体中
 外键列名 = db.Co(db.Integer, db.ForeignKey(‘主表.主键‘)
 属性名=db.relationhip('多的实体类名',backref='反向引用的关系属性名',lazy='dynamic')
在“一”的实体中
增加关联属性和反向引用关系属性
属性名= db.relationship('多的实体类名'，backref='反向引用关系属性名',lazy=dynamic)
lazy --- 指定如何加载相关记录
      select : 首次访问时加载相关关联数据
      immediate --- 元对象加载后立马加载关联数据（使用连接）
      subquery --- 效果同上，使用子查询
      noload --- 永不加载
      dynamic ---- 不加载记录， 但提供加载记录的查询
如： Course与Teacher是存在一对多的关系
     course = Course.query.filter_by(id=1).first
     course.teachers.all()\course.teachers.first(),course.filter_by().all()

获取数据

- 通过“一”对象找“多” 的关联对象们
  course = Course.query.filter_by(id=1).first()
  teachers = course.teachers.all()
- 通过’多‘对象找’一‘的关联对象（通过反向引用关系属性 查找） 
  tea= Teacher.query.filter_by(id=1).first()
  course = tea.course

5、 模型关系映射（多对多）

from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['DEBUG'] = True
app.config["ENV"] = "development"
# 连接数据库
# app.config['SQLALCHEMY_DATABASE__URL'] = "mysql://用户名:密码@数据库服务地址:端口号/数据库"
SQLALCHEMY_DATABASE_URL = "mysql://root:123456@localhost:3306/flask"
app.config['SQLALCHEMY_DATABASE_URL'] = SQLALCHEMY_DATABASE_URL

# 实例化ORM框架的操作对象，后续数据库操作，都要基于操作对象来完成
db = SQLAlchemy(app)

""" 以db.Table关系表来确定模型之间的多对多关联"""
achievement = db.Table(
    'tb_achievement',
    db.Column('student_id', db.Integer, db.ForeignKey('tb_student.id')),
    db.Column('course_id', db.Integer, db.ForeignKey('tb_course.id')),
    # 这里的表信息，在主键模型中，仅仅表达的是关联关系，所以中间表的字段，无法通过主模型来获取
    db.Column('score', db.DECIMAL(5, 2), comment='成绩'),
    db.Column('create_time', db.DateTime, comment='考试时间')

)


class Strudent(db.Model):
    __tablename__ = "tb_student"
    id = db.Column(db.Integer, primary_key=True, comment="主键ID")
    name = db.Column(db.String(250), comment="姓名")
    age = db.Column(db.Integer, comment="年龄")

    # 关联属性，是SQLALchemy提供给开发者快速引用外键模型的一个对象属性，不存在mysql中
    # backref反向引用，类似django的related，通过外键模型查询主模型数据时的惯量属性
    info = db.relationship('StrudentInfo', backref='own', uselist=False)

    def __repr__(self):
        return self.name


class Teacher(db.Model):
    __tablename__ = "tb_teacher"
    id = db.Column(db.Integer, primary_key=True, comment="主键ID")
    name = db.Column(db.String(250), comment="姓名")
    sex = db.Column(db.Boolean, default=False, comment="性别")
    age = db.Column(db.Integer, comment="年龄")
    option = db.Column(db.Enum('老师', '助教', '班主任'), default='老师', comment='教职')
    # 关联属性，是SQLALchemy提供给开发者快速引用外键模型的一个对象属性，不存在mysql中
    # backref反向引用，类似django的related，通过外键模型查询主模型数据时的惯量属性
    course_list = db.relationship('Course', uselist=True, backref='teacher', lazy='subquery')

    def __repr__(self):
        return self.name


class Course(db.Model):
    __tablename__ = "tb_course"
    id = db.Column(db.Integer, primary_key=True, comment="主键ID")
    # 外键 -在另一模型中添加外键
    name = db.Column(db.String(250), unique=True, comment="课程名称")
    price = db.Column(db.Numeric(6, 2))
    teacher_id = db.Column(db.Integer, db.ForeignKey(Teacher.id), comment="教职人员id")
    student_list = db.relationship('Strudent', secondary=achievement, backref='course_list', lazy='dynamic')

    def __repr__(self):
        return self.own.name


class Config:
    DENUG = True
    JSON_AS_ASCII = False
    SQLALCHEMY_DATABASE_URL = "mysql://root:123456@localhost:3306/flask"
    SQLALCHEMY_TRACK_MODIFICATIONS = True
    SQLALCHEMY_ECHO = True


if __name__ == "__name__":
    # 创建当前应用中声明的所有模型类对应的数据表，db.drop_all()是删除表
    app.config.from_object(Config)
    db = SQLAlchemy(app)
    db.init_app(app)
雨停江南Lujier
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
flask中ORM的使用
weixin_72247804的博客
09-27 1866
flask中ORM的使用
flask框架使用orm连接数据库的方法示例
09-20
主要介绍了flask框架使用orm连接数据库的方法,结合实例形式分析了flask框架使用flask_sqlalchemy包进行mysql数据库连接操作的具体步骤与相关实现技巧,需要的朋友可以参考下
python ORM（Flask-SQLAlchemy 介绍)
Lxy_Python的博客
11-21 895
ORM 对象关系映射（Object Relational Mapping，简称ORM） 一个 ORM , 它的一端连着 Database, 一端连着 Python DataObject 对象。有了 ORM，可以通过对 Python 对象的操作，实现对数据库的操作，不需要直接写 SQL 语句。ORM 会自动将 Python 代码转换成对应的 SQL 语句。其余的操作，包括数据检查，生成 SQL 语...
flask的ORM操作
weixin_44777680的博客
10-30 3754
flask的ORM操作 目录flask的ORM操作ORMFlask-SQLAlchemy扩展数据模型模型之间的关联表管理操作数据新增修改删除事务查询Flask-SQLAlchemy提供了分页方法四、文件的迁移 ORM ORM（Object Relational Mapping）中文翻译过来叫作对象关系映射，它把一个类映射成数据库里的一张表而属性映射成数据库表的列，每一个实例对象对应数据库表里的一行数据。通过它我们可以直接使用面向对象的方式来编写程序而不再直接书写原生的SQL语句，而且大部分ORM框架支持多种
python flask配置数据库并进行orm操作 flask_sqlalchemy
最新发布
Zwq的博客
06-17 1025
Flask-SQLAlchemy是Flask框架中的一个扩展，它简化了在Flask应用中使用SQLAlchemy的操作。通过orm更方便的对数据库进行操作。
Python–Flask的ORM依赖安装和使用
01-20
Python–Flask的ORM依赖安装和使用 博客说明 文章所涉及的资料来自互联网整理和个人总结，意在于个人学习和经验汇总，如有什么地方侵权，请联系本人删除，谢谢！ 安装依赖 Flask-SQLAlchemy 扩展 pip3 install flask-sqlalchemy mysqlclient扩展 pip3 install mysqlclient 测试使用 flask-sqlalchemy文档网址 https://flask-sqlalchemy.palletsprojects.com/en/2.x/quickstart/#a-minimal-application from
【Flask】创建ORM映射以及参数解释
python全栈
02-10 1471
创建一个类，一个类对应了一个数据库中的一张表，类的数据属性对应了表中的字段名，这个类称为映射类。 一、主动创建映射 使用Declarative系统映射的类是根据基类定义的，换句话说每个映射类需要继承这个基类。我们使用declarative_base() 函数可以创建这个基类， 如下所示： 第一步：创建基类（所有ORM中的O，对象模型的超级父类） from sqlalchemy.ext.declarative import declarative_base #创建数据库引擎 engine=create_e
Python Flask框架 -- ORM模型与表的映射
lpx666168的博客
03-23 871
Python Flask框架 -- ORM模型与表的映射 代码示例
Flask 的 ORM 模型 - 概述
weixin_42576837的博客
08-21 1233
flask SQLALCHEMY CRUD，增删改查
flask的orm框架SQLAlchemy查询实现解析
09-18
在Python的Web开发框架Flask中，SQLAlchemy是常用的ORM（Object-Relational Mapping）工具，它使得开发者可以通过面向对象的方式来处理数据库操作。本篇文章主要探讨如何使用SQLAlchemy在Flask应用中实现查询功能。 ...
阿里云部署Ubuntu 1.4 Flask + WSGI + Nginx 详解
09-30
在本文中，我们将探讨如何在阿里云Ubuntu 1.4服务器上部署Flask应用程序，利用uWSGI作为应用服务器，以及Nginx作为反向代理服务器。这个组合提供了高效且稳定的生产环境。 首先，确保你已经通过SSH连接到阿里云...
flask-数据库模型创建和导入
12-21
在Flask框架中，数据库操作通常借助于SQLAlchemy库进行，这是一个强大的ORM（对象关系映射）工具，它允许开发者以Python对象的方式处理数据库操作。接下来我们将深入探讨如何在Flask应用中创建数据库模型和导入。 1...
【Flask】ORM高级操作之排序和分页操作
python全栈
02-25 1033
一、数据准备 from sqlalchemy import create_engine, Column, Integer, ForeignKey, String, TEXT, Boolean, DATE, DECIMAL from sqlalchemy import Table from sqlalchemy.ext.declarative import declarative_base from datetime import date from sqlalchemy.orm import session
【Flask】ORM高级操作之懒加载
python全栈
03-13 678
在一对多，或者多对多关系的时候，如果想要获取多的一方这一部分的数据的时候，往往能通过一个属性就可以全部获取了。 如有一个部门，想要这个部门下的所有员工，通过user.emp就可以获取所有的。 但有时候我们不想获取所有的数据，如只想获取范围更小的数据，那么这时候我们可以给relationship方法添加属性lazy=‘dynamic’，以后通过user.emp获取到的就不是一个列表，而是一个AppenderQuery对象了。这样就可以对这个对象再进行一层过滤和排序等操作。 一、数据准备：配置数据库、创建数据库
FLASK核心操作之ORM
爬山的小明
01-19 1310
ORM 一、概要 1、说明 ORM，即Object-Relational Mapping（对象关系映射），它的作用是在关系型数据库和业务实体对象之间作一个映射，这样，我们在具体的操作业务对象的时候，就不需要再去和复杂的SQL语句打交道，只需简单的操作对象的属性和方法, 2、核心模块SQLAlchemy ORM 和SQLAlchemy Core Core是一种构建在表达式语言之上的一种API，...
flask_sqlalchemy
qq_38323690的博客
04-14 207
Flask-SQLAlchemy ORM ORM --> Object-Relation Mapping 对象-关系映射 主要实现模型对象到关系数据库数据的映射 ORM 一般解释 Flask 创建对象，调用 flask-sqlalchemy db.session.add(对象) ORM db.session.commit() ...
Python Flask框架 -- ORM模型外键与表关系
lpx666168的博客
03-24 1300
Python Flask框架 -- ORM模型外键与表关系 代码示例
Python全栈：Flask的ORM使用
超级大洋葱的博客
02-02 5476
文章目录1 ORM是什么2 flask-sqlalchemy介绍及安装、配置安装fask-sqlalchemy配置创建数据库3 设计数据库模型并创建表4 使用OR M插入、修改、删除数据新增/修改数据5 使用ORM进行数据查询与展示 1 ORM是什么 ORM（Object Relational Mapping），对象关系映射 ORM的重要特性： 面向对象的编程思想，方便扩充 少写（几乎不写）SQL，提升开发效率 支持多种类型的数据库，方便切换 ORM技术成熟，能解决绝大部分问题 2 flask-sq
Flask框架种使用ORM模型对MySQL数据库的管理
qq_45863127的博客
08-23 345
通过flask连接MySQL数据库后，使用ORM模型对数据库管理ORM模型的优点：使用 ORM 做数据库的开发可以有效的减少重复SQL语句的概率，写出来的模型也更加直观、清晰。支持多个关系数据库引擎，包括流行的 MySQL 、 PostgreSQL 和 SQLite。可以非常轻松的切换数据库。
flask的ORM模型是什么
05-28
Flask本身是一个轻量级的Web框架，它并没有自带ORM模型。但是，Flask与SQLAlchemy这个Python的ORM库非常搭配，SQLAlchemy为Flask提供了一个很好的ORM支持。 SQLAlchemy是一个功能强大的ORM库，它支持多种关系型数据库，包括MySQL、PostgreSQL、SQLite等。使用SQLAlchemy，我们可以通过Python代码来操作数据库，而不用直接写SQL语句。在Flask中，我们可以通过将SQLAlchemy对象实例化并绑定到应用程序上来使用ORM模型，例如： ```python from flask import Flask from flask_sqlalchemy import SQLAlchemy app = Flask(__name__) app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://username:password@localhost/dbname' app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False db = SQLAlchemy(app) ``` 在上面的代码中，我们首先实例化了一个Flask对象，然后通过`flask_sqlalchemy`模块中的`SQLAlchemy`类来创建一个`db`对象，并将其绑定到Flask应用程序对象上。在实际开发中，我们可以通过继承SQLAlchemy的`Model`类来定义模型类，例如： ```python class User(db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(50), nullable=False) email = db.Column(db.String(120), unique=True, nullable=False) ``` 在上面的代码中，我们定义了一个名为`User`的模型类，并通过`db.Column()`方法定义了三个属性：`id`、`name`和`email`。通过这些定义，我们可以通过Python代码来操作数据库，例如添加、删除、修改和查询等操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值