Crate reinhardt_db 

Reinhardt Database

Django-style database layer for Reinhardt framework.

This crate provides a unified database abstraction that combines:

• Database Backends: Low-level database operations
• Connection Pooling: Advanced connection pool management
• ORM: Django-style ORM for database queries
• Migrations: Database schema migration system
• Hybrid Types: Common database type abstractions
• Associations: Relationship management between models

Equivalent to Django’s django.db package.

Features

Database Backends (backends module)

• Schema Editor Abstraction: Unified BaseDatabaseSchemaEditor trait
• Database-Specific Implementations: PostgreSQL, MySQL, SQLite support
• DDL Operations: CREATE TABLE, ALTER TABLE, CREATE INDEX, etc.
• Query Builder: Type-safe query construction

Connection Pooling (pool module)

• Advanced Pooling: SQLAlchemy-inspired connection pool management
• Dependency Injection: Integration with Reinhardt DI system
• Event Listeners: Connection lifecycle hooks
• Pool Configuration: Fine-grained control over pool behavior

ORM (orm module)

• Django-style Models: Define database models with structs
• QuerySet API: Chainable query builder
• Field Types: Rich set of field types with validation
• Relationships: ForeignKey, ManyToMany, OneToOne

Migrations (migrations module)

• Schema Migrations: Track and apply database schema changes
• Auto-detection: Automatically detect model changes
• Migration Files: Generate migration files from model changes
• Rollback Support: Reverse migrations when needed
• MigrationStateLoader: Django-style approach for building ProjectState
  • Replays applied migrations to reconstruct schema state
  • Enables accurate change detection without database introspection
  • Used internally by makemigrations command

Available Database Backends

The backends crate provides multiple database backend implementations:

• PostgreSQL: Full support with connection pooling
• MySQL: Full support with connection pooling
• SQLite: Full support with connection pooling
• CockroachDB: Distributed transaction support

Optimization Features ✅

• Connection Pool Optimization: Idle timeout, dynamic sizing, health checks
• Query Caching: LRU cache with TTL for prepared statements and results
• Batch Operations: Efficient bulk insert, update, and delete operations

Enhanced Migration Tools ✅

• Schema Diff Detection: Automatic detection of schema changes between DB and models
• Auto-Migration Generation: Generate migration files from detected differences
• Migration Validation: Pre-execution validation with data loss warnings
• Rollback Script Generation: Automatic rollback operations for safe migrations

Quick Start

Using Schema Editor

use reinhardt_db::backends::schema::factory::{SchemaEditorFactory, DatabaseType};
use reinhardt_query::prelude::{PostgresQueryBuilder, QueryStatementBuilder};

let factory = SchemaEditorFactory::new_postgres(pool);
let editor = factory.create_for_database(DatabaseType::PostgreSQL);

let stmt = editor.create_table_statement("users", &[
    ("id", "INTEGER PRIMARY KEY"),
    ("name", "VARCHAR(100)"),
]);
let sql = stmt.to_string(PostgresQueryBuilder);

Using Connection Pool

use reinhardt_db::pool::{ConnectionPool, PoolConfig};

let pool = ConnectionPool::new_postgres("postgres://localhost/mydb", PoolConfig::default()).await?;
let conn = pool.acquire().await?;

Feature Flags

• backends (default): Database backend abstractions
• pool (default): Connection pooling support
• orm (default): ORM functionality
• migrations (default): Migration system
• hybrid (default): Hybrid type system
• associations (default): Association management
• postgres (default): PostgreSQL support
• sqlite: SQLite support
• mysql: MySQL support
• all-databases: Enable all database backends

Re-exports

pub use backends::DatabaseBackend;

pub use backends::DatabaseError;

pub use orm::DatabaseConnection;

pub use pool::ConnectionPool;

pub use pool::PoolConfig;

pub use pool::PoolError;

Modules

associations

Association proxies for Reinhardt

backends

Reinhardt Database Backends

backends_pool

Connection pooling with advanced lifecycle management

contenttypes

Reinhardt ContentTypes

hybrid

Hybrid properties for Reinhardt

migrations

Reinhardt Migrations

orm

Reinhardt ORM

pool

Database connection pooling for Reinhardt

prelude

Prelude module for convenient imports

Macros

hybrid_property

Macro for defining hybrid properties