uptrace/bun

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.

Star history