Struct Client 

pub struct Client<E>
where
    E: Executor,
{ /* private fields */ }

A Client holding both a Dialect (for SQL rendering) and an Executor (for query execution).

The Client uses Arc internally, making it cheap to clone and thread-safe. This allows the same client to be shared across multiple parts of your application.

The Client is generic over the Executor type to work around limitations with trait objects and Generic Associated Types (GATs).

Example

let client = Client::postgres("postgres://user:pass@localhost/db").await?;
// client can now be cloned and passed around cheaply
let clone = client.clone();

Implementations

impl<E> Client<E>

where E: Executor,

pub fn new<D>(dialect: D, executor: E) -> Self

where D: Dialect + Send + Sync + 'static,

Creates a new Client from a dialect and an executor.

This is the generic constructor that works with any Dialect and Executor implementation.

Example

let executor = PgExecutor::new("postgres://localhost/mydb").await?;
let dialect = PostgresDialect;
let client = Client::new(dialect, executor);

pub fn dialect(&self) -> &(dyn Dialect + Send + Sync)

Returns a reference to the underlying Dialect.

Use this to render queries into SQL.

pub fn executor(&self) -> &E

Returns a reference to the underlying Executor.

Use this to execute rendered SQL queries against the database.

impl Client<PgExecutor>

Convenience constructors for specific database backends.

pub async fn postgres(url: &str) -> Result<Self>

Creates a new PostgreSQL client.

This is a convenience constructor that creates both a PostgresDialect and a PgExecutor, then wraps them in a Client.

Arguments

• url - PostgreSQL connection string (e.g., “postgres://user:pass@localhost/db”)

Example

let client = Client::postgres("postgres://localhost/mydb").await?;

pub async fn postgres_with_options( url: &str, pool_options: ConnectorPoolOptions, ) -> Result<Self>

Creates a new PostgreSQL client with explicit pool overrides.

pub async fn transaction<F, Fut, T>( &self, opts: TransactionOptions, f: F, ) -> Result<T>

where F: FnOnce(Client<TransactionExecutor>) -> Fut, Fut: Future<Output = Result<T>> + Send, T: Send + 'static,

Execute an async closure inside a database transaction.

The closure receives a Client<TransactionExecutor> whose queries all run on the same underlying connection. If the closure returns Ok, the transaction is committed; if it returns Err (or panics), the transaction is rolled back.

Example

let client = Client::postgres("postgres://localhost/mydb").await?;
let result = client.transaction(Default::default(), |tx| Box::pin(async move {
    // tx.executor() runs queries inside the transaction
    Ok(42)
})).await?;

impl Client<MysqlExecutor>

Convenience constructor for MySQL.

pub async fn mysql(url: &str) -> Result<Self>

Creates a new MySQL client.

This is a convenience constructor that creates both a MysqlDialect and a MysqlExecutor, then wraps them in a Client.

Arguments

• url - MySQL connection string (e.g., “mysql://user:pass@localhost/db”)

Example

let client = Client::mysql("mysql://user:pass@localhost/mydb").await?;

pub async fn mysql_with_options( url: &str, pool_options: ConnectorPoolOptions, ) -> Result<Self>

Creates a new MySQL client with explicit pool overrides.

pub async fn transaction<F, Fut, T>( &self, opts: TransactionOptions, f: F, ) -> Result<T>

where F: FnOnce(Client<TransactionExecutor>) -> Fut, Fut: Future<Output = Result<T>> + Send, T: Send + 'static,

Execute an async closure inside a MySQL transaction.

See Client::<PgExecutor>::transaction for full documentation.

impl Client<SqliteExecutor>

Convenience constructor for SQLite.

pub async fn sqlite(url: &str) -> Result<Self>

Creates a new SQLite client.

This is a convenience constructor that creates both a SqliteDialect and a SqliteExecutor, then wraps them in a Client.

Arguments

• url - SQLite connection URL (e.g., sqlite:mydb.db or sqlite::memory:)

Example

let client = Client::sqlite("sqlite::memory:").await?;

pub async fn sqlite_with_options( url: &str, pool_options: ConnectorPoolOptions, ) -> Result<Self>

Creates a new SQLite client with explicit pool overrides.

pub async fn transaction<F, Fut, T>( &self, opts: TransactionOptions, f: F, ) -> Result<T>

where F: FnOnce(Client<TransactionExecutor>) -> Fut, Fut: Future<Output = Result<T>> + Send, T: Send + 'static,

Execute an async closure inside a SQLite transaction.

See Client::<PgExecutor>::transaction for full documentation. SQLite ignores TransactionOptions::isolation_level because it does not support SET TRANSACTION ISOLATION LEVEL.

Trait Implementations

impl<E> Clone for Client<E>

where E: Executor,

fn clone(&self) -> Self

Cloning a Client is cheap - it only clones the Arc pointers, not the underlying data.

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

Performs copy-assignment from source.