Projects sharing features with DBFlow

Jet is a schema-driven code generation tool and type-safe SQL builder for Go. It introspects database schemas to automatically generate builders and data models, enabling compile-time type checking for table and column references to prevent runtime errors. The project distinguishes itself through a fluent interface that mirrors native SQL syntax, allowing for the orchestration of complex queries including common table expressions, recursive queries, and nested JSON structures. It further optimizes data retrieval by binding query outputs directly into generated Go structures or raw byte slices

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 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

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

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,

Drift is a type-safe SQL persistence library and relational mapper that provides a structured way to map database tables to classes and execute SQL queries with build-time validation. It functions as a type-safe query builder and a wrapper for SQLite and PostgreSQL, eliminating manual result set parsing by binding query outputs to native objects. The project distinguishes itself through a build-time code generation system that produces type-safe APIs and validates raw SQL statements against database versions before execution. It features reactive query streaming, which transforms SQL queries

This project is a reference implementation of the Model-View-Presenter (MVP) architecture for Android applications. It focuses on separating business logic from the user interface by decoupling data logic, UI presentation, and view layers. The implementation distinguishes itself through the inclusion of a boilerplate generator that automatically creates the activity, presenter, and view files required for the MVP pattern. It utilizes a compile-time dependency injection framework to manage object lifetimes and a reactive programming workflow to handle asynchronous data streams and event propag

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

This project is a reference implementation providing a collection of practical examples for data access patterns and repository abstractions within the Spring Data ecosystem. It serves as a comprehensive showcase for implementing consistent data layers across various relational and non-relational databases. The repository specifically demonstrates multi-store persistence by integrating relational, document, and vector databases within a single application. It includes implementations for vector search to manage high-dimensional embeddings and similarity searches across different database tech

SQLModel is a type-safe object-relational mapping library for Python that integrates database schema definitions with data validation logic. By combining these two roles into a single class, it allows developers to manage relational data structures and enforce data integrity for web APIs simultaneously. The framework is built to support asynchronous database operations, enabling high-performance applications to execute queries and transactions without blocking the main execution thread. The library distinguishes itself by leveraging Python type hints to provide IDE autocompletion and compile-

Hawk is a secure local storage library and persistence API for Android. It provides a framework for saving and retrieving primitives, objects, and collections using a key-value storage system. The library features an encrypted storage wrapper that secures data through a pluggable crypto provider, including a fallback mechanism to non-encrypted mode. Its architecture allows for custom storage backend implementations and interface-based component injection to replace default serialization, parsing, and conversion processes. The system supports type-preserving serialization and includes utiliti

sqlite-net is a lightweight object-relational mapper and data access layer for SQLite. It provides tools for translating application classes into database tables, managing records through an entity mapper, and implementing local data persistence. The library includes an encrypted wrapper that secures database files using connection keys and native encryption configurations. It also features a data access layer that supports both synchronous and asynchronous operations to maintain application responsiveness during disk access. The project covers a range of database management capabilities, in

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

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

sqlx is a set of extensions for the Go database/sql package that reduces boilerplate code by automating the mapping of database query results directly into structs and slices. It provides a wrapper around standard database types to eliminate manual row scanning and repetitive error handling. The project distinguishes itself through named parameter binding and query placeholder rebinding, which translate generic markers into driver-specific symbols. It also enables dynamic SQL execution by allowing the application to read and execute SQL statements directly from the filesystem. The library co

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

linq2db is a type-safe object-relational mapper that translates LINQ expressions into optimized SQL queries for multiple database providers. It functions as a database mapper that links classes to tables and includes a SQL query builder and a command-line schema tool for generating data classes from existing databases. The project provides high-performance bulk data processing for inserting and loading large volumes of records via batch or binary copy methods. It also supports advanced SQL operations, including window functions, common table expressions for recursive hierarchical querying, an

Sqlbrite is a reactive SQLite database manager and lightweight wrapper for Android. It functions as a reactive SQL library that converts standard SQLite queries into observable streams, allowing the application to emit new results automatically when underlying database tables change. The project provides a mechanism for tracking changes to specific database tables, triggering query refreshes without manual polling. It also includes an atomic transaction manager to group multiple SQL modifications into single units, ensuring data integrity and preventing redundant notifications. The library h

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

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.

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

JSqlParser is a Java library for SQL query parsing, converting raw SQL strings into a structured hierarchy of strongly typed Java objects. It provides the means to programmatically analyze and manipulate database queries by representing them as a tree of objects. The library supports both the parsing of existing SQL text and the programmatic generation of new statements through a fluent API. It includes mechanisms for transforming query trees and serializing structured object models back into formatted SQL text. Additional capabilities include database schema analysis, such as the extraction

EmDash is an open-source content management system built on Astro that combines a visual admin panel with a plugin-driven architecture and server-side rendering. It provides a complete content management system with structured content modeling, a rich text editor using Portable Text format, and a TypeScript API for type-safe content queries. The system supports authentication through passkeys, OAuth 2.1, and external providers, with role-based access control and fine-grained permission scopes. What distinguishes EmDash is its plugin development framework, which supports both native plugins ru

Android Lite ORM is a lightweight object-relational mapping and data persistence framework for Android that simplifies SQLite database operations. It maps Java and Kotlin objects directly to relational database tables using field annotations, eliminating the need for complex SQL statements or configuration files. The library handles data management through concise single-line operations that encapsulate transaction management and SQL generation. It supports recursive relationship mapping to persist nested object graphs and coordinates multiple distinct database file targets across internal a

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

jOOQ is a type-safe SQL query builder for Java that generates code from live database schemas, enabling compile-time validation of SQL syntax and data types. Its core identity is built around a fluent DSL that mirrors SQL structure, a code generator that maps tables, views, and routines to Java objects, and a multi-dialect engine that translates the same DSL into vendor-specific SQL for over 30 databases. The project also includes a SQL parser and transformer for refactoring or dialect conversion, reactive stream integration for non-blocking query execution, and a JDBC proxy diagnostics tool f

ihp is a type-safe web framework and full-stack application orchestrator designed for PostgreSQL. It functions as a server-side rendering framework and a type-safe ORM that automatically generates record types from SQL schemas to ensure compile-time query validation. The platform distinguishes itself by verifying routing, database queries, and templates at compile time to prevent runtime crashes. It implements real-time web interfaces using WebSockets for instant data synchronization and employs server-driven hypermedia for partial DOM patching. The framework covers a broad range of integrat