gaarason/database-all

Features

• CRUD Operations - Provides a comprehensive interface for performing CRUD operations on database records with protection against accidental mass updates.
• Object-Relational Mapping Frameworks - Maps relational database tables to Java objects using annotations to simplify data interaction and persistence.
• Active Record Mappers - Provides an active record implementation that binds database records directly to object-oriented models for simplified data access.
• Spring Boot Database Access - Integrates database operations into Spring Boot applications with support for lifecycle events and transaction management.
• Fluent Query Construction - Constructs complex database queries using a type-safe fluent interface that handles joins and filtering automatically.
• Fluent Query Builders - Provides a chainable, fluent interface for constructing complex database queries with automatic parameter binding.
• Active-Record ORMs - Implements the active record pattern where models encapsulate data access logic and CRUD operations.
• Relational Association Management - The product updates, removes, or synchronizes associations between records by managing foreign keys or intermediate join table entries.
• Entity Association Annotations - Uses mapping annotations to establish one-to-one, one-to-many, and many-to-many relationships between database models.
• Schema Mappings - Uses class annotations to define mappings between application object fields and underlying database table structures.
• Java Frameworks - Provides a fluent object-relational mapping library for Java and Spring Boot that simplifies database interactions.
• Asynchronous Database Command Execution - Executes database operations in a background thread pool with automatic fallback to synchronous mode during active transactions.
• Query Result Pagination - Provides built-in pagination logic to retrieve large database result sets in smaller, manageable chunks for efficient memory usage.
• Data Source Routing - Directs database queries to specific storage instances or shards based on runtime logic to support multi-tenancy.
• Complex Data Type Mappings - Converts complex types to database-compatible formats during serialization, supporting custom logic and bitwise operations.
• Database Dialects - Detects the underlying database engine and automatically adjusts SQL syntax for pagination, upserts, and identifier quoting.
• Database Object Synchronizations - Updates local object state with current data from the database to ensure consistency after persistence operations.
• Database Query Builders - Provides a fluent API for constructing type-safe SQL queries with support for multiple database dialects.
• Query Scopes - Defines reusable query constraints within model definitions to enforce consistent data access rules across lookups.
• Model Table Mappings - Maps database tables to objects by extending a base model class and configuring data source connections.
• Object-Relational Mapping - Converts database result sets into objects, maps, or custom lists to facilitate data manipulation.
• Polymorphic Associations - Supports polymorphic associations that allow a single model to link to multiple target types using type and ID keys.
• Raw SQL Execution - Allows execution of custom SQL queries directly against the database with secure parameter binding.
• Read and Write Splitting - Distributes database traffic across primary and replica nodes based on query intent to optimize performance.
• Read-Write Splitting - Automatically distributes database operations across primary and replica sources based on query type to optimize performance.
• Eager Loading - The product fetches associated records alongside primary query results to minimize database round-trips and simplify data retrieval.
• Polymorphic Relations - Manages complex entity associations including one-to-many, many-to-many, and polymorphic links with efficient data loading.
• Soft Deletion - Marks records as deleted using status flags instead of physical removal to support data recovery.
• Dialect-Specific SQL Generation - Automatically translates abstract query requests into SQL syntax tailored to specific database engines and versions.
• Lifecycle Event Hooks - Executes custom logic at specific points during database operations to handle tasks before or after record persistence.
• Entity Definition Generators - Automates the generation of type-safe entity classes directly from existing database schema definitions.
• Asynchronous Task Orchestration - Manages database operations using background thread pools to maintain application responsiveness while supporting synchronous transaction modes.
• Lifecycle Event Hooks - Executes custom logic at specific stages of the record persistence lifecycle to automate validation and state synchronization.
• Multi-Database Routing - Routes database queries to specific data sources or read-write replicas to support scalable and multi-tenant architectures.
• Spring Boot Integrations - Provides a database abstraction layer designed for seamless integration with Spring Boot applications.
• Transaction-Aware Event Execution - Ensures lifecycle event handlers only execute after a database transaction has successfully committed to prevent processing rolled-back data.

Star history