Bun

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

The library covers a broad range of data operations, including bulk processing, upserts, soft deletes, and the management of relational data such as polymorphic associations. It provides capabilities for advanced SQL analytics using common table expressions and window functions, alongside atomic transaction management and connection pooling.

Schema management is supported via a command-line interface for applying versioned migration scripts.

Features

Fluent Query Builders - Provides a chainable, functional interface for constructing complex SQL statements through a programmable API.
SQL Query Building - Provides a programmable fluent API for the incremental construction of complex SQL statements.
Go Struct Mappings - Maps database tables to Go structs to facilitate type-safe data retrieval and insertion.
Row-to-Struct Mappers - Automatically transforms database result sets into strongly-typed Go structures by matching columns to fields.
Connection and Transaction Management - Manages database connection pools and ensures atomic transaction consistency across operations.
Atomic Transactions - Ensures data consistency by executing a series of database operations as a single atomic unit.
Database Relationship Mappings - Defines declarative associations between data models including support for custom join columns.
Type-Safe Query Construction - Provides a type-safe fluent API that maps database results directly into typed Go structures.
Row Result Scanning - Maps database row values into typed Go structures by analyzing field metadata at runtime via reflection.
Record Deletion - Removes specific rows from a database table based on a defined model and query criteria.
Record Insertion - Adds new rows to database tables using type-safe models to ensure data integrity.
Record Updating - Modifies existing database rows using models or maps with support for omitting zero-value fields.
Relational Table Associations - Manages associations between tables and automatically generates SQL JOIN clauses for related data retrieval.
Row-to-Struct Mapping - Scans database rows into structs, maps, or slices to convert raw SQL output into usable data.
SQL Dialect Adapters - Uses a consistent interface to interact with various SQL databases using a single codebase via dialect adapters.
Dialect-Specific SQL Generation - Implements translation of abstract query requests into SQL strings tailored to specific database versions and dialects.
SQL ORMs - Functions as a type-safe object relational mapper for Go, prioritizing SQL-first construction and result mapping.
SQL Query Builders - Provides a programmable interface for composing complex SQL statements across multiple dialects.
Struct-to-Table Mappings - Defines declarative mappings that determine how Go structs correspond to database table columns and behaviors.
Type-Safe Query Builders - Provides a programmable query builder that ensures compile-time type safety for database operations.
Parameterized Query Bindings - Implements parameterized query bindings to prevent SQL injection and ensure secure data handling.
Struct Tags - Uses Go struct tags to define the relationship between application models and database table columns.
Type-Safe Row Scanning - Scans database output into specific typed structures for flexible and safe data handling.
SQL Query Type Validation - Ensures SQL queries are constructed with static typing to provide compile-time safety across different dialects.
Bulk Data Operations - Executes high-performance batch inserts, updates, and deletes on large datasets.
Common Table Expressions - Implements support for recursive and non-recursive common table expressions using WITH clauses.
Custom SQL Execution - Allows the execution of manually crafted, parameterized SQL statements within the persistence layer.
Cursor-Based Pagination - Implements high-performance data retrieval using unique record pointers for memory-efficient iteration.
Batch Insert, Update, or Delete Operations - Synchronizes data by performing combined insert, update, or delete operations in a single SQL statement.
Schema Versioning - Implements versioned changes to database structures using standalone SQL files or Go functions.
Schema Migration Scripts - Supports the registration and application of ordered migration scripts to evolve database structures.
Application Type Mappings - Implements custom conversion logic to translate application-level objects into database-specific data formats via scanning interfaces.
CLI Schema Management - Includes a command-line interface for managing and applying versioned schema migrations.
Database Transaction Wrappers - Wraps standard SQL transaction objects to integrate the type-safe query builder with existing transaction logic.
Database Query Interceptors - Provides hooks to intercept and modify database queries for logging, monitoring, and auditing purposes.
Row Mapping Logic - Provides custom hooks to execute logic during the conversion of database rows into application objects.
Connection Pooling - Maintains a pool of idle connections and handles the automatic creation and release of database sessions.
JSON Column Support - Stores and queries semi-structured data using JSON and JSONB column types in compatible databases.
Multi-Database Connections - Orchestrates multiple independent database connection pools within a single application runtime.
Raw SQL Execution - Enables execution of raw, manually crafted SQL strings and scanning results directly into types.
Advanced SQL Construct Execution - Provides execution support for advanced SQL features like window functions and common table expressions.
Raw SQL Result Mapping - Maps the results of raw SQL executions into typed Go structures for flexible data retrieval.
Polymorphic Relations - Implements associations where a model can belong to multiple other models using a virtual type column.
SQL IN Clause Generation - The project isolates rows where a column value matches any element in a provided list or subquery.
SQL Performance Analysis - Provides instrumentation and hooks to monitor query execution and identify performance bottlenecks in production.
Subquery Execution - Supports embedding subqueries within other queries to use inner results as filters.
Table Joining Operations - Provides capabilities for combining rows from multiple tables using various SQL join types.
WHERE Clause Builders - Implements builders for constructing safe SQL WHERE clauses using placeholders and logical groupings.
CTE-Based Bulk Updates - Updates multiple records efficiently by utilizing common table expressions to apply changes in one operation.
Upsert Operations - Provides atomic operations to insert a new record or update an existing one based on key conflicts.
Database Schema Migrations - Includes a system for versioning and applying structural changes to database schemas to maintain environment consistency.
Database Migration Tools - Ships a tool for managing and applying versioned schema changes to SQL databases via scripts.
Query Lifecycle Hooks - Provides pre- and post-execution hooks to intercept the query lifecycle for logging, tracing, and auditing.
Distributed Tracing Instrumentation - Integrates standard distributed tracing instrumentation to monitor production database workloads.
Database Query Observability - Implements a query interception system for distributed tracing and logging of SQL performance.
Database Query Tracing - Captures SQL statements and connection details within distributed tracing contexts to monitor performance.
Query Execution Hooks - Implements a hook system to intercept and modify database query execution sequences for logging and processing.
Database Tools - SQL-first ORM for multiple databases.

simolus3/drift

3,231View on GitHub

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

go-xorm/xorm

6,628View on GitHub

xorm is a relational mapper and object-relational mapping tool for Go. It translates Go structures into SQL queries and maps database rows back into native objects, providing a multi-dialect database driver that supports MySQL, PostgreSQL, SQLite, Oracle, SQL Server, and TiDB. The project features a read-write splitting manager that routes modification requests to a primary database and read requests to replicas. It includes a database schema synchronizer to automatically align table structures and indexes with application data models, as well as a fluent SQL query builder for constructing co

go-pg/pg

5,785View on GitHub

pg is a PostgreSQL object-relational mapper (ORM) for Go that maps Go structs to database tables and provides a fluent query builder for constructing SQL statements programmatically. At its core, it automatically generates CREATE TABLE statements from Go struct definitions using struct tags and naming conventions, and builds queries through method chaining with placeholder-based parameter binding to prevent SQL injection. The library distinguishes itself through relation-aware join generation that automatically constructs JOIN clauses for has-one, has-many, many-to-many, and polymorphic assoc

linq2db/linq2db

3,239View on GitHub

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

uptracebun

Features