Struct DatabaseConnection 

pub struct DatabaseConnection { /* private fields */ }

Database connection wrapper

Implementations

impl DatabaseConnection

pub fn new( backend: DatabaseBackend, inner: DatabaseConnection, ) -> DatabaseConnection

Available on native and crate feature database only.

Creates a new instance.

pub async fn connect(url: &str) -> Result<DatabaseConnection, Error>

Available on native and crate feature database only.

Connect to a database from a connection URL

Automatically detects the database type from the URL scheme:

• postgres:// or postgresql:// → PostgreSQL
• mysql:// → MySQL
• sqlite:// or sqlite: → SQLite

Examples

use reinhardt_db::orm::connection::DatabaseConnection;

let conn = DatabaseConnection::connect("postgres://localhost/mydb").await.unwrap();

pub async fn connect_postgres(url: &str) -> Result<DatabaseConnection, Error>

Available on native and crate feature database and crate feature postgres only.

Connect to a PostgreSQL database

Examples

use reinhardt_db::orm::connection::DatabaseConnection;

let conn = DatabaseConnection::connect_postgres("postgres://localhost/mydb").await.unwrap();

pub async fn connect_mysql(url: &str) -> Result<DatabaseConnection, Error>

Available on native and crate feature database and crate feature mysql only.

Connect to a MySQL database

Examples

use reinhardt_db::orm::connection::DatabaseConnection;

let conn = DatabaseConnection::connect_mysql("mysql://localhost/mydb").await.unwrap();

pub async fn connect_sqlite(url: &str) -> Result<DatabaseConnection, Error>

Available on native and crate feature database and crate feature sqlite only.

Connect to a SQLite database

Examples

use reinhardt_db::orm::connection::DatabaseConnection;

let conn = DatabaseConnection::connect_sqlite("sqlite::memory:").await.unwrap();

pub async fn connect_with_pool_size( url: &str, pool_size: Option<u32>, ) -> Result<DatabaseConnection, Error>

Available on native and crate feature database only.

Connect to a database with a specific connection pool size

Arguments

• url - Database connection URL
• pool_size - Maximum number of connections in the pool (None = use default)

Examples

use reinhardt_db::orm::connection::DatabaseConnection;

// Use larger pool for high-concurrency scenarios
let conn = DatabaseConnection::connect_with_pool_size(
    "postgres://localhost/mydb",
    Some(50)
).await.unwrap();

pub fn backend(&self) -> DatabaseBackend

Available on native and crate feature database only.

Performs the backend operation.

pub fn inner(&self) -> &DatabaseConnection

Available on native and crate feature database only.

Get a reference to the inner backends connection

This provides access to the low-level connection for operations that require direct database access.

pub fn into_inner(self) -> DatabaseConnection

Available on native and crate feature database only.

Consume self and return the inner backends connection

This is useful when you need to pass ownership of the connection to functions that expect a BackendsConnection.

pub async fn query_one( &self, sql: &str, params: Vec<QueryValue>, ) -> Result<QueryRow, Error>

Available on native and crate feature database only.

Execute a SQL query and return a single row

pub async fn query_optional( &self, sql: &str, params: Vec<QueryValue>, ) -> Result<Option<QueryRow>, Error>

Available on native and crate feature database only.

Execute a SQL query and return an optional row

pub async fn execute( &self, sql: &str, params: Vec<QueryValue>, ) -> Result<u64, Error>

Available on native and crate feature database only.

Execute a SQL statement (INSERT, UPDATE, DELETE, etc.)

pub async fn query( &self, sql: &str, params: Vec<QueryValue>, ) -> Result<Vec<QueryRow>, Error>

Available on native and crate feature database only.

Execute a SQL query and return all rows

pub async fn begin_transaction(&self) -> Result<(), Error>

Available on native and crate feature database only.

Begin a database transaction

Examples

use reinhardt_db::orm::connection::DatabaseConnection;

let conn = DatabaseConnection::connect("sqlite::memory:").await.unwrap();
let result = conn.begin_transaction().await;
assert!(result.is_ok());

pub async fn begin_transaction_with_isolation( &self, level: IsolationLevel, ) -> Result<(), Error>

Available on native and crate feature database only.

Begin a transaction with a specific isolation level

Examples

use reinhardt_db::orm::connection::DatabaseConnection;
use reinhardt_db::orm::transaction::IsolationLevel;

let conn = DatabaseConnection::connect("sqlite::memory:").await.unwrap();
let result = conn.begin_transaction_with_isolation(IsolationLevel::Serializable).await;
assert!(result.is_ok());

pub async fn commit_transaction(&self) -> Result<(), Error>

Available on native and crate feature database only.

Commit the current transaction

Examples

use reinhardt_db::orm::connection::DatabaseConnection;

