Tortoise ORM

已于 2024-07-12 23:57:32 修改
阅读量2.5k 收藏 52
点赞数 38
文章标签： fastapi python
于 2024-07-12 23:18:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/D_ASH/article/details/140390651
版权

Tortoise ORM 全面指南：从基础到高级应用

目录

  1. 简介
  2. 安装与配置
  3. 基本用法
  4. 高级特性
  5. 性能优化
  6. 测试策略
  7. 与其他库的集成
  8. 最佳实践
  9. 常见问题及解决方案
  10. 实际应用场景
  11. 与其他 ORM 的比较
  12. 结语

简介

Tortoise ORM 是一个强大的异步 Python ORM，专为现代异步 Web 框架设计。它结合了 Django ORM 的直观性和异步编程的高效性，为开发者提供了一个理想的数据库交互解决方案。

主要特性

  • 完全异步操作
  • 类似 Django 的 API
  • 强类型支持
  • 复杂关系处理
  • 丰富的查询 API
  • 事务支持
  • 多数据库支持（SQLite, PostgreSQL, MySQL）

安装与配置

基本安装

pip install tortoise-orm

数据库特定安装

pip install tortoise-orm[asyncpg]  # PostgreSQL
pip install tortoise-orm[aiomysql]  # MySQL

基本配置

from tortoise import Tortoise, run_async

async def init():
    await Tortoise.init(
        db_url='sqlite://db.sqlite3',
        modules={'models': ['myapp.models']}
    )
    await Tortoise.generate_schemas()

run_async(init())

基本用法

模型定义

from tortoise import Model, fields

class User(Model):
    id = fields.IntField(pk=True)
    username = fields.CharField(max_length=50, unique=True)
    email = fields.CharField(max_length=100, unique=True)
    password = fields.CharField(max_length=128)
    is_active = fields.BooleanField(default=True)
    created_at = fields.DatetimeField(auto_now_add=True)

    def __str__(self):
        return self.username

class Post(Model):
    id = fields.IntField(pk=True)
    title = fields.CharField(max_length=200)
    content = fields.TextField()
    author = fields.ForeignKeyField('models.User', related_name='posts')
    created_at = fields.DatetimeField(auto_now_add=True)
    updated_at = fields.DatetimeField(auto_now=True)

    def __str__(self):
        return self.title

CRUD 操作

# 创建
user = await User.create(username='johndoe', email='john@example.com', password='securepass')

# 读取
user = await User.get(username='johndoe')
all_users = await User.all()

# 更新
await User.filter(id=1).update(is_active=False)

# 删除
await User.filter(id=1).delete()

高级特性

复杂查询

from tortoise.expressions import Q

# 组合查询
active_users = await User.filter(
    Q(is_active=True) & (Q(username__contains='john') | Q(email__contains='john'))
)

# 排除
non_admin_users = await User.exclude(username='admin')

# 排序
sorted_users = await User.all().order_by('-created_at', 'username')

# 限制结果
recent_users = await User.all().order_by('-created_at').limit(5)

关系查询

# 预加载关联对象
users_with_posts = await User.all().prefetch_related('posts')

# 反向关系查询
user = await User.get(id=1)
user_posts = await user.posts.all()

# 多对多关系
class Tag(Model):
    name = fields.CharField(max_length=50)
    posts = fields.ManyToManyField('models.Post', related_name='tags')

# 添加多对多关系
post = await Post.get(id=1)
tag = await Tag.get(id=1)
await post.tags.add(tag)

# 查询多对多关系
posts_with_tag = await Post.filter(tags__id=1)

聚合和注解

from tortoise.functions import Count, Avg, Sum

# 计算每个用户的帖子数
users_post_count = await User.annotate(post_count=Count('posts'))

# 获取帖子数量最多的用户
most_active_user = await User.annotate(post_count=Count('posts')).order_by('-post_count').first()

# 计算平均帖子长度
avg_post_length = await Post.annotate(avg_length=Avg('content__length')).values('avg_length')

