SeaQL/sea-orm

Features

• Database ORMs - Maps relational database records to strongly typed application objects within an asynchronous runtime.
• Object-Relational Mappers - Provides a full object-relational mapper for bridging relational database tables with strongly typed objects.
• Asynchronous Database Command Execution - Performs relational database operations using non-blocking asynchronous I/O to prevent thread exhaustion.
• Cross-Engine Database Compatibility - Enables application logic to run across PostgreSQL, MySQL, and SQLite without changing code.
• Database Driver Abstractions - Decouples business logic from specific database engines by deferring syntax and driver resolution to runtime configuration.
• Database Engine Abstractions - Decouples business logic from specific database engines to run the same code across different backends.
• Atomic Transactions - Groups multiple database operations into single atomic units to ensure data consistency and integrity.
• Database Schema Migrations - Provides tools for defining and applying versioned schema updates to maintain structural compatibility.
• Database Connections - Manages the lifecycle of opening, initializing, and session-handling for relational database connections.
• Database Migrations - Ships a dedicated utility for versioning and applying incremental schema changes to databases.
• Database Query Joins - Supports specifying non-standard criteria and custom expressions for joining relational tables.
• Eager Loading - Retrieves related data across complex join paths in a single query to avoid multiple round-trips.
• CRUD Interfaces - Provides a configurable dynamic API for executing create, read, update, and delete actions on records.
• Database Table Generation - Programmatically generates SQL statements to create database tables and foreign key constraints from entity models.
• Dynamic SQL Generators - Constructs SQL queries programmatically at runtime using a fluent API instead of static raw strings.
• SQL Syntax Tree Construction - Builds complex database statements by programmatically manipulating a SQL syntax tree through a tiered fluent API.
• Fluent Query Builders - Offers a fluent, chainable API for constructing complex SQL statements at runtime.
• Many-to-Many Associations - Implements complex entity relationships including one-to-one, one-to-many, and many-to-many associations.
• Active-Record ORMs - Implements the Active Record pattern to track model changes and map them back to database records.
• Relational Association Mapping - Defines relational associations by linking child tables to parent entities using specific relation names.
• Query Aggregates - Calculates summary statistics such as sums, averages, and counts across database records.
• Pagination - Implements both offset-based and cursor-based pagination to retrieve large datasets in manageable chunks.
• Query Filters - Applies logical AND, OR, and nested conditional expressions to refine records returned from the database.
• Advanced SQL Construct Execution - Supports execution of complex SQL features including subqueries, aggregate functions, and custom SQL constructs.
• AST-Based Query Construction - Constructs advanced database statements programmatically by manipulating a SQL syntax tree through a tiered API.
• Record Insertion - Creates new entries or modifies existing rows in a table using active models to track changes.
• Relational Data Modeling - Defines complex data associations including one-to-many and many-to-many relationships between entities.
• Schema Definitions - Provides a unified toolset for the declarative definition and management of relational database schemas.
• Asynchronous SQL Toolkits - Provides a comprehensive asynchronous SQL toolkit for type-safe mapping and query execution.
• Type-Safe - Uses traits to define data structures and relationships, ensuring type-safe mapping between tables and columns.
• SQL Query Builders - Provides a programmatic interface for constructing structured SQL operations with filters and joins.
• Entity Mappings - Maps relational database tables to strongly typed structures using shared interfaces to ensure type safety.
• Type Mapping Converters - Converts raw query outputs into structured language types and assembles related entities.
• Unified Database Interfaces - Communicates with MySQL, PostgreSQL, and SQLite using a single, unified asynchronous interface.
• Database Schema Scaffolding - Automatically generates strongly typed data models and boilerplate entities from existing database schemas.
• Asynchronous Runtime Compatibility - Executes database operations using non-blocking I/O to maintain compatibility across various asynchronous execution environments.
• Connection Pooling - Maintains a cache of open asynchronous database connections to reduce session overhead and improve performance.
• Connection Pools - Maintains a cache of open asynchronous connections to reduce the overhead of establishing new sessions.
• GraphQL API Generators - Transforms database entities into typed GraphQL schemas with built-in support for pagination and filters.
• Data-to-Model Mappers - Converts partial data structures into database-ready models to facilitate selective field updates and API submissions.
• Database Indexing - Generates and executes SQL commands to create database indices based on entity definitions.
• Eager Loading - Retrieves related data through predefined associations using either separate queries or single joined operations.
• Relational Entity Filtering - Restricts results to entities that meet specific relationship conditions using EXISTS subqueries.
• Enum Definitions - Generates database-specific enum type definitions across multiple supported relational backends.
• Application-to-Database Enum Mapping - Connects database-level enumeration types to application-level enums using native types or standard columns.
• Partial Model Projections - Selects a specific subset of columns from a table and maps them into a projection struct.
• Result Streaming - Fetches large datasets incrementally via cursors to prevent memory exhaustion during processing.
• Raw SQL Execution - Executes complex queries using raw SQL strings with parameter expansion for specialized scenarios.
• Record Deletion - Removes specific records or groups of records from a table based on filters or model instances.
• Result Grouping - Organizes database records into sets based on shared values and applies conditional filters to those groups.
• Schema-Driven Code Generators - Automatically creates strongly typed data models and entities from an existing database schema using a CLI tool.
• Concurrent Query Handlers - Executes multiple database operations in parallel using asynchronous primitives to increase application throughput.
• Database Interaction Mocking - Simulates database behavior in controlled environments to test application logic without live connections.
• Server Implementations - Provides a CLI to bootstrap ready-to-run GraphQL server implementations across multiple web frameworks.
• GraphQL Schema Generation - Transforms database entities into typed GraphQL schemas with built-in support for pagination and filters.

Star history