fastapi/sqlmodel

Features

• Data Schema Definitions - Defines data structures that serve as both database schemas and validation models for application logic.
• Database ORMs - Interacts with relational databases using typed objects and class-based models to eliminate raw SQL.
• Object-Relational Mapping - Links database entities through object attributes to allow automatic fetching and traversal of related records without manual joins.
• Data Validation - Enforces schema constraints and type requirements on incoming data payloads to ensure integrity.
• Data Persistence - Saves instances of data models to a connected database by managing sessions and committing changes to the underlying storage.
• Database Query Interfaces - Constructs and executes database queries using class models to retrieve typed objects without raw SQL.
• CRUD Interfaces - Executes standard create, read, update, and delete actions on database records using object-oriented methods and session management.
• Data Validation Libraries - Combines Python type hints with database schema definitions for unified data validation and object-relational mapping.
• Asynchronous Database Drivers - Executes database queries and transactions using asynchronous syntax to prevent blocking the main thread.
• Database Schema Migrations - Tracks and applies incremental changes to database structures to maintain synchronization with data models.
• Database Connections - Automates the opening and closing of database connections for each request handler to ensure efficient resource management.
• Database Object Synchronizations - SQLModel updates local object attributes with the latest data from the database, ensuring fields like auto-generated IDs are available after a commit.
• ORM Relationship Querying - Retrieves records from multiple tables by filtering or joining based on defined foreign key relationships.
• Database Relationship Mappings - Defines relational associations between data models using foreign keys and relationship attributes.
• Type-Safe Query Builders - Uses static type analysis and class attributes to build database queries that provide IDE autocompletion and compile-time safety.
• Data Schema Definitions - Combines data validation logic and database schema definitions into a single class to ensure consistency across application layers.
• Unified Data Modeling - Provides unified data structures that serve simultaneously as database schemas and validation models.
• Data Serializers - Validates incoming and outgoing web request data while automatically converting between objects and formats.
• Database Clients - SQL databases designed for simplicity and compatibility.
• Database ORMs - Listed in the “Database ORMs” section of the Awesome Python awesome list.
• Object Relational Mappers - ORM based on type annotations and Pydantic.
• Asynchronous Database Command Execution - Executes database transactions and queries asynchronously to prevent blocking the main execution thread.
• Database Schema Managers - Automatically generates database tables from defined models during application startup.
• Many-to-Many Associations - Links two database entities through intermediate tables to represent many-to-many associations.
• Association Models - SQLModel connects two entities through an intermediate model that stores additional metadata alongside the foreign keys representing the relationship.
• Object Relational Mappings - Automatically updates linked object attributes in memory to maintain consistency before database commits.
• Record Updating - Updates existing object attributes and persists changes to the database via session commits.
• Schema Mapping Utilities - Maps application classes directly to database tables and columns to enable object-oriented interaction with relational storage.
• Single Record Retrievers - Fetches specific database entries by primary key with built-in error handling for missing records.
• Session Persistence Management - Handles database connections and transaction lifecycles automatically within the context of individual request handlers.
• Data Pagination Utilities - Restricts record counts and skips initial rows to enable efficient chunked data retrieval.
• In-Memory Databases - Runs ephemeral database instances in memory to facilitate isolated and efficient test environments.
• Local State Stores - Ensures application instances reflect the current state of stored records by fetching latest data.
• Many-to-Many Relationship Managers - Manages many-to-many associations by automatically synchronizing changes across related models.
• Record Deletion - Deletes a specific object from the database session to permanently remove the corresponding record from the underlying storage.
• Nested Serialization - Embeds nested information from associated database records into API responses automatically to reduce the number of separate requests.
• Related Attribute Resolvers - Automatically fetches and resolves associated database records when accessing relationship attributes.
• Relationship Management - Links database entities through foreign keys to enable automatic navigation and persistence of connected records.
• Circular Dependency Resolutions - SQLModel uses string-based type annotations to reference classes that are not yet defined in the current scope, allowing for circular dependencies and cleaner code organization.
• Database Indexing - Configures model fields to be indexed in the database to optimize query performance.
• Database Record Management - Applies conditional logic to select statements to retrieve records matching specific criteria.
• Inheritance Mappings - Shares common fields across multiple data models using class inheritance to reduce code duplication.
• Cascading Deletion Hooks - Configures automatic deletion or modification of child records when a parent record is removed.
• Database Injection Prevention - Provides automated query sanitization and parameterization to protect database interactions from injection attacks.
• Circular Dependency Resolution - Uses string-based annotations to resolve circular dependencies between data models during schema initialization.
• Test Fixture Management - Automates the setup and teardown of database engines and sessions to provide isolated environments for individual test functions.
• Response Validation - Validates and formats data returned by API endpoints using predefined models to ensure consistent response structures.

Star history