原生 SQL

# 执行原生 SQL 查询
users = await User.raw("SELECT * FROM user WHERE is_active = 1")

# 执行原生 SQL 命令
await Tortoise.get_connection('default').execute_query("UPDATE user SET is_active = 1 WHERE id = 1")

性能优化

批量操作

# 批量创建
users_data = [
    {"username": f"user{i}", "email": f"user{i}@example.com"}
    for i in range(100)
]
await User.bulk_create([User(**data) for data in users_data])

# 批量更新
await User.filter(is_active=False).update(is_active=True)

索引优化

class OptimizedPost(Model):
    title = fields.CharField(max_length=200, index=True)
    content = fields.TextField()
    created_at = fields.DatetimeField(auto_now_add=True, index=True)

    class Meta:
        indexes = [("title", "created_at")]

连接池配置

await Tortoise.init(
    db_url='postgres://user:pass@localhost:5432/dbname',
    modules={'models': ['myapp.models']},
    connections={
        'default': {
            'engine': 'tortoise.backends.asyncpg',
            'credentials': {
                'host': 'localhost',
                'port': '5432',
                'user': 'user',
                'password': 'pass',
                'database': 'dbname',
                'minsize': 1,
                'maxsize': 10,
            }
        }
    }
)

测试策略

使用测试数据库

from tortoise.contrib.test import initializer, finalizer

def setUpModule():
    initializer(['myapp.models'], db_url='sqlite://:memory:')

def tearDownModule():
    finalizer()

class TestUser(TestCase):
    async def test_create_user(self):
        user = await User.create(username='testuser', email='test@example.com')
        self.assertEqual(await User.all().count(), 1)
        self.assertEqual(user.username, 'testuser')

事务测试

from tortoise.transactions import in_transaction

async def test_transaction():
    async with in_transaction():
        user = await User.create(username='transactionuser', email='trans@example.com')
        # 事务会在这里回滚，不会实际创建用户
    assert await User.filter(username='transactionuser').exists() == False

与其他库的集成

与 FastAPI 集成

from fastapi import FastAPI
from tortoise.contrib.fastapi import register_tortoise

app = FastAPI()

register_tortoise(
    app,
    db_url="sqlite://db.sqlite3",
    modules={"models": ["myapp.models"]},
    generate_schemas=True,
    add_exception_handlers=True,
)

@app.get("/users")
async def get_users():
    return await User.all()

与 Pydantic 集成

from tortoise.contrib.pydantic import pydantic_model_creator

UserPydantic = pydantic_model_creator(User)

@app.post("/users")
async def create_user(user: UserPydantic):
    user_obj = await User.create(**user.dict(exclude_unset=True))
    return await UserPydantic.from_tortoise_orm(user_obj)

最佳实践

  1. 使用异步上下文管理器：在处理长时间运行的操作时，使用异步上下文管理器来确保资源被正确释放。

  2. 合理使用预加载：使用 prefetch_related 来减少数据库查询次数，但要避免过度预加载。

  3. 批量操作：对于大量数据的操作，使用批量创建、更新或删除方法。

  4. 使用事务：对于需要保证一致性的复杂操作，使用事务来确保原子性。

  5. 索引优化：根据查询模式合理设置索引，但要避免过度索引。

  6. 异步迭代：处理大量数据时，使用异步迭代器来减少内存使用。

async for user in User.all():
    # 处理每个用户
  1. 定期清理连接池：在长时间运行的应用中，定期重置数据库连接池以防止连接泄漏。

常见问题及解决方案

  1. 循环导入问题：
    解决方案：使用字符串模型引用或延迟导入。

  2. 大量数据的内存问题：
    解决方案：使用 limit 和 offset 进行分页查询，或使用异步迭代器。

  3. 复杂查询性能问题：
    解决方案：使用 select_related 和 prefetch_related 优化查询，必要时使用原生 SQL。

  4. 多数据库支持：
    解决方案：使用 Tortoise 的多数据库配置功能，为不同模型指定不同的数据库。

