Struct DBAdapterManager 

pub struct DBAdapterManager<'q, DB, T>
where
    DB: Database,
    T: SqlTemplate<'q, DB>,
{ /* private fields */ }

Database adapter manager handling SQL rendering and execution

Generic Parameters

• 'q: Query lifetime
• DB: Database type
• T: SQL template type

Implementations

impl<'q, DB, T> DBAdapterManager<'q, DB, T>

where DB: Database, T: SqlTemplate<'q, DB>,

pub fn new(template: T) -> Self

Creates new adapter with SQL buffer

Arguments

• template - SQL template instance

pub fn sql(&self) -> &String

impl<'q, 'c, 'e, DB, T> DBAdapterManager<'q, DB, T>

where DB: Database + Sync, T: SqlTemplate<'q, DB> + Send + 'q, i64: Encode<'q, DB> + Type<DB>, DB::Arguments<'q>: 'q, 'q: 'e, 'c: 'e,

pub fn set_persistent(self, persistent: bool) -> Self

Configures query persistence (default: true)

pub fn count<Adapter>( &'q mut self, db_adapter: Adapter, ) -> BoxFuture<'e, Result<i64, Error>>

where Adapter: BackendDB<'c, DB> + 'c, (i64,): for<'r> FromRow<'r, DB::Row>,

Executes count query for pagination

Arguments

• db_adapter - Database connection adapter

pub async fn count_page<Adapter>( &'q mut self, page_size: i64, db_adapter: Adapter, ) -> Result<PageInfo, Error>

where Adapter: BackendDB<'c, DB> + 'c, (i64,): for<'r> FromRow<'r, DB::Row>,

Calculates complete pagination metadata

Arguments

• page_size - Records per page
• db_adapter - Database connection adapter

pub fn set_page(self, page_size: i64, page_no: i64) -> Self

Sets pagination parameters

pub async fn execute<Adapter>( &'q mut self, db_adapter: Adapter, ) -> Result<DB::QueryResult, Error>

where Adapter: BackendDB<'c, DB> + 'c,

like sqlx::Query::execute Execute the query and return the number of rows affected.

pub fn execute_many<Adapter>( &'q mut self, db_adapter: Adapter, ) -> impl Stream<Item = Result<DB::QueryResult, Error>>

where Adapter: BackendDB<'c, DB> + 'c,

like sqlx::Query::execute_many Execute multiple queries and return the rows affected from each query, in a stream.

pub fn fetch<Adapter>( &'q mut self, db_adapter: Adapter, ) -> impl Stream<Item = Result<DB::Row, Error>>

where Adapter: BackendDB<'c, DB> + 'c,

like sqlx::Query::fetch Execute the query and return the generated results as a stream.

pub fn fetch_many<Adapter>( &'q mut self, db_adapter: Adapter, ) -> BoxStream<'e, Result<Either<DB::QueryResult, DB::Row>, Error>>

where Adapter: BackendDB<'c, DB> + 'c,

like sqlx::Query::fetch_many Execute multiple queries and return the generated results as a stream.

For each query in the stream, any generated rows are returned first, then the QueryResult with the number of rows affected.

pub async fn fetch_all<Adapter>( &'q mut self, db_adapter: Adapter, ) -> Result<Vec<DB::Row>, Error>

where Adapter: BackendDB<'c, DB> + 'c,

like sqlx::Query::fetch_all Execute the query and return all the resulting rows collected into a Vec.

Note: beware result set size.

This will attempt to collect the full result set of the query into memory.

To avoid exhausting available memory, ensure the result set has a known upper bound, e.g. using LIMIT.

pub async fn fetch_one<Adapter>( &'q mut self, db_adapter: Adapter, ) -> Result<DB::Row, Error>

where Adapter: BackendDB<'c, DB> + 'c,

like sqlx::Query::fetch_one Execute the query, returning the first row or Error::RowNotFound otherwise.

Note: for best performance, ensure the query returns at most one row.

Depending on the driver implementation, if your query can return more than one row, it may lead to wasted CPU time and bandwidth on the database server.

Even when the driver implementation takes this into account, ensuring the query returns at most one row can result in a more optimal query plan.

If your query has a WHERE clause filtering a unique column by a single value, you’re good.

Otherwise, you might want to add LIMIT 1 to your query.

pub async fn fetch_optional<Adapter>( &'q mut self, db_adapter: Adapter, ) -> Result<Option<DB::Row>, Error>

where Adapter: BackendDB<'c, DB> + 'c,

like sqlx::Query::fetch_optional Execute the query, returning the first row or None otherwise.

Note: for best performance, ensure the query returns at most one row.

Depending on the driver implementation, if your query can return more than one row, it may lead to wasted CPU time and bandwidth on the database server.

Even when the driver implementation takes this into account, ensuring the query returns at most one row can result in a more optimal query plan.

If your query has a WHERE clause filtering a unique column by a single value, you’re good.

Otherwise, you might want to add LIMIT 1 to your query.

pub async fn fetch_as<Adapter, O>( &'q mut self, db_adapter: Adapter, ) -> impl Stream<Item = Result<O, Error>>

where Adapter: BackendDB<'c, DB> + 'c, O: Send + Unpin + for<'r> FromRow<'r, DB::Row> + 'e,

like sqlx::QueryAs::fetch Execute the query and return the generated results as a stream.

pub fn fetch_many_as<Adapter, O>( &'q mut self, db_adapter: Adapter, ) -> BoxStream<'e, Result<Either<DB::QueryResult, O>, Error>>

where Adapter: BackendDB<'c, DB> + 'c, O: Send + Unpin + for<'r> FromRow<'r, DB::Row> + 'e, 'q: 'e,

like sqlx::QueryAs::fetch_many Execute multiple queries and return the generated results as a stream from each query, in a stream.

pub async fn fetch_all_as<Adapter, O>( &'q mut self, db_adapter: Adapter, ) -> Result<Vec<O>, Error>

where Adapter: BackendDB<'c, DB> + 'c, O: Send + Unpin + for<'r> FromRow<'r, DB::Row> + 'e,

like sqlx::QueryAs::fetch_all Execute the query and return all the resulting rows collected into a Vec.

Note: beware result set size.

This will attempt to collect the full result set of the query into memory.

To avoid exhausting available memory, ensure the result set has a known upper bound, e.g. using LIMIT.

pub async fn fetch_one_as<Adapter, O>( &'q mut self, db_adapter: Adapter, ) -> Result<O, Error>

where Adapter: BackendDB<'c, DB> + 'c, O: Send + Unpin + for<'r> FromRow<'r, DB::Row> + 'e,

like sqlx::QueryAs::fetch_one Execute the query, returning the first row or Error::RowNotFound otherwise.

Note: for best performance, ensure the query returns at most one row.

Depending on the driver implementation, if your query can return more than one row, it may lead to wasted CPU time and bandwidth on the database server.

Even when the driver implementation takes this into account, ensuring the query returns at most one row can result in a more optimal query plan.

If your query has a WHERE clause filtering a unique column by a single value, you’re good.

Otherwise, you might want to add LIMIT 1 to your query.

pub async fn fetch_optional_as<Adapter, O>( &'q mut self, db_adapter: Adapter, ) -> Result<Option<O>, Error>

where Adapter: BackendDB<'c, DB> + 'c, O: Send + Unpin + for<'r> FromRow<'r, DB::Row>,

like sqlx::QueryAs::fetch_optional Execute the query, returning the first row or None otherwise.

Note: for best performance, ensure the query returns at most one row.

Depending on the driver implementation, if your query can return more than one row, it may lead to wasted CPU time and bandwidth on the database server.

Even when the driver implementation takes this into account, ensuring the query returns at most one row can result in a more optimal query plan.

If your query has a WHERE clause filtering a unique column by a single value, you’re good.

Otherwise, you might want to add LIMIT 1 to your query.