Struct postgres_query::Caching

pub struct Caching<C> where
    C: GenericClient,  { /* fields omitted */ }

A client wrapper which caches prepared queries.

Only queries prepared through the GenericClient::prepare_static trait method are actually cached.

Methods

impl<C> Caching<C> where
    C: GenericClient, 

pub fn new(client: C) -> Caching<C>

Wrap a client in a new cache.

pub fn into_inner(self) -> C

Return the inner client.

impl Caching<Client>

pub async fn transaction<'_, '_>(
    &'_ mut self
) -> Result<Caching<Transaction<'_>>, Error>

Start a new transaction that shares the same cache as the current client.

impl<'_> Caching<Transaction<'_>>

pub async fn transaction<'_, '_>(
    &'_ mut self
) -> Result<Caching<Transaction<'_>>, Error>

Start a new transaction that shares the same cache as the current client.

Trait Implementations

impl<C: Clone> Clone for Caching<C> where
    C: GenericClient, 

fn clone(&self) -> Caching<C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<C> Deref for Caching<C> where
    C: GenericClient, 

type Target = C

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<C> DerefMut for Caching<C> where
    C: GenericClient, 

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<C> From<C> for Caching<C> where
    C: GenericClient, 

fn from(client: C) -> Self

Performs the conversion.

impl<C> GenericClient for Caching<C> where
    C: GenericClient + Sync + Send, 

fn prepare<'life0, 'life1, 'async_trait>(
    &'life0 self,
    sql: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<Statement, SqlError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Prepare a SQL query for execution. See [Client::prepare] for more info.

fn prepare_static<'life0, 'async_trait>(
    &'life0 self,
    sql: &'static str
) -> Pin<Box<dyn Future<Output = Result<Statement, SqlError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Implementors may choose to override this method if they, for whatever reason (performance being one), want to cache a specific query.

fn execute_raw<'a, 'life0, 'life1, 'async_trait>(
    &'a self,
    statement: &'life0 Statement,
    parameters: &'life1 [&'a (dyn ToSql + Sync)]
) -> Pin<Box<dyn Future<Output = Result<u64, SqlError>> + Send + 'async_trait>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Execute the given statement with the parameters specified and return the number of affected rows. See [Client::execute_raw] for more info.

fn query_raw<'a, 'life0, 'life1, 'async_trait>(
    &'a self,
    statement: &'life0 Statement,
    parameters: &'life1 [&'a (dyn ToSql + Sync)]
) -> Pin<Box<dyn Future<Output = Result<RowStream, SqlError>> + Send + 'async_trait>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Execute the given statement with the parameters specified and return the resulting rows as an asynchronous stream. See [Client::query_raw] for more info.