实际应用场景

  1. 博客系统：
    使用 User、Post、Comment 和 Tag 模型，展示复杂的关系查询和内容管理。

  2. 电子商务平台：
    实现 Product、Order、Customer 模型，展示事务处理和库存管理。

  3. 社交媒体应用：
    使用 User、Post、Like、Follow 模型，展示高并发场景下的性能优化。

  4. 内容管理系统 (CMS)：
    实现灵活的内容类型和字段定义，展示动态模型创建和管理。

与其他 ORM 的比较

  1. vs SQLAlchemy：

    • Tortoise ORM 专注于异步，API 设计更简洁。
    • SQLAlchemy 功能更全面，生态系统更大。

  2. vs Django ORM：

    • Tortoise ORM 支持异步操作，更适合现代异步框架。
    • Django ORM 与 Django 框架深度集成，提供更多开箱即用的功能。

  3. vs Peewee：

    • Tortoise ORM 原生支持异步操作。
    • Peewee 更轻量，但主要用于同步操作。

结语

Tortoise ORM 为 Python 异步编程提供了一个强大而灵活的 ORM 解决方案。它结合了直观的 API 设计和高效的异步操作，使得在现代 Web 应用中处理数据库操作变得简单而高效。无论是构建小型项目还是大型应用，Tortoise ORM 都能提供必要的工具和灵活性。

随着异步编程在 Python 社区中的日益普及，Tortoise ORM 的重要性可能会进一步提升。持续关注其发展和最佳实践，将有助于构建更高效、更可扩展的 Python 应用。

