Struct DatabaseConnection 

pub struct DatabaseConnection { /* private fields */ }

Available on crate feature database and native only.

Database connection wrapper

Implementations

impl DatabaseConnection

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

Creates a new instance.

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

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 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 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 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>

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

Performs the backend operation.

pub fn inner(&self) -> &DatabaseConnection

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

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>

Execute a SQL query and return a single row

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

Execute a SQL query and return an optional row

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

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

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

Execute a SQL query and return all rows

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

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>

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>

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>

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>

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>

Release a savepoint

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

Rollback to a savepoint

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

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>

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).