fnc12/sqlite_orm
Sqlite Orm
This project is a header-only C++ library that provides an object-relational mapping layer for SQLite databases. It enables developers to map native class structures directly to database tables, facilitating type-safe data persistence and retrieval without the need for raw query strings.
The library distinguishes itself through the use of template-based metaprogramming, which allows for compile-time schema mapping and query construction. By utilizing a fluent interface, it translates method calls into optimized database statements, while its support for prepared statement caching minimizes parsing overhead for repetitive operations. The system also includes automated schema synchronization to ensure that database structures remain consistent with application object definitions.
Beyond core mapping, the library provides a comprehensive suite of database management capabilities, including support for relational joins, aggregate data calculations, and atomic transaction management. It accommodates both persistent storage and volatile, in-memory database configurations. A command-line utility is also provided to assist with project distribution by merging source and header files into consolidated outputs.
Features
- Object-Relational Mapping - Maps C++ classes to SQLite tables for type-safe CRUD operations without raw SQL.
- SQLite ORMs - Provides a header-only C++ object-relational mapping library specifically optimized for SQLite database persistence.
- CRUD Operations - Provides type-safe interfaces for performing create, read, update, and delete operations on database records.
- Object-Relational Mappers - Synchronizes database schema definitions with application class structures to enable type-safe persistence and fluent query construction.
- Fluent Query Builders - Implements a fluent, chainable interface for constructing complex database queries at compile time.
- Query Filters - Enables complex data retrieval with fluent filtering, grouping, and ordering without raw SQL.
- Schema Synchronizers - Synchronizes database structures with native object definitions to maintain schema consistency.
- Type-Safe Object-Relational Mappers - Binds database columns to native language members to ensure type-safe data persistence and retrieval.
- Template Metaprogramming - Uses template metaprogramming to map native classes to database schemas at compile time.
- Aggregate Calculations - Supports built-in aggregate calculations like sums, averages, and counts directly within database queries.
- Transactional Updates - Ensures transactional integrity by grouping operations into atomic units for reliable state updates.
- Prepared Statement Engines - Optimizes database performance by caching prepared statements to minimize parsing overhead.
- Atomic Transactions - Provides atomic transaction management to ensure data consistency through commit and rollback mechanisms.
- Database Query Joins - Supports relational joins by referencing mapped classes directly within database queries.
- Database Transaction Management - Manages database transactions by grouping operations into atomic units with commit and rollback capabilities.
- Type-Safe Query Construction - Facilitates advanced relational querying with joins and aggregations using type-safe C++ syntax.
- In-Memory Databases - Supports volatile, in-memory database configurations for temporary, high-performance data storage.
- Prepared Statement Interfaces - Executes strongly-typed, pre-compiled database statements to improve performance and security.
- SQL Data Access Layers - Provides a type-safe abstraction layer that maps database tables to native C++ data structures for query execution.
