Struct PraxClient 

pub struct PraxClient<E: QueryEngine> { /* private fields */ }

Top-level client grouping every model’s per-model Client<E>.

Implementations

impl<E: QueryEngine> PraxClient<E>

pub fn new(engine: E) -> Self

Create a new top-level client wrapping the given engine.

pub fn engine(&self) -> &E

Borrow the underlying engine. Accessor macros clone it per call.

pub async fn query_raw<T>(&self, sql: Sql) -> QueryResult<Vec<T>>

where T: Model + FromRow + Send + 'static,

Execute a typed raw SQL query, decoding each returned row as T.

The typed Client API covers the common cases, but every ORM eventually hits something it doesn’t yet model — window functions, vendor-specific extensions, recursive CTEs, bespoke aggregates. query_raw is the escape hatch: build a parameterized prax_query::raw::Sql and route the result through the same FromRow bridge the derived models use, so the returned records stay typed.

T must implement both Model (so the driver can associate the query with a table) and FromRow (so each row can be decoded). Both are provided automatically by #[derive(Model)].

use prax_query::raw::Sql;

let users: Vec<User> = client
    .query_raw(
        Sql::new("SELECT id, email FROM users WHERE email = ")
            .bind("alice@example.com"),
    )
    .await?;

pub async fn execute_raw(&self, sql: Sql) -> QueryResult<u64>

Execute a raw statement that doesn’t return rows.

Use this for INSERT / UPDATE / DELETE / DDL when the typed Client API doesn’t model what you need. Returns the driver-reported affected-row count.

use prax_query::raw::Sql;

let n = client
    .execute_raw(
        Sql::new("UPDATE users SET verified = TRUE WHERE id = ")
            .bind(user_id),
    )
    .await?;
assert_eq!(n, 1);

pub async fn transaction<R, Fut, F>(&self, f: F) -> QueryResult<R>

where F: FnOnce(PraxClient<E>) -> Fut + Send + 'static, Fut: Future<Output = QueryResult<R>> + Send + 'static, R: Send + 'static,

Run f inside a single database transaction.

The closure receives a fresh PraxClient<E> whose engine is bound to the in-flight transaction — every typed operation emitted through that client (tx.user().create()..., tx.query_raw(...), etc.) routes through the same BEGIN block. Returning Ok(r) commits and yields Ok(r) back; returning Err(e) rolls back and surfaces e unchanged. Panics bubble through and leave the connection to drop, which aborts the transaction on the server.

use prax_query::error::QueryResult;

let created = client
    .transaction(|tx| async move {
        let u = tx.user().create()
            .set("email", "alice@example.com")
            .exec().await?;
        tx.post().create()
            .set("author_id", u.id)
            .set("title", "hello")
            .exec().await?;
        QueryResult::Ok(u)
    })
    .await?;

Nested transaction() calls on the same engine return QueryError::internal(...) until dialect-aware SAVEPOINT support lands.

Trait Implementations

impl<E: Clone + QueryEngine> Clone for PraxClient<E>

fn clone(&self) -> PraxClient<E>

Returns a duplicate of the value.

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

Performs copy-assignment from source.