tortoise/tortoise-orm

Features

• Async-Await ORM Cores - Executes all database operations asynchronously using Python's async/await syntax, enabling non-blocking I/O for concurrent workloads.
• Database Field Lookups - Ships a chainable filter API with field lookups like contains, range, and regex for precise record selection.
• Record Creations - Provides methods for inserting new rows into the database via model instances.
• Atomic Transaction Execution - Groups multiple database operations into an atomic unit that commits or rolls back as a whole.
• Automatic Migration Detectors - Compares current model definitions against migration history to generate and apply schema changes automatically.
• Built-in Migration Engines - Includes a built-in migration engine that auto-detects model changes and manages schema versions.
• Django Model Generation - Defines database tables as Python classes with typed fields, mirroring Django's model API for familiar object-oriented data modeling.
• ORM Data Models - Defines database tables as Python classes with typed fields and relationships, mirroring Django's model syntax.
• Typed Field Definitions - Defines model attributes using typed fields like CharField and IntField to map Python objects to database columns.
• ORM Model Declarations - Defines database tables as Python classes with typed fields and relations, automatically generating schema.
• Type-Safe Schema Definitions - Defines database tables as Python classes with typed fields, primary keys, and inheritance support.
• Database Connection Configurations - Connects to SQLite, PostgreSQL, MySQL, MSSQL, or Oracle databases using a connection URL or parameters.
• Database Connectivity - Connects to a database using a connection URL and registers model modules for use across the application.
• Database Driver Abstractions - Connects to PostgreSQL, SQLite, MySQL, MSSQL, and Oracle through pluggable async drivers without changing application code.
• Django-Style ORMs for Async Frameworks - Provides a Django-style ORM designed for async frameworks, enabling familiar data access in ASGI applications.
• Async - Provides async database operations as a core feature of the ORM.
• Database Migration Management - Detects model changes, generates migration files, and applies or reverts schema changes through a command-line tool.
• Record Creations and Updates - Provides methods for inserting and updating database records through model instances.
• Database Record Querying - Retrieves records from the database using querysets with filtering, prefetching, grouping, and ordering.
• Database Transaction Management - Wraps a sequence of database operations in a transaction that commits or rolls back as a single atomic unit.
• Database Transactions - Wraps a block of code so that all database changes are committed atomically or rolled back on error.
• Primary Key Configurations - Provides automatic primary key generation and configuration for ORM models.
• Foreign Key Constraints - Defines foreign key fields to link models, enabling related queries and prefetching of associated records.
• Many-to-Many Associations - Connects two models through an automatically managed intermediate table for bidirectional queries.
• Relational Field Definitions - Creates foreign-key and many-to-many relationships between models in object-oriented code.
• Migration Execution - Executes all unapplied database migrations for a specific app or for all configured apps.
• Migration Generation - Compares current model definitions against the migration history and generates new migration files automatically.
• Migration Management - Detects model changes, generates migration files, and applies them to keep the schema in sync.
• Model-as-a-Table Integrations - Defines database tables as Python classes with typed fields for object-oriented data access.
• Many-to-Many Relationship Managers - Provides methods to add, remove, or clear related records through an automatically managed intermediate table.
• Query Filtering - Provides a chainable filter API that translates to SQL WHERE clauses for retrieving database records.
• Chainable Modifier Patterns - Provides a chainable query builder for filtering, ordering, and aggregating records.
• Query Filters - Provides a chainable filter API that translates to SQL WHERE clauses with lookups like contains and startswith.
• Filtered and Ordered Queries - Supports chaining filter, order, and distinct constraints on database queries for precise record retrieval.
• Asynchronous Operations - Executes all database operations asynchronously using async/await syntax for non-blocking I/O.
• Relational Data Modeling - Defines and manages relational data models with automatic prefetching and related-object queries.
• Eager-Loaded Relation Queries - Builds queries with eager-loading, filtering, and aggregation across foreign key and many-to-many relations to minimize N+1 problems.
• Related Object Retrievers - Filters, orders, limits, or counts related records through foreign key or many-to-many relations.
• Relational Data Management - Links models through foreign keys and many-to-many relationships with automatic fetching of related objects.
• Async Python ORMs with Relations - Provides an async Python ORM with full relational support, defining the core identity of the repository.
• Relational Field Managers - Declares foreign key, many-to-many, and one-to-one relationships and fetches related objects.
• Schema Generators - Creates database tables automatically from model definitions for development and prototyping.
• Django-Style ORMs - Defines database tables as Python classes and queries them with an object-oriented API mirroring Django's syntax.
• Multi-Database Support - Supports PostgreSQL, SQLite, MySQL, MariaDB, MSSQL, and Oracle through pluggable async drivers.
• Schema Migrations - Applies schema changes, detects differences, and manages data migrations through a built-in command-line tool.
• Async Query Builders with Relations - Ships a chainable async query builder with relation prefetching for efficient data access.
• Class-Based Data Modeling - Defines data models by subclassing a base class and declaring typed fields for each database column.
• Isolated Database Tests - Ships a context manager that sets up and tears down isolated test databases for integration tests.
• Model Field Definitions - Defines database tables as Python classes with typed fields, automatically generating the schema from model definitions.
• ORM-to-Pydantic Generators - Generates Pydantic schemas from ORM models for validation and serialization in API endpoints.
• Multi-Backend Async Database Drivers - Supports multiple database backends through pluggable async drivers without changing application code.
• Web Framework Integrations - Connects the ORM lifecycle to ASGI frameworks so database connections start and stop with the application.
• Savepoints - Creates savepoints inside an outer transaction so inner blocks can roll back independently.
• Data Serialization and Parsing - Converts model instances to and from structured formats with built-in validation and custom serializers.
• Custom Field Type Definitions - Subclasses an existing field to store and convert custom Python types, such as enums, to and from a database-compatible format.
• URL-Based Connections - Specifies database connection details in a single URL string, including type, credentials, host, port, and options.
• Nested Transactions - Supports nested savepoints within outer transactions, allowing partial rollbacks without aborting the entire transaction.
• Asynchronous - Filters, annotates, groups, and aggregates records using a composable async query API.
• Group-By Aggregations - Computes grouped summaries by annotating querysets with expressions like Count and Case.
• Migration Reversion - Rolls back a previously applied migration for a specific app to a named target.
• Multi-Tenant Data Management - Connects to different databases per context without global state for separate ORM state per tenant.
• Null Value Filtering in Queries - Matches records where a field is null when the filter value is explicitly set to None in queries.
• Raw SQL Execution - Executes raw SQL statements with parameter binding against the connected database.
• Bulk Record Insertions - Inserts many model instances in one database query with conflict handling and batch sizing.
• Relation Prefetching - Prefetches related model instances in a single query to avoid N+1 problems.
• Test Database Creations and Deletions - Creates or deletes databases on the server, typically used by a test runner for isolated testing.
• Bulk Update Utilities - Updates specified fields on multiple model instances in a single database query.
• Custom Data Transformations During Migration - Runs custom Python logic or raw SQL to modify existing data as part of a schema migration.
• Django Abstract Model Inheritances - Supports sharing field definitions across models via abstract base classes and mixin inheritance.
• Non-Transactional Migrations - Wraps data-migration operations in a database transaction by default, with an option to disable it.
• Isolated Test Database Contexts - Wraps each test in a fresh database context that initializes models, generates schemas, and closes connections on exit.
• ORM Model Metadata - Configures table name, schema, ordering, compound indexes, and constraints through an inner Meta class.
• Database Clients - Asyncio ORM built with relations in mind.
• Database Drivers - Multi-backend ORM with a Django-like API.
• Database ORMs - Listed in the “Database ORMs” section of the Awesome Python awesome list.
• Object Relational Mappers - Asyncio ORM inspired by Django.

Star-Verlauf