【Tortoise-ORM】 高级特性与实战

卜及中2025-01-20 17:38

文章目录

  • [6. 迁移与数据库管理](#6. 迁移与数据库管理)
    • [使用 `Tortoise-ORM` 与 `aerich` 进行数据库迁移管理](#使用 Tortoise-ORM 与 aerich 进行数据库迁移管理)
      • [安装 `aerich`](#安装 aerich)
      • [配置 `aerich`](#配置 aerich)
      • 创建和应用数据库迁移
        • [1. 创建迁移](#1. 创建迁移)
        • [2. 查看迁移历史](#2. 查看迁移历史)
        • [3. 应用迁移](#3. 应用迁移)
        • [4. 回滚迁移](#4. 回滚迁移)
      • 迁移常见问题
  • [7. 事务管理](#7. 事务管理)
    • [使用 `Tortoise` 提供的事务管理](#使用 Tortoise 提供的事务管理)
      • [1. 开始事务：](#1. 开始事务：)
      • [2. 提交事务：](#2. 提交事务：)
      • [3. 回滚事务：](#3. 回滚事务：)
      • [4. 手动控制提交和回滚](#4. 手动控制提交和回滚)
    • 事务管理的最佳实践
  • [8. 性能优化](#8. 性能优化)
  • [9. 与其他框架的集成](#9. 与其他框架的集成)
    • [1. 与 FastAPI 集成](#1. 与 FastAPI 集成)
      • 安装依赖
      • [配置 Tortoise-ORM 和 FastAPI](#配置 Tortoise-ORM 和 FastAPI)
      • [在 FastAPI 路由中使用数据库操作](#在 FastAPI 路由中使用数据库操作)
    • [2. 与 Sanic 集成](#2. 与 Sanic 集成)
      • 安装依赖
      • [配置 Tortoise-ORM 和 Sanic](#配置 Tortoise-ORM 和 Sanic)
      • [在 Sanic 路由中使用数据库操作](#在 Sanic 路由中使用数据库操作)
    • [3. 在 Web 框架中使用 Tortoise-ORM](#3. 在 Web 框架中使用 Tortoise-ORM)
  • [10. 项目实战](#10. 项目实战)
    • [1. 实际项目概述](#1. 实际项目概述)
    • [2. 设计数据库模型](#2. 设计数据库模型)
    • [3. **在 FastAPI 中集成数据库操作**](#3. 在 FastAPI 中集成数据库操作)
      • 安装依赖
      • [配置 FastAPI 和 Tortoise-ORM](#配置 FastAPI 和 Tortoise-ORM)
      • [CRUD 操作](#CRUD 操作)
        • [1. 创建任务](#1. 创建任务)
        • [2. 获取任务列表](#2. 获取任务列表)
        • [3. 获取单个任务](#3. 获取单个任务)
        • [4. 更新任务状态](#4. 更新任务状态)
        • [5. 删除任务](#5. 删除任务)
    • [4. 测试和运行](#4. 测试和运行)
    • [5. 总结](#5. 总结)

6. 迁移与数据库管理

在开发过程中，数据库模式的变更是不可避免的，例如添加字段、修改数据表结构或删除数据表等。为了在这些变更中保持数据的完整性和一致性，我们通常会使用数据库迁移工具来自动化这些操作。Tortoise-ORM 配合 aerich 工具实现了数据库迁移管理，下面将详细介绍如何使用它们进行迁移操作。

使用 Tortoise-ORM 与 aerich 进行数据库迁移管理

aerich 是一个轻量级的数据库迁移工具，它专门为 Tortoise-ORM 设计，支持自动化生成、应用和回滚数据库迁移。它能帮助在数据库和模型定义发生变化时，自动生成迁移脚本，并将这些脚本应用到数据库中。

安装 aerich

首先，需要安装 aerich 工具，它是一个单独的工具包，可以通过 pip 安装：

bash 复制代码 
pip install aerich

配置 aerich

在项目中使用 aerich 时，需要进行一些基本配置。通常需要在项目根目录下创建一个配置文件，指定数据库连接信息及模型路径。aerich 依赖于 Tortoise 的配置，因此需要先配置好 Tortoise-ORM。

  1. 创建配置文件：

    通常将数据库配置放在 config.py 中，并在 aerich 中引用。配置文件内容如下：

    python 复制代码 
    # config.py
TORTOISE_ORM = {
    "connections": {
        "default": "sqlite://db.sqlite3",  # 使用 SQLite 作为数据库
    },
    "apps": {
        "models": {
            "models": ["your_project.models"],  # 模型模块路径
            "default_connection": "default",
        },
    },
}

  2. 初始化 aerich：

    在项目根目录下初始化 aerich，以便生成数据库迁移配置文件：

    bash 复制代码 
    aerich init -t config.TORTOISE_ORM

    这条命令会在项目目录下创建一个 migrations 文件夹，并且初始化相关配置。

创建和应用数据库迁移

一旦 aerich 配置完成，就可以开始创建和应用数据库迁移了。下面是常见的迁移操作。

1. 创建迁移

每当修改了模型（如新增、删除或修改字段），需要生成一个新的迁移文件。可以使用 aerich 提供的命令来创建迁移文件：

bash 复制代码 
aerich migrate --autogenerate

这条命令会扫描模型定义，自动生成迁移脚本，保存到 migrations 文件夹中。如果没有修改模型或模型没有变动，aerich 会提示没有需要迁移的内容。

2. 查看迁移历史

可以使用以下命令查看当前迁移的状态：

bash 复制代码 
aerich history

该命令会显示所有已经应用过的迁移版本。

3. 应用迁移

生成迁移文件后，接下来需要将迁移应用到数据库中。使用以下命令将迁移应用到数据库：

bash 复制代码 
aerich upgrade

该命令会将所有未应用的迁移脚本应用到数据库中，更新数据库结构。

4. 回滚迁移

如果需要回滚某个迁移，或者遇到数据库迁移失败的情况，可以使用 aerich 的回滚命令。假设想回滚到上一个迁移版本，可以使用以下命令：

bash 复制代码 
aerich downgrade

如果希望回滚到特定的迁移版本，可以指定迁移版本号：

bash 复制代码 
aerich downgrade <version>

迁移常见问题

  1. 数据库表未更新：

    如果修改了模型但是数据库表没有更新，确保迁移文件已成功生成并应用。可以通过 aerich history 查看迁移记录，检查当前数据库版本是否与迁移文件匹配。

  2. 字段类型变化：

    如果修改了字段的类型，aerich 会根据情况生成相应的 SQL 语句进行更改。在某些情况下，数据库可能不支持某些字段类型的修改，这时可能需要手动干预。

  3. 数据库连接问题：

    如果在配置数据库连接时遇到问题，确保连接字符串正确，并且相关的数据库服务（如 MySQL、PostgreSQL 等）已启动并可访问。

7. 事务管理

在数据库操作中，事务是为了保证数据的一致性和可靠性而提出的概念。一个事务是指一系列数据库操作，它们要么全部成功，要么全部失败。事务保证了即使在并发或系统崩溃的情况下，数据的完整性和一致性也能得到维护。

Tortoise-ORM 提供了对事务的支持，帮助我们在数据库操作中确保数据的一致性。通过事务管理，可以确保多个操作要么全部成功，要么在发生错误时回滚到事务开始时的状态。

使用 Tortoise 提供的事务管理

在 Tortoise-ORM 中，事务的管理通常使用 Tortoise.transaction() 方法来进行，这个方法会为自动处理事务的开始、提交和回滚。

1. 开始事务：

事务通常由 begin() 操作开始。在 Tortoise 中，Tortoise.transaction() 本身会在传入的代码块开始时自动开启一个事务，并在代码块执行结束时提交或回滚事务。

可以通过 Tortoise.transaction() 来显式地开始一个事务：

python 复制代码 
from tortoise import Tortoise

async def example_transaction():
    async with Tortoise.transaction():
        # 执行一系列数据库操作
        pass

2. 提交事务：

事务提交通过 commit() 来完成，在 Tortoise 中，commit() 会自动在事务块完成时提交，不需要显式地调用。在代码块执行结束时，如果没有发生异常，事务会自动提交：

python 复制代码 
from tortoise import Tortoise
from myapp.models import User

async def create_user():
    async with Tortoise.transaction():
        # 事务开始
        user = await User.create(username="new_user", email="newuser@example.com")
        # 如果没有异常，事务会自动提交

在这个例子中，User.create() 操作会被包括在事务内。如果没有发生异常，事务会在代码块结束时提交，确保数据成功保存。

3. 回滚事务：

如果在事务过程中发生了异常，Tortoise 会自动执行回滚操作，确保数据库不会处于半成功状态。回滚操作通过 rollback() 完成，通常我们不需要显式地调用它，Tortoise 会在异常发生时自动回滚事务。

例如：

python 复制代码 
from tortoise import Tortoise
from myapp.models import User

async def create_user_with_error_handling():
    try:
        async with Tortoise.transaction():
            # 事务开始
            user1 = await User.create(username="user1", email="user1@example.com")
            user2 = await User.create(username="user2", email="user2@example.com")
            # 模拟错误
            raise ValueError("Something went wrong!")
            user3 = await User.create(username="user3", email="user3@example.com")
    except Exception as e:
        # 如果发生异常，事务会自动回滚
        print(f"Error occurred: {e}")

在此例中，如果 ValueError 被抛出，那么事务会自动回滚。也就是说，user1 和 user2 的数据不会被保存到数据库中，数据库的状态会回到事务开始时的状态。

4. 手动控制提交和回滚

虽然在大多数情况下，Tortoise.transaction() 可以自动处理提交和回滚，但也可以通过手动控制事务的提交和回滚来精细管理事务。

python 复制代码 
from tortoise import Tortoise

async def manual_transaction():
    async with Tortoise.transaction() as transaction:
        try:
            # 执行操作
            pass
            await transaction.commit()  # 手动提交事务
        except Exception as e:
            await transaction.rollback()  # 手动回滚事务
            print(f"Error occurred: {e}")

在这个例子中，transaction.commit() 和 transaction.rollback() 手动控制事务的提交和回滚。

事务管理的最佳实践

  • 尽量避免长时间持有事务：

    如果事务在执行时被阻塞，它将会影响数据库的性能和其他事务的执行。长时间的事务也容易出现锁表的问题，因此要确保事务尽量精简、快速执行。

  • 捕获并处理异常：

    在使用事务时，要确保代码中出现的任何异常都能被捕获和正确处理，以便触发回滚操作，避免数据不一致。

  • 使用事务来处理多个数据库操作：

    如果操作涉及多个数据库表格或多个插入/更新操作，确保将它们放在同一个事务中执行，这样可以保证它们的原子性，要么全部成功，要么全部失败。

8. 性能优化

在开发数据库应用时，性能往往是一个至关重要的考虑因素。随着数据量的增长，如何优化查询效率、减少数据库访问次数以及提高整体响应速度变得尤为重要。Tortoise-ORM 提供了一些工具和方法，帮助开发者在不同场景下进行性能优化。

1. 通过索引优化查询性能

索引是数据库中一种常用的优化技术，能够显著提高查询操作的速度。通过为数据库表中的某些字段创建索引，数据库可以快速定位到相关的数据行，而无需扫描整个表。索引通常用于频繁作为查询条件的字段。

在 Tortoise-ORM 中，可以通过 Meta 类中的 indexes 参数为模型字段创建索引。例如：

python 复制代码 
from tortoise import models
from tortoise import fields

class User(models.Model):
    username = fields.CharField(max_length=255, unique=True)
    email = fields.CharField(max_length=255, unique=True)
    age = fields.IntField()

    class Meta:
        indexes = [
            ('username',),  # 创建复合索引
            ('email',),     # 创建单字段索引
        ]

在这个例子中，User 模型中的 username 和 email 字段被索引，以提高基于这两个字段的查询性能。

选择索引时的注意事项：

  • 字段选择 ：为经常用于查询的字段（如 WHERE 子句中的条件字段）创建索引。避免为所有字段都创建索引，因为索引会增加数据插入和更新的成本。
  • 复合索引 ：当查询常常使用多个字段作为查询条件时，可以考虑创建复合索引。例如，如果查询经常是 WHERE username = ? AND age = ?，那么可以创建一个复合索引 (username, age)。

2. 批量插入优化

对于需要插入大量数据的场景，逐条插入可能会导致性能瓶颈。Tortoise-ORM 提供了批量插入的功能，可以一次性插入多条记录，从而减少与数据库的交互次数，提高性能。

Tortoise-ORM 提供了 bulk_create() 方法来执行批量插入。例如：

python 复制代码 
from myapp.models import User

async def bulk_insert_users():
    users = [
        User(username="user1", email="user1@example.com", age=25),
        User(username="user2", email="user2@example.com", age=30),
        User(username="user3", email="user3@example.com", age=22),
    ]
    await User.bulk_create(users)

在这个例子中，bulk_create() 方法将多个 User 实例一次性插入到数据库中，比逐条插入更加高效。

批量插入的最佳实践：

  • 合理分批：对于大量数据的批量插入，可以根据数据库性能和操作系统的限制将数据分批插入。例如，将 1000 条数据分成 100 条一批进行插入，以防止因为一次性插入过多数据导致数据库压力过大。
  • 关闭信号 ：在批量插入时，可以关闭信号（如 pre_save 和 post_save 信号）来提高性能，避免触发不必要的操作。

3. 使用缓存减少数据库访问

缓存是一种常见的性能优化手段，通过缓存常用数据，可以减少数据库的访问次数，提高应用程序的响应速度。在 Tortoise-ORM 中，虽然没有直接内置的缓存机制，但可以使用外部的缓存工具（如 Redis 或 Memcached）与 Tortoise-ORM 配合使用。

结合 Redis 缓存优化查询：

假设使用 Redis 作为缓存服务器，在查询数据时，首先检查缓存中是否存在数据，如果存在则从缓存中读取，如果不存在则从数据库中读取并将结果缓存起来。

python 复制代码 
import redis
from tortoise import Tortoise
from myapp.models import User

# 配置 Redis 客户端
cache = redis.StrictRedis(host='localhost', port=6379, db=0)

async def get_user_from_cache(user_id):
    # 首先检查缓存
    cached_user = cache.get(f"user:{user_id}")
    if cached_user:
        return cached_user  # 返回缓存中的数据

    # 如果缓存中没有数据，则查询数据库
    user = await User.get(id=user_id)
    
    # 将查询结果存入缓存，缓存 10 分钟
    cache.setex(f"user:{user_id}", 600, user)
    return user

在这个例子中，首先尝试从 Redis 缓存中获取用户数据，如果缓存中没有找到，才从数据库中查询并将结果存入缓存。这样可以有效减少数据库的查询负担。

缓存使用的最佳实践：

  • 缓存过期时间：为缓存设置合理的过期时间，确保缓存中的数据不会过期太久，避免读取到过时的数据。
  • 缓存击穿与雪崩：当多个请求同时访问相同的缓存数据时，可能会导致缓存击穿问题，解决方案是使用互斥锁或预加载数据。在高并发场景下，多个缓存过期同时发生可能会导致缓存雪崩，解决方法是为缓存的过期时间设置随机性，避免全部过期。

4. 查询优化

除了索引和缓存外，查询的优化也是提升性能的关键。通过合理的查询条件、避免查询不必要的字段、以及限制返回的结果数，都可以显著提高数据库查询的性能。

优化查询的技巧：

  • 选择性查询 ：避免使用 all() 返回所有记录，尽量使用 filter() 限制查询条件。
  • 限制返回字段 ：通过 only() 或 values() 方法选择只需要的字段，避免加载不必要的数据。
  • 使用分页：当查询数据量较大时，使用分页查询而不是一次性加载所有数据。
python 复制代码 
# 只选择需要的字段
users = await User.all().only('username', 'email')

# 分页查询
page = 1
page_size = 10
users = await User.all().limit(page_size).offset((page - 1) * page_size)

通过这些查询优化技巧，可以减少查询的计算量和返回的数据量，从而提高查询的效率。

9. 与其他框架的集成

Tortoise-ORM 作为一个异步 ORM 框架，非常适合与异步 Web 框架如 FastAPI 或 Sanic 集成。在现代的 Web 开发中，异步框架能够提升应用的性能，特别是在处理高并发请求时。Tortoise-ORM 提供了与这些框架的无缝集成方式，使得开发者可以方便地在异步 Web 应用中使用 ORM 来处理数据库操作。

1. 与 FastAPI 集成

FastAPI 是一个快速、高效、现代的 Python Web 框架，特别适用于构建异步 Web 应用。Tortoise-ORM 可以与 FastAPI 很好地集成，使得数据库操作变得简单且高效。

安装依赖

首先，需要安装 Tortoise-ORM 和 FastAPI 以及 ASGI 服务器（如 uvicorn）：

bash 复制代码 
pip install fastapi uvicorn tortoise-orm

配置 Tortoise-ORM 和 FastAPI

接下来，在 FastAPI 应用中配置 Tortoise-ORM。首先需要初始化数据库连接，并在 FastAPI 启动时创建数据库表。

python 复制代码 
from fastapi import FastAPI
from tortoise import Tortoise
from tortoise.contrib.fastapi import register_tortoise

app = FastAPI()

# 数据库配置
DB_URL = 'sqlite://db.sqlite3'

@app.on_event("startup")
async def startup():
    # 初始化数据库连接
    await Tortoise.init(
        db_url=DB_URL,
        modules={"models": ["yourapp.models"]}  # 配置模型
    )
    await Tortoise.generate_schemas()  # 自动创建数据库表

@app.on_event("shutdown")
async def shutdown():
    # 关闭数据库连接
    await Tortoise.close_connections()

# 注册 Tortoise-ORM，使 FastAPI 可以与 Tortoise 配合使用
register_tortoise(app, db_url=DB_URL, modules={"models": ["yourapp.models"]}, generate_schemas=True)

在这个示例中，FastAPI 的 startup 和 shutdown 事件用来初始化和关闭数据库连接。register_tortoise 方法则简化了在 FastAPI 中注册 Tortoise-ORM 的步骤。

在 FastAPI 路由中使用数据库操作

可以在 FastAPI 的路由中直接使用 Tortoise-ORM 进行数据库操作。例如，获取用户列表的接口如下：

python 复制代码 
from fastapi import HTTPException
from yourapp.models import User

@app.get("/users")
async def get_users():
    users = await User.all()  # 使用 Tortoise ORM 查询数据库
    return users

这个接口会查询数据库中的所有用户，并返回结果。

2. 与 Sanic 集成

Sanic 是另一个支持异步请求处理的 Python Web 框架，与 FastAPI 类似，Sanic 也可以与 Tortoise-ORM 很好地集成。以下是如何将 Tortoise-ORM 与 Sanic 集成的步骤。

安装依赖

首先，需要安装 Sanic 和 Tortoise-ORM：

bash 复制代码 
pip install sanic tortoise-orm

配置 Tortoise-ORM 和 Sanic

与 FastAPI 类似，在 Sanic 中使用 Tortoise-ORM 也需要在应用启动时进行初始化，通常使用 Sanic 的 before_server_start 和 after_server_stop 钩子来管理数据库连接。

python 复制代码 
from sanic import Sanic
from tortoise import Tortoise
from tortoise.contrib.sanic import register_tortoise

app = Sanic("myapp")

# 配置数据库连接
DB_URL = 'sqlite://db.sqlite3'

@app.before_server_start
async def startup(app, loop):
    # 初始化 Tortoise-ORM 数据库连接
    await Tortoise.init(
        db_url=DB_URL,
        modules={"models": ["yourapp.models"]}  # 配置模型
    )
    await Tortoise.generate_schemas()  # 自动创建数据库表

@app.after_server_stop
async def shutdown(app, loop):
    # 关闭数据库连接
    await Tortoise.close_connections()

# 注册 Tortoise-ORM
register_tortoise(app, db_url=DB_URL, modules={"models": ["yourapp.models"]}, generate_schemas=True)

@app.route("/users")
async def get_users(request):
    users = await User.all()  # 查询所有用户
    return response.json([user.to_dict() for user in users])

在这个示例中，before_server_start 和 after_server_stop 分别用于初始化和关闭数据库连接。register_tortoise 方法注册了 Tortoise-ORM，使得 Sanic 能够与数据库进行交互。

在 Sanic 路由中使用数据库操作

可以像 FastAPI 中一样，在 Sanic 路由中使用 Tortoise-ORM 执行数据库操作：

python 复制代码 
@app.route("/users")
async def get_users(request):
    users = await User.all()  # 使用 Tortoise ORM 查询数据库
    return response.json([user.to_dict() for user in users])

3. 在 Web 框架中使用 Tortoise-ORM

在任何异步 Web 框架中，使用 Tortoise-ORM 都非常直观。只需要在应用启动时初始化数据库连接，在关闭时清理资源。Tortoise-ORM 的异步支持使得它能够非常高效地处理大量并发请求，适用于需要高性能数据库操作的 Web 应用。

在使用 Tortoise-ORM 时，只需关注数据模型的定义和数据库操作，而不必关心底层的 SQL 查询。这使得开发者能够快速构建可维护且高效的数据库交互层，尤其是在高并发场景下，Tortoise-ORM 的异步特性能够大大提升性能。

10. 项目实战

在本部分中，我们将通过一个实际的项目示例，演示如何将 Tortoise-ORM 应用于实际开发中。通过设计和操作数据库模型，可以更好地理解如何在项目中高效地使用 Tortoise-ORM。

1. 实际项目概述

假设我们正在开发一个简单的任务管理应用，用户可以创建任务、查看任务列表、更新任务状态以及删除任务。我们的任务模型包括任务的标题、描述、状态（待办、进行中、已完成）和创建时间。

我们将通过以下步骤实现：

  1. 设计数据库模型。
  2. 使用 Tortoise-ORM 进行数据库操作。
  3. 在 FastAPI 中应用这些操作，处理前端请求。

2. 设计数据库模型

首先，定义一个 Task 模型来表示任务。我们将使用 Tortoise-ORM 来定义这个模型。

python 复制代码 
from tortoise import fields
from tortoise.models import Model
from datetime import datetime

class Task(Model):
    id = fields.IntField(pk=True)  # 主键
    title = fields.CharField(max_length=255)  # 任务标题
    description = fields.TextField()  # 任务描述
    status = fields.CharField(max_length=50, default="To Do")  # 任务状态
    created_at = fields.DatetimeField(default=datetime.utcnow)  # 创建时间

    class Meta:
        table = "tasks"  # 指定数据库表名

在这个模型中，我们定义了：

  • id：任务的唯一标识，使用整数类型作为主键。
  • title：任务的标题，使用 CharField。
  • description：任务的描述，使用 TextField。
  • status：任务的状态，使用 CharField，并且设置了默认值 To Do。
  • created_at：任务的创建时间，使用 DatetimeField，并设置默认值为当前时间。

3. 在 FastAPI 中集成数据库操作

接下来，在 FastAPI 中使用 Tortoise-ORM 进行任务的增、查、改、删操作。

安装依赖

首先，确保安装了所需的依赖：

bash 复制代码 
pip install fastapi tortoise-orm uvicorn

配置 FastAPI 和 Tortoise-ORM

在 FastAPI 中初始化 Tortoise-ORM，并配置数据库连接。

python 复制代码 
from fastapi import FastAPI, HTTPException
from tortoise import Tortoise
from tortoise.contrib.fastapi import register_tortoise
from tortoise.exceptions import DoesNotExist
from pydantic import BaseModel

app = FastAPI()

DB_URL = 'sqlite://db.sqlite3'

class TaskIn(BaseModel):
    title: str
    description: str
    status: str

class TaskOut(BaseModel):
    id: int
    title: str
    description: str
    status: str
    created_at: datetime

@app.on_event("startup")
async def startup():
    await Tortoise.init(
        db_url=DB_URL,
        modules={"models": ["__main__"]}
    )
    await Tortoise.generate_schemas()

@app.on_event("shutdown")
async def shutdown():
    await Tortoise.close_connections()

register_tortoise(app, db_url=DB_URL, modules={"models": ["__main__"]}, generate_schemas=True)

CRUD 操作

1. 创建任务

我们首先定义一个接口，用于创建新的任务：

python 复制代码 
@app.post("/tasks/", response_model=TaskOut)
async def create_task(task: TaskIn):
    task_obj = await Task.create(**task.dict())
    return await TaskOut.from_tortoise_orm(task_obj)

这里使用了 TaskIn 和 TaskOut 模型：

  • TaskIn 用于接收来自客户端的任务数据。
  • TaskOut 用于响应客户端，返回任务的完整数据。
2. 获取任务列表

接下来，我们定义一个接口来获取任务列表：

python 复制代码 
@app.get("/tasks/", response_model=List[TaskOut])
async def get_tasks():
    tasks = await Task.all()
    return await TaskOut.from_queryset(tasks)

这个接口会查询所有任务并返回，使用 from_queryset 方法将查询结果转化为 Pydantic 模型。

3. 获取单个任务

通过任务的 id 获取任务的详细信息：

python 复制代码 
@app.get("/tasks/{task_id}", response_model=TaskOut)
async def get_task(task_id: int):
    try:
        task = await Task.get(id=task_id)
        return await TaskOut.from_tortoise_orm(task)
    except DoesNotExist:
        raise HTTPException(status_code=404, detail="Task not found")

这个接口会根据任务的 id 查询任务，如果没有找到，则返回 404 错误。

4. 更新任务状态

定义一个接口来更新任务的状态：

python 复制代码 
@app.put("/tasks/{task_id}", response_model=TaskOut)
async def update_task(task_id: int, task: TaskIn):
    try:
        task_obj = await Task.get(id=task_id)
        task_obj.title = task.title
        task_obj.description = task.description
        task_obj.status = task.status
        await task_obj.save()
        return await TaskOut.from_tortoise_orm(task_obj)
    except DoesNotExist:
        raise HTTPException(status_code=404, detail="Task not found")

该接口允许用户更新任务的标题、描述和状态。

5. 删除任务

删除任务的接口：

python 复制代码 
@app.delete("/tasks/{task_id}")
async def delete_task(task_id: int):
    try:
        task = await Task.get(id=task_id)
        await task.delete()
        return {"message": "Task deleted successfully"}
    except DoesNotExist:
        raise HTTPException(status_code=404, detail="Task not found")

该接口根据任务的 id 删除任务。

4. 测试和运行

当所有路由定义完成后，可以通过以下命令运行 FastAPI 应用：

bash 复制代码 
uvicorn main:app --reload

这样，FastAPI 服务将启动并监听请求，可以通过 http://localhost:8000 来访问这些 API 路由，测试增、查、改、删等数据库操作。

5. 总结

通过这个实战项目，我们学会了如何在实际应用中应用 Tortoise-ORM，设计数据库模型，并将这些操作与 FastAPI 集成。我们能够使用 Tortoise-ORM 提供的异步查询功能，快速处理数据库操作，构建高效的 Web 应用。

在实际项目中，Tortoise-ORM 的易用性和异步特性使其成为一个理想的选择，尤其适用于需要高并发数据库操作的应用。通过合理的数据库模型设计和优化查询操作，可以有效提升应用的性能和可维护性。

相关推荐
道剑剑非道11 分钟前
QT开发技术 【基于TinyXml2的对类进行序列化和反序列化】一
数据库·qt·算法
一只鹿鹿鹿41 分钟前
IT程序设计文档，软件需求设计文档，详细设计模板（Word原件）
开发语言·数据库·安全·需求分析·设计规范
雷学习1 小时前
MySQL - 主从同步
数据库·mysql
小白学大数据1 小时前
Django多线程爬虫：突破数据抓取瓶颈
数据库·爬虫·scrapy·数据分析·django
m0_748257461 小时前
MySQL 篇 - Java 连接 MySQL 数据库并实现数据交互
java·数据库·mysql
进击的CJR1 小时前
PG vs MySQL mvcc机制实现的异同
数据库·mysql
落霞与孤鹭齐飞。。1 小时前
SSM宠物论坛设计系统
java·服务器·数据库·mysql·毕业设计·课程设计
TechNomad1 小时前
Qt开发：QSqlDatabase的常见用法
数据库·qt
老马啸西风1 小时前
数据库高可用方案-04-删除策略
数据库·oracle
wclass-zhengge1 小时前
02内存结构篇（D1_自动内存管理）
java·开发语言·jvm
热门推荐
01xgboost: Why not implement distributed XGBoost on top of spark02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03半导体应用系统一些小知识收集(strip&wafer mapping,EAP&scada)04密码学原理技术-第六章-introduction to pulibc-key cryptography05Dell服务器升级ubuntu 22.04失败解决06优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间07centos7 init.d 和system.d08PyTorch AMP 混合精度中grad_scaler.py的scale函数解析09渗透测试之SQLMAP工具详解 kali自带SQLmap解释 重点sqlmap --tamper 使用方式详解 搞完你就很nice了10leetcode - 1769. Minimum Number of Operations to Move All Balls to Each Box