Struct PGRobustClient 

pub struct PGRobustClient<TLS> { /* private fields */ }

Implementations

impl<TLS> PGRobustClient<TLS>

where TLS: MakeTlsConnect<Socket> + Clone, <TLS as MakeTlsConnect<Socket>>::Stream: Send + Sync + 'static,

pub async fn spawn( config: PGRobustClientConfig<TLS>, ) -> PGResult<PGRobustClient<TLS>>

Connects to the database and returns a new client.

pub fn config(&self) -> &PGRobustClientConfig<TLS>

Returns a reference to the config object used to create this client.

pub fn config_mut(&mut self) -> &mut PGRobustClientConfig<TLS>

Returns a mutable reference to the config object used to create this client. Some changes only take effect on the next connection. Others are immediate.

pub async fn cancel_query(&mut self) -> PGResult<()>

Cancels any query in-progress.

This is the only function that does not take a timeout nor does it attempt to reconnect if the connection is lost. It will simply return the original error.

pub fn capture_and_clear_log(&mut self) -> Vec<PGMessage>

Returns the log messages captured since the last call to this function. It also clears the log.

pub async fn with_captured_log<F, T>( &mut self, f: F, ) -> PGResult<(T, Vec<PGMessage>)>

where F: AsyncFn(&mut Self) -> PGResult<T>,

Given an async closure taking the postgres client, returns the result of said closure along with the accumulated log since the beginning of the closure.

If you use query pipelining then collect the logs for all queries in the pipeline. Otherwise, the logs might not be what you expect.

pub async fn wrap_reconnect<T>( &mut self, max_dur: Option<Duration>, factory: impl AsyncFn(&mut PGClient) -> Result<T, Error>, ) -> PGResult<T>

Wraps most calls that use the client with a timeout and reconnect loop.

If you loose the connection during a query, the client will automatically reconnect and retry the query.

pub async fn subscribe_notify( &mut self, channels: &[impl AsRef<str> + Send + Sync + 'static], timeout: Option<Duration>, ) -> PGResult<()>

pub async fn unsubscribe_notify( &mut self, channels: &[impl AsRef<str> + Send + Sync + 'static], timeout: Option<Duration>, ) -> PGResult<()>

pub async fn unsubscribe_notify_all( &mut self, timeout: Option<Duration>, ) -> PGResult<()>

Unsubscribes from all channels.

pub async fn execute_raw<P, I, T>( &mut self, statement: &T, params: I, timeout: Option<Duration>, ) -> PGResult<u64>

where T: ?Sized + ToStatement + Sync + Send, P: BorrowToSql + Clone + Send + Sync, I: IntoIterator<Item = P> + Sync + Send, I::IntoIter: ExactSizeIterator,

Like [Client::execute_raw].

pub async fn query<T>( &mut self, query: &T, params: &[&(dyn ToSql + Sync)], timeout: Option<Duration>, ) -> PGResult<Vec<Row>>

where T: ?Sized + ToStatement + Sync + Send,

Like [Client::query].

pub async fn query_one<T>( &mut self, statement: &T, params: &[&(dyn ToSql + Sync)], timeout: Option<Duration>, ) -> PGResult<Row>

where T: ?Sized + ToStatement + Sync + Send,

Like [Client::query_one].

pub async fn query_opt<T>( &mut self, statement: &T, params: &[&(dyn ToSql + Sync)], timeout: Option<Duration>, ) -> PGResult<Option<Row>>

where T: ?Sized + ToStatement + Sync + Send,

Like [Client::query_opt].

pub async fn query_raw<T, P, I>( &mut self, statement: &T, params: I, timeout: Option<Duration>, ) -> PGResult<RowStream>

where T: ?Sized + ToStatement + Sync + Send, P: BorrowToSql + Clone + Send + Sync, I: IntoIterator<Item = P> + Sync + Send, I::IntoIter: ExactSizeIterator,

Like [Client::query_raw].

pub async fn query_typed( &mut self, statement: &str, params: &[(&(dyn ToSql + Sync), Type)], timeout: Option<Duration>, ) -> PGResult<Vec<Row>>

Like [Client::query_typed]

pub async fn query_typed_raw<P, I>( &mut self, statement: &str, params: I, timeout: Option<Duration>, ) -> PGResult<RowStream>

where P: BorrowToSql + Clone + Send + Sync, I: IntoIterator<Item = (P, Type)> + Sync + Send,

Like [Client::query_typed_raw]

pub async fn prepare( &mut self, query: &str, timeout: Option<Duration>, ) -> PGResult<Statement>

Like [Client::prepare].

pub async fn prepare_typed( &mut self, query: &str, parameter_types: &[Type], timeout: Option<Duration>, ) -> PGResult<Statement>

Like [Client::prepare_typed].

pub async fn transaction<F>( &mut self, timeout: Option<Duration>, f: F, ) -> PGResult<()>

where for<'a> F: AsyncFn(&'a mut Transaction<'_>) -> Result<(), Error>,

Similar but not quite the same as [Client::transaction].

Executes the closure as a single transaction. Commit is automatically called after the closure. If any connection issues occur during the transaction then the transaction is rolled back (on drop) and retried a new with the new connection subject to the maximum number of reconnect attempts.

pub async fn batch_execute( &mut self, query: &str, timeout: Option<Duration>, ) -> PGResult<()>

Like [Client::batch_execute].

pub async fn simple_query( &mut self, query: &str, timeout: Option<Duration>, ) -> PGResult<Vec<SimpleQueryMessage>>

Like [Client::simple_query].

pub fn client(&self) -> &Client

Returns a reference to the underlying tokio_postgres::Client.