FastApi学习第三天：FastAPI用Tortoise ORM案例和创建模型
百锦再的博客
11-21 1万+
在 FastAPI 中与 Tortoise ORM 配合使用，可以轻松创建数据模型，处理关系型数据（如一对多和多对多），并通过 Pydantic 模型与 FastAPI 的请求和响应机制进行集成。Tortoise ORM 提供了灵活且强大的查询接口，可以支持多种常见的数据库操作，如增、删、查、改、事务等。此外，使用aerich等工具进行数据库迁移也是最佳实践。
Python中的异步ORM框架：Tortoise ORM
2301_79366177的博客
09-23 1236
本文提供了Tortoise ORM的安装方法、数据库连接示例、模型定义示例以及常见的数据库操作示例。通过学习和使用Tortoise ORM，开发人员可以更高效地管理和操作数据库，并提升应用程序的性能和可伸缩性。Tortoise ORM是一个基于Python的异步ORM（对象关系映射）框架，它提供了一种方便的方式来管理和操作数据库。在使用Tortoise ORM进行数据库操作之前，我们需要定义相应的模型。在本文中，我们将探讨Tortoise ORM的使用方法，并提供一些示例代码来说明其功能和用法。
Python-TortoiseORM是python中易于使用的异步ORM
08-10
Tortoise ORM 是 python 中易于使用的异步 ORM
【Tortoise-ORM】 高级特性与实战
最新发布
卜及中的博客
01-19 1320
假设我们正在开发一个简单的任务管理应用，用户可以创建任务、查看任务列表、更新任务状态以及删除任务。我们的任务模型包括任务的标题、描述、状态（待办、进行中、已完成）和创建时间。设计数据库模型。使用Tortoise-ORM进行数据库操作。在FastAPI中应用这些操作，处理前端请求。通过这个实战项目，我们学会了如何在实际应用中应用Tortoise-ORM，设计数据库模型，并将这些操作与FastAPI集成。
Python 数据持久层ORM框架 TorToise模块（异步）
weixin_54217348的博客
03-19 1万+
Tortoise ORM，一个功能强大的异步ORM框架，简化了数据库操作，使开发者能通过Python类定义和管理数据库结构。其支持多种数据库后端，并提供直观易用的API进行高效的数据访问。无论是初学者还是资深开发者，Tortoise ORM都能助力构建稳健、高效的数据库应用。
FastAPI_Tortoise_template:FastAPI-Tortoise ORM-Celery-Docker模板
05-14
基本的FastAPI模板 包括 -FastAPI -TortoiseORM -艾里奇 -用户模型+ JWT身份验证 ...-记录到文件 - 芹菜 -高山Dockerfile -Docker组成文件 -NGINX + certbot ...复制template.config.py-> config.py并填充 ...
Tortoise ORM 简单使用
一个专注于机器学习基础与实战的技术博客，内容涵盖算法推导、模型实现、数学原理与代码实践。用通俗的语言解析复杂概念，记录学习过程中的思考与总结，适合机器学习爱好者和从业者参考。
10-10 9971
当您构建使用关系数据库的应用程序或服务时，有时您不能仅仅使用参数化查询甚至查询构建器就可以逃脱，您只是不断重复自己，为每个实体编写略有不同的代码。代码不知道数据之间的关系，因此您最终几乎是手动连接数据。访问数据库的方式也很容易出错，从而很容易发生 SQL 注入攻击。您的数据规则也是分布式的，增加了管理数据的复杂性，更糟糕的是，应用不一致。ORM（对象关系映射器）旨在解决这些问题，通过集中您的数据模型和数据规则，确保您的数据得到安全管理（提供对 SQL 注入的免疫力）并跟踪关系，因此您不必。
Python中的ORM框架：Tortoise ORM
TechCraze的博客
10-16 989
Tortoise ORM是一个功能强大的异步Python ORM框架，可以简化与数据库的交互。通过使用Tortoise ORM，我们可以轻松地定义模型、执行数据库操作，并将数据库中的数据映射到Python对象中。本文介绍了Tortoise ORM的安装方法、数据库连接配置、模型定义和基本的数据库操作示例。ORM（对象关系映射）是一种编程技术，用于将数据库中的表和行映射到编程语言中的对象和属性。参数指定了数据库的URL，这里我们使用SQLite数据库，并指定了数据库文件的路径为。在上面的示例中，我们使用。
fastapi之tortoise-orm
热门推荐
chise_
05-21 1万+
目录概述fastapi引入创建对应数据模型创建Model设置数据库字段field字段介绍自定义字段设置MetaModel模型方法查询Q对象查询字段过滤预取F表达式功能和聚合事务根据Model生成Schema 概述 fastapi是一个很优秀的框架，但是缺少一个合适的orm，官方代码里面使用的是sqlalchemy，异步也是使用的这个。但是我这边看到有tortoise-orm这个异步orm框架，不知道效率如何，这里先学习，之后做一个性能测试比较一下。 整个框架非常接近django，如果我没写的地方，要么是和d
tortoise-orm：熟悉python的asyncio ORM，考虑了相关性
02-03
tortoise-orm：熟悉python的asyncio ORM，考虑了相关性
tortoise_orm_cookbook：由FastAPI和Tortoise ORM构建
02-21
tortoise_orm_cookbook 由FastAPI和Tortoise ORM构建 Documentのリポジトリは下记バージョンのの文献ationexmapleに，コメントを追记したものです。 乌龟ORM 0.16.22 乌龟ORM文档
Tortoise ORM：异步世界的ORM新星
gitblog_00583的博客
08-09 1007
Tortoise ORM：异步世界的ORM新星 项目地址:https://gitcode.com/gh_mirrors/to/tortoise-orm 项目介绍 Tortoise ORM 是一个易于使用的 asyncio ORM（对象关系映射器），灵感来源于 Django ORM。它设计时考虑到了关系，让你在处理数据时不仅仅是操作表，而是处理关系数据。Tortoise ORM 支持 CPython...
Tortoise-orm 使用(三) 一对一，一对多，多对多关系表及操作
wzbhbb的专栏
01-18 3310
原始:# 修改为:# 这样和其它模型定义关联保持一致，更容易理解。
Tortoise ORM 数据模型定义：账户、账单、类别及预购清单
xinyueyueyueyyyy的博客
08-30 1677
Tortoise ORM 是一个为异步Python应用设计的ORM（对象关系映射）库；它允许开发者以面向对象的方式与关系型数据库进行交互，同时充分利用异步编程的优势来提高应用的性能和响应速度；Tortoise ORM 支持多种数据库后端，如PostgreSQL、MySQL和SQLite等。核心概念模型（Models）：Tortoise ORM 使用Python类来定义数据库中的表结构。每个类代表一个数据库表，类的属性对应表中的列。
【Tortoise-ORM】 基础与数据库操作
卜及中的博客
01-16 1416
ORM（Object-Relational Mapping）是一种用于将对象模型与关系型数据库表格之间进行映射的技术。简单来说，ORM 允许开发者以面向对象的方式操作数据库，而不必直接编写 SQL 查询语句。传统的关系型数据库（如 MySQL、PostgreSQL）使用表格来存储数据，而对象导向编程语言（如 Python）使用对象来表示数据。ORM 通过创建数据库表与类之间的映射关系，简化了数据存取的操作，并在底层自动生成 SQL 语句，从而提高开发效率，减少了开发者与数据库的直接交互。
数据库和ORMS：使用Tortoise ORM与数据库通信
Michael是个半路程序员
03-23 5782
文章目录1. 安装环境2. 创建数据库模型3. 设置 `Tortoise` 引擎 learn from 《Building Data Science Applications with FastAPI》 Tortoise ORM 是一种现代异步 ORM，非常适合 FastAPI项目 1. 安装环境 pip install tortoise-orm https://tortoise-orm.readthedocs.io/en/latest/getting_started.html#installation
fastapi中使用tortoise-orm(入门)
ArthurWangzt的博客
10-17 6822
Tortoise-orm小白入门
tortoise orm
12-30
### Tortoise ORM 使用指南 #### 安装 Tortoise ORM 为了开始使用 Tortoise ORM，需先通过 pip 进行安装。该库适用于多种数据库引擎，包括 SQLite、PostgreSQL 及 MySQL。 ```bash pip install tortoise-orm ``` 对于特定类型的数据库连接，可能还需要额外的驱动包，比如 `aiomysql` 或者 `asyncpg` 来分别支持 MySQL 和 PostgreSQL[^1]。 #### 初始化配置 初始化 Tortoise ORM 通常涉及设置数据库 URL 和定义模型类。下面是一段简单的代码片段来展示如何完成这一过程： ```python from tortoise import Tortoise, fields, run_async from tortoise.models import Model class Tournament(Model): id = fields.IntField(pk=True) name = fields.CharField(max_length=255) async def init(): await Tortoise.init( db_url='sqlite://db.sqlite3', modules={'models': ['__main__']} ) await Tortoise.generate_schemas() ``` 这段脚本展示了创建一个名为 `Tournament` 的表结构，并设置了与 SQLite 数据库之间的连接。 #### 创建和查询数据 一旦完成了上述准备工作，则可以轻松执行 CRUD 操作。这里给出了一些基础的例子： ```python # 添加新记录到 tournament 表中 tournament = await Tournament.create(name="New Tournament") # 查询所有比赛名称包含 "Tour" 字样的赛事列表 tournaments = await Tournament.filter(name__icontains="Tour").all() for t in tournaments: print(t.name) # 更新某条记录的信息 await Tournament.filter(id=tournament.id).update(name="Updated Name") # 删除一条或多条符合条件的数据项 deleted_count = await Tournament.filter(name="Old Event").delete() print(f"{deleted_count} records were deleted.") ``` 这些例子覆盖了常见的增删改查操作，同时也体现了 Tortoise ORM 对于异步方法的支持特性[^2]。 #### 关闭连接池 当应用程序结束运行时应当关闭数据库会话: ```python await Tortoise.close_connections() ``` 这一步骤确保资源被正确释放，防止潜在的问题发生。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值