let conn = DatabaseConnection::connect("sqlite::memory:").await.unwrap();
conn.begin_transaction().await.unwrap();
// ... perform operations ...
let result = conn.commit_transaction().await;
assert!(result.is_ok());

pub async fn rollback_transaction(&self) -> Result<(), Error>

Available on native and crate feature database only.

Rollback the current transaction

Examples

use reinhardt_db::orm::connection::DatabaseConnection;

let conn = DatabaseConnection::connect("sqlite::memory:").await.unwrap();
conn.begin_transaction().await.unwrap();
// ... error occurs ...
let result = conn.rollback_transaction().await;
assert!(result.is_ok());

pub async fn savepoint(&self, name: &str) -> Result<(), Error>

Available on native and crate feature database only.

Create a savepoint for nested transactions

Examples

use reinhardt_db::orm::connection::DatabaseConnection;

let conn = DatabaseConnection::connect("sqlite::memory:").await.unwrap();
conn.begin_transaction().await.unwrap();
let result = conn.savepoint("sp1").await;
assert!(result.is_ok());
// ... nested operations ...
conn.release_savepoint("sp1").await.unwrap();

pub async fn release_savepoint(&self, name: &str) -> Result<(), Error>

Available on native and crate feature database only.

Release a savepoint

pub async fn rollback_to_savepoint(&self, name: &str) -> Result<(), Error>

Available on native and crate feature database only.

Rollback to a savepoint

pub async fn begin(&self) -> Result<Box<dyn TransactionExecutor>, Error>

Available on native and crate feature database only.

Begin a database transaction and return a dedicated executor

This method acquires a dedicated database connection and begins a transaction on it. All queries executed through the returned TransactionExecutor are guaranteed to run on the same physical connection, ensuring proper transaction isolation.

Returns

A boxed TransactionExecutor that holds the dedicated connection and provides methods for executing queries within the transaction.

Example

use reinhardt_db::orm::connection::DatabaseConnection;

let conn = DatabaseConnection::connect("postgres://localhost/mydb").await?;
let mut tx = conn.begin().await?;

tx.execute("INSERT INTO users (name) VALUES ($1)", vec!["Alice".into()]).await?;
tx.commit().await?;

pub async fn begin_with_isolation( &self, level: IsolationLevel, ) -> Result<Box<dyn TransactionExecutor>, Error>

Available on native and crate feature database only.

Begin a transaction with a specific isolation level using TransactionExecutor

This method returns a TransactionExecutor that provides dedicated connection semantics with the specified isolation level. All queries executed through the returned executor are guaranteed to run on the same physical connection.

Arguments

• level - The desired isolation level for the transaction

Examples

use reinhardt_db::orm::connection::{DatabaseConnection, IsolationLevel};

let conn = DatabaseConnection::connect("postgres://localhost/mydb").await?;
let mut tx = conn.begin_with_isolation(IsolationLevel::Serializable).await?;

tx.execute("INSERT INTO users (name) VALUES ($1)", vec!["Alice".into()]).await?;
tx.commit().await?;

Trait Implementations

impl Clone for DatabaseConnection

fn clone(&self) -> DatabaseConnection

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl DatabaseExecutor for DatabaseConnection

fn execute<'life0, 'life1, 'async_trait>( &'life0 self, sql: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, DatabaseConnection: 'async_trait,

Executes a SQL statement and returns the number of affected rows.

fn query<'life0, 'life1, 'async_trait>( &'life0 self, sql: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<QueryRow>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, DatabaseConnection: 'async_trait,

Executes a SQL query and returns the resulting rows.

impl Injectable for DatabaseConnection

Injectable implementation for DatabaseConnection

DatabaseConnection must be explicitly registered in the DI context using InjectionContextBuilder::singleton(). It cannot be auto-injected because it requires runtime configuration (connection URL, pool settings, etc.).

Example

use reinhardt_db::orm::DatabaseConnection;
use reinhardt_di::InjectionContext;

// First, establish a database connection
let db = DatabaseConnection::connect("postgres://localhost/mydb").await.unwrap();

// Then register it in the DI context as a singleton
let singleton_scope = reinhardt_di::SingletonScope::new();
let ctx = InjectionContext::builder(singleton_scope)
    .singleton(db)
    .build();

fn inject<'life0, 'async_trait>( ctx: &'life0 InjectionContext, ) -> Pin<Box<dyn Future<Output = Result<DatabaseConnection, DiError>> + Send + 'async_trait>>

where 'life0: 'async_trait, DatabaseConnection: 'async_trait,

Creates an instance of this type by resolving dependencies from the injection context.

fn inject_uncached<'life0, 'async_trait>( ctx: &'life0 InjectionContext, ) -> Pin<Box<dyn Future<Output = Result<DatabaseConnection, DiError>> + Send + 'async_trait>>

where 'life0: 'async_trait, DatabaseConnection: 'async_trait,

Inject without using cache (for cache = false support).