Struct Transaction

Source

pub struct Transaction { /* private fields */ }

Expand description

Transaction represents a database transaction

Provides ACID guarantees for a series of database operations. Must be explicitly committed or rolled back.

Implementations§

Source §

impl Transaction

Source

pub fn append_audit_event(&mut self, event: AuditEvent) -> Result<[u8; 16]>

Append one audit event to this transaction. Embedded callers act as the bootstrap principal; server/procedural execution uses its authenticated execution context inside the executor host bridge.

Source

pub fn append_outbox_message( &mut self, message: OutboxMessage, ) -> Result<[u8; 16]>

Append one external side-effect intent to this business transaction.

Source §

impl Transaction

Source

pub fn execute_orm(&mut self, document: &IrDocument) -> OrmResult<i64>

Compile and execute command-like ORM IR inside this transaction.

Source

pub fn query_orm(&mut self, document: &IrDocument) -> OrmResult<Rows>

Compile and execute row-producing ORM IR inside this transaction.

Source

pub fn schema(&mut self) -> EmbeddedSchemaClient<'_>

Borrow this transaction for catalog operations without leaving it.

Source

pub fn entity(&mut self, table: impl Into<String>) -> OrmResult<DynamicEntity>

Source §

impl Transaction

Source

pub fn id(&self) -> i64

Get the transaction ID

Source

pub fn execute<P: Params>(&mut self, sql: &str, params: P) -> Result<i64>

Execute a SQL statement within the transaction

§Parameters

Parameters can be passed using:

Empty tuple () for no parameters
Tuple syntax (1, "Alice", 30) for multiple parameters
params! macro params![1, "Alice", 30]

§Examples

let mut tx = db.begin()?;
tx.execute("INSERT INTO users VALUES ($1, $2)", (1, "Alice"))?;
tx.execute("UPDATE accounts SET balance = balance - $1 WHERE user_id = $2", (100, 1))?;
tx.commit()?;

Source

pub fn execute_with_timeout<P: Params>( &mut self, sql: &str, params: P, timeout_ms: u64, ) -> Result<i64>

Execute a statement in this transaction with a cancellation deadline.

Source

pub fn execute_prepared<P: Params>( &mut self, statement: &Statement, params: P, ) -> Result<i64>

Execute a high-level prepared statement with parameters.

Avoids re-parsing SQL on every call — ideal for batch operations where the same statement is executed many times with different params.

Source

pub fn query_prepared<P: Params>( &mut self, statement: &Statement, params: P, ) -> Result<Rows>

Query using a pre-parsed statement with parameters.

Avoids re-parsing SQL on every call — ideal for batch read operations where the same query is executed many times with different params.

Source

pub fn query<P: Params>(&mut self, sql: &str, params: P) -> Result<Rows>

Execute a query within the transaction

§Examples

let mut tx = db.begin()?;
for row in tx.query("SELECT * FROM users WHERE age > $1", (18,))? {
    let row = row?;
    println!("{}", row.get::<String>("name")?);
}
tx.commit()?;

Source

pub fn query_with_timeout<P: Params>( &mut self, sql: &str, params: P, timeout_ms: u64, ) -> Result<Rows>

Query in this transaction with a cancellation deadline.

Source

pub fn query_one<T: FromValue, P: Params>( &mut self, sql: &str, params: P, ) -> Result<T>

Execute a query and return a single value

§Examples

let mut tx = db.begin()?;
let count: i64 = tx.query_one("SELECT COUNT(*) FROM users", ())?;
tx.commit()?;

Source

pub fn query_opt<T: FromValue, P: Params>( &mut self, sql: &str, params: P, ) -> Result<Option<T>>

Execute a query and return an optional single value

§Examples

let mut tx = db.begin()?;
let name: Option<String> = tx.query_opt("SELECT name FROM users WHERE id = $1", (999,))?;
tx.commit()?;

Source

pub fn execute_named(&mut self, sql: &str, params: NamedParams) -> Result<i64>

Execute a SQL statement with named parameters within the transaction

§Examples

use radixdb::named_params;

let mut tx = db.begin()?;
tx.execute_named(
    "INSERT INTO users VALUES (:id, :name)",
    named_params!{ id: 1, name: "Alice" }
)?;
tx.commit()?;