Sea Orm

Sea-ORM is an asynchronous SQL object-relational mapper and database toolkit for mapping relational tables to strongly typed objects. It provides a relational database mapper for performing CRUD operations across MySQL, PostgreSQL, and SQLite, and includes a programmatic dynamic query builder for constructing complex SQL statements.

The project distinguishes itself by providing a GraphQL schema generator that transforms database entities into typed schemas with built-in pagination and filters. It also features a dedicated database migration tool for defining and applying versioned schema changes.

The toolkit covers broad capability areas including relational data modeling and schema management, where it supports the automatic generation of entities from existing database schemas. It further provides advanced query building features such as aggregate value computation, partial model projection, and linked entity fetching, all executed within non-blocking asynchronous runtimes.

The project includes a command-line interface for database entity generation and GraphQL server bootstrapping.

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.

jeremyevans/sequel

5,076View on GitHub

Sequel is a relational database toolkit for Ruby that provides object-relational mapping, a fluent SQL query builder, and schema migration capabilities. It maps database tables to Ruby classes with support for associations, validations, lifecycle hooks, and eager loading, offering a comprehensive ORM layer for building data-centric applications. Sequel distinguishes itself through a plugin-based extension architecture that allows composable customization of models, databases, and datasets without relying on deep inheritance hierarchies. It includes a thread-safe connection pool with support f

knex/knex

20,300View on GitHub

Knex is a multi-dialect database client that provides a programmatic SQL query builder, a connection pool manager, and a versioned schema migration tool. It enables programmatic database interaction across multiple SQL engines, including PostgreSQL, MySQL, SQLite3, SQL Server, CockroachDB, and Oracle. The project distinguishes itself through a fluent interface for constructing complex SQL statements and a dedicated framework for database seeding. It utilizes specialized dialects to translate generic query representations into database-specific syntax while maintaining a consistent API across

dotnet/efcore

14,587View on GitHub

Entity Framework Core is an object-relational mapper that enables developers to interact with database systems using strongly-typed code. It serves as a comprehensive data access framework, providing a unified interface for mapping application objects to relational and non-relational database schemas while managing the lifecycle of data operations through a central context. The project distinguishes itself through a provider-based architecture that decouples core data access logic from specific database engines, allowing for consistent interaction across diverse storage systems. It features a

Vincit/objection.js

7,343View on GitHub

Objection.js is an object-relational mapper for Node.js that maps SQL database tables to classes and rows to model instances. It functions as a high-level abstraction layer built on top of the Knex.js query builder to provide structured model definitions and relational data mapping. The project distinguishes itself through its ability to manage complex object graphs, allowing for the persistence and eager-loading of deeply nested related data in single operations. It incorporates a data integrity layer that uses JSON schema validation to verify model instances before they are persisted to the

SeaQLsea-orm

Features