# ORM query builder

> AI-ranked search results for `orms query builders and data access%5C` on awesome-repositories.com — ordered by an LLM for relevance, best match first. 109 total matches; showing the top 30.

Explore on the web: https://awesome-repositories.com/q/orms-query-builders-and-data-access-5c

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [this search on awesome-repositories.com](https://awesome-repositories.com/q/orms-query-builders-and-data-access-5c).**

## Results

- [drizzle-team/drizzle-orm](https://awesome-repositories.com/repository/drizzle-team-drizzle-orm.md) (34,835 ⭐) — Drizzle ORM is a TypeScript-native database toolkit providing type-safe SQL query building, schema management, and automated migrations across PostgreSQL, MySQL, SQLite, and SingleStore.
- [mybatis-flex/mybatis-flex](https://awesome-repositories.com/repository/mybatis-flex-mybatis-flex.md) (2,554 ⭐) — MyBatis-Flex is an object-relational mapping framework for Java that extends MyBatis with a fluent API and automated CRUD operations. It provides a data access suite featuring an automatic CRUD data mapper, a type-safe SQL query builder, and a row-based query engine for manipulating records without predefined entity classes.

The framework includes a multi-dialect SQL translator that converts generated syntax across different database engines, such as MySQL, PostgreSQL, and Oracle. It further distinguishes itself by offering annotation-free entity mapping using runtime reflection and naming co
- [sequelize/sequelize](https://awesome-repositories.com/repository/sequelize-sequelize.md) (30,349 ⭐) — Sequelize is an object-relational mapping library that provides a unified interface for managing relational data through code. By implementing the Active Record pattern, it maps database tables to application objects, allowing developers to perform standard create, read, update, and delete operations using high-level method calls. The library abstracts complex database interactions by translating these calls into optimized, engine-specific SQL statements, ensuring consistent behavior across different database systems.

The project distinguishes itself through a comprehensive suite of tools for
- [kysely-org/kysely](https://awesome-repositories.com/repository/kysely-org-kysely.md) (13,969 ⭐) — Kysely is a TypeScript SQL query builder that provides a type-safe interface for constructing and executing database queries. It functions as a database layer that ensures schema compliance and prevents runtime errors by using a fluent interface and a programmable way to build complex SQL statements.

The project features a type-safe database layer capable of inferring return types and aliases from SQL selections and joins. It also includes a SQL migration manager to track and apply schema changes across different environments to keep database versions synchronized.

The toolkit covers relatio
- [tgriesser/knex](https://awesome-repositories.com/repository/tgriesser-knex.md) (20,314 ⭐) — Knex is a programmatic SQL query builder for Node.js applications. It provides a unified interface for generating database statements and managing structural versioning through a schema migration tool.

The project features a multi-dialect database layer that translates programmatic queries into specific syntax for relational databases including PostgreSQL, MySQL, SQLite3, and MSSQL. This allows for writing database logic that remains compatible across different systems.

The system includes infrastructure for managing reusable database connection pools and handling relational transactions to
- [seaql/sea-query](https://awesome-repositories.com/repository/seaql-sea-query.md) (1,725 ⭐) — Sea-query is a database abstraction library for Rust that provides a fluent builder pattern for constructing type-safe SQL queries. It functions as a framework for defining and managing database schemas and queries through code, allowing developers to generate syntactically valid statements for multiple database engines without relying on manual string concatenation.

The library distinguishes itself by using an abstract syntax tree to model queries, which enables engine-agnostic transformations and compilation into specific SQL dialects. This architecture supports cross-database portability,
- [go-gorm/gorm](https://awesome-repositories.com/repository/go-gorm-gorm.md) (39,798 ⭐) — GORM is a developer-focused object-relational mapping library for Go that provides a comprehensive data persistence framework. It serves as a database access layer, allowing developers to map application structures to database tables and perform CRUD operations using a fluent, type-safe query builder instead of writing raw SQL.

The library distinguishes itself through its association-aware persistence, which automatically tracks and synchronizes complex entity relationships during database operations. It utilizes a driver-agnostic interface to maintain consistent behavior across various stora
- [typeorm/typeorm](https://awesome-repositories.com/repository/typeorm-typeorm.md) (36,540 ⭐) — TypeORM is an object-relational mapper for TypeScript and JavaScript that bridges the gap between object-oriented application code and relational database tables. It provides a comprehensive data persistence layer that allows developers to define database entities using class decorators or configuration objects, enabling seamless interaction with data through object-oriented patterns.

The project distinguishes itself through a flexible architecture that supports both the data mapper and repository patterns, alongside a fluent query builder that translates high-level method calls into platform
- [mikro-orm/mikro-orm](https://awesome-repositories.com/repository/mikro-orm-mikro-orm.md) (9,085 ⭐) — Mikro-ORM is a TypeScript-based object-relational mapping system that provides a unified persistence layer for Node.js applications. It translates TypeScript entities into relational or document-based database schemas, supporting a variety of engines including PostgreSQL, MySQL, MariaDB, MS SQL Server, SQLite, and MongoDB.

The project implements the data mapper pattern to decouple in-memory domain models from the database persistence layer. It utilizes a unit of work pattern to track entity changes in memory and commit them in a single coordinated database transaction.

The library covers com
- [diesel-rs/diesel](https://awesome-repositories.com/repository/diesel-rs-diesel.md) (14,021 ⭐) — This project is a type-safe database toolkit and object-relational mapper designed to enforce structural consistency between database schemas and application code. By leveraging compile-time validation, it ensures that SQL queries and data structures remain synchronized, preventing common errors before the application executes. It provides a comprehensive framework for relational data modeling, allowing developers to define table associations and map database results directly into strongly-typed language objects.

The library distinguishes itself through its focus on compile-time safety and au
- [aplus-framework/database](https://awesome-repositories.com/repository/aplus-framework-database.md) (339 ⭐) — This project is a database access layer for PHP that provides a consistent interface for interacting with multiple relational database management systems. It functions as a unified abstraction layer, enabling developers to connect to various SQL databases and perform data operations through a standardized command set.

The library distinguishes itself by utilizing a fluent query builder that allows for the programmatic construction of complex SQL statements. It further abstracts database interactions through a schema definition language, which enables the creation, modification, and management
- [stephencelis/sqlite.swift](https://awesome-repositories.com/repository/stephencelis-sqlite-swift.md) (10,167 ⭐) — SQLite.swift is a type-safe Swift wrapper and object-relational mapping layer that provides a bridge for interacting with SQLite databases. It functions as a database driver that allows for embedded database management and local data persistence within Swift applications.

The project distinguishes itself through a type-safe expression builder that verifies SQL statement syntax and intent at compile time. It includes specialized support for high-performance text matching via full-text search integration and provides mechanisms for securing sensitive data through database encryption.

The libra
- [prisma/prisma-client-js](https://awesome-repositories.com/repository/prisma-prisma-client-js.md) (1,465 ⭐) — Prisma Client is a database client for Node.js and TypeScript applications that provides a type-safe interface for interacting with relational databases. It functions as an object-relational mapper that translates declarative schema definitions into strongly typed query interfaces, ensuring that database operations align with the underlying data structure.

The library distinguishes itself by generating type definitions directly from a schema model, which enables static analysis and IDE autocompletion during development. By abstracting database interactions into a unified query language, it st
- [prisma/prisma](https://awesome-repositories.com/repository/prisma-prisma.md) (46,366 ⭐) — Prisma is a database toolkit that provides a unified access layer for interacting with relational and document databases. It centers on a declarative schema modeling approach, where developers define their data structures in a human-readable language. This schema serves as the single source of truth, from which the toolkit automatically generates type-safe database clients that provide compile-time validation and editor autocomplete for all data operations.

The project distinguishes itself through a high-performance, Rust-based query engine that handles query planning and connection pooling o
- [knex/knex](https://awesome-repositories.com/repository/knex-knex.md) (20,300 ⭐) — 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
- [seaql/sea-orm](https://awesome-repositories.com/repository/seaql-sea-orm.md) (9,410 ⭐) — 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 chan
- [elixir-ecto/ecto](https://awesome-repositories.com/repository/elixir-ecto-ecto.md) (6,471 ⭐) — Ecto is an Elixir database toolkit that maps database rows to Elixir structs and validates data changes through changesets before persistence. It provides a language-integrated query syntax for composing database queries, building them incrementally and securely with compile-time expansion into safe SQL.

The toolkit connects to multiple database backends including PostgreSQL, MySQL, MSSQL, SQLite3, ClickHouse, and ETS through a pluggable adapter interface. It supports eager and lazy preloading of associated records to eliminate N+1 query problems, and can store nested data structures as embed
- [sqlalchemy/sqlalchemy](https://awesome-repositories.com/repository/sqlalchemy-sqlalchemy.md) (11,612 ⭐) — SQLAlchemy is a comprehensive Python SQL toolkit and object-relational mapper that provides a full suite of tools for interacting with relational databases. It serves as a foundational layer for database connectivity, offering both a high-level object-oriented interface for data persistence and a programmatic SQL expression language for constructing complex, dialect-agnostic queries.

The project distinguishes itself through its sophisticated unit of work persistence, which coordinates atomic transactions and tracks object state changes to minimize redundant database operations. It provides a
- [vincit/objection.js](https://awesome-repositories.com/repository/vincit-objection-js.md) (7,343 ⭐) — 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
- [groue/grdb.swift](https://awesome-repositories.com/repository/groue-grdb-swift.md) (8,209 ⭐) — GRDB.swift is a comprehensive SQLite toolkit and object-relational mapper for Swift. It provides a database wrapper that handles local data persistence, connection management, and encrypted file storage for Apple platforms.

The library features a dedicated observation framework that tracks database changes to automatically synchronize the application state and user interface in real time. It distinguishes itself with a type-safe query builder and a protocol-based mapping system that converts database rows into structured Swift objects.

The toolkit covers a broad range of administrative and o
- [hibernate/hibernate-orm](https://awesome-repositories.com/repository/hibernate-hibernate-orm.md) (6,447 ⭐) — Hibernate ORM is a Java object-relational mapper and a full implementation of the Jakarta Persistence API. It serves as a SQL database abstraction layer that translates Java object models into relational database schemas to manage data persistence and lifecycles.

The framework distinguishes itself with a multi-tenant data isolation framework for separating customer data within a single database instance. It also features a database schema generator that automatically produces and updates relational structures based on entity mappings.

The system covers broad capability areas including transa
- [uptrace/bun](https://awesome-repositories.com/repository/uptrace-bun.md) (4,867 ⭐) — Bun is a type-safe object relational mapper for Go that prioritizes SQL-first query construction and result mapping. It functions as a programmable SQL query builder, a database connection manager, and a tool for mapping database tables to Go structs.

The project distinguishes itself through a multi-dialect SQL support system, allowing a single codebase to interact with different database engines via a consistent interface. It includes a built-in database observability tool for query interception, distributed tracing, and logging, as well as a schema migration tool for versioning structural c
- [ebean-orm/ebean](https://awesome-repositories.com/repository/ebean-orm-ebean.md) (1,523 ⭐) — Ebean is a Java object-relational mapping framework designed to simplify database persistence through automated query generation, schema migration, and transaction management. It uses metadata-driven mapping and bytecode enhancement to bridge the gap between application objects and relational database tables, providing a persistent layer that handles complex data interactions while maintaining consistency across unit-of-work boundaries.

The framework distinguishes itself through its focus on developer productivity and performance optimization. It provides type-safe query builders that generat
- [ent/ent](https://awesome-repositories.com/repository/ent-ent.md) (17,110 ⭐) — Ent is a statically typed entity framework for Go that models database structures as a graph of nodes and edges. It functions as a code generation engine that transforms schema definitions into type-safe database clients, query builders, and migration scripts. By representing data as interconnected entities, the framework enables intuitive traversal of complex relationships and ensures that database interactions remain consistent with the application model at compile time.

The framework distinguishes itself through its graph-based approach to data modeling and its reliance on compile-time cod
- [doctrine/orm](https://awesome-repositories.com/repository/doctrine-orm.md) (10,172 ⭐) — Doctrine ORM is a PHP object-relational mapper that connects application objects to relational database tables. It uses the data mapper and identity map patterns to decouple the in-memory object model from the database schema, allowing developers to manage data persistence without writing manual SQL.

The project features a dedicated object-oriented query language and programmatic builder for retrieving data based on entities rather than tables. It implements a unit-of-work system to track object changes during a request and synchronize them via atomic transactions.

The capability surface inc
- [stephenafamo/bob](https://awesome-repositories.com/repository/stephenafamo-bob.md) (1,739 ⭐) — This project is a database toolkit for Go that provides schema-to-object mapping, fluent query construction, and automated code generation. It functions as a framework for type-safe database access, enabling developers to interact with relational databases by generating models and interfaces directly from existing database schemas.

The toolkit distinguishes itself through a workflow that parses hand-written SQL files to generate type-safe functions, allowing for the integration of custom SQL while maintaining consistent result mapping. It supports modular customization through a plugin-based
- [ormar-orm/ormar](https://awesome-repositories.com/repository/ormar-orm-ormar.md) (1,805 ⭐) — Ormar is an asynchronous object-relational mapper for Python that integrates database persistence with data validation. It functions as a bridge between relational database management and application-level data structures, allowing developers to define database schemas that serve simultaneously as validation models.

The project distinguishes itself by using validation classes to enforce schema integrity, ensuring that all persisted records conform to defined types and structures. It supports complex relational associations, including one-to-many and many-to-many relationships, and provides ev
- [gaarason/database-all](https://awesome-repositories.com/repository/gaarason-database-all.md) (1,033 ⭐) — This project is a Java-based object-relational mapping framework that utilizes the active record pattern to simplify database interactions. It provides a comprehensive data access layer that binds database tables directly to application objects, enabling developers to perform CRUD operations, manage complex entity relationships, and execute queries through a fluent, type-safe interface. Designed for integration with Spring Boot, the framework abstracts database complexities while maintaining support for native compilation and asynchronous execution.

The framework distinguishes itself through
- [doctrine/dbal](https://awesome-repositories.com/repository/doctrine-dbal.md) (9,699 ⭐) — This project is a SQL database abstraction layer that provides a consistent object-oriented interface for interacting with multiple relational database systems. It includes a driver wrapper to standardize connections and result sets, a fluent query builder for constructing portable SQL statements, and a type mapper for converting database-specific data types into native application types and vice versa.

The library enables programmatic schema management through a schema manager that can introspect database metadata, model structures as objects, and generate the SQL required to migrate between
- [baomidou/mybatis-plus](https://awesome-repositories.com/repository/baomidou-mybatis-plus.md) (17,391 ⭐) — MyBatis-Plus is a persistence framework extension for Java that simplifies data access by reducing boilerplate code. It provides a toolkit for automating common database operations, utilizing dynamic query wrappers and a system for automated CRUD generation.

The project distinguishes itself through a code generation system that produces mapper, model, service, and controller layers based on database metadata. It also implements a security layer that prevents SQL injection through input sanitization and blocks dangerous global update or delete operations to prevent accidental data loss.

The f