pub struct Connection<'a>(/* private fields */);Expand description
Wrapper struct over the remote PooledConnection type for dealing with the Store trait.
Trait Implementations§
Source§impl Connection for Connection<'_>
impl Connection for Connection<'_>
Source§fn committer_watermark<'life0, 'async_trait>(
&'life0 mut self,
pipeline: &'static str,
) -> Pin<Box<dyn Future<Output = Result<Option<CommitterWatermark>>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn committer_watermark<'life0, 'async_trait>(
&'life0 mut self,
pipeline: &'static str,
) -> Pin<Box<dyn Future<Output = Result<Option<CommitterWatermark>>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
Given a pipeline, return the committer watermark from the
Store. This is used by the
indexer on startup to determine which checkpoint to resume processing from.Source§fn reader_watermark<'life0, 'async_trait>(
&'life0 mut self,
pipeline: &'static str,
) -> Pin<Box<dyn Future<Output = Result<Option<ReaderWatermark>>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn reader_watermark<'life0, 'async_trait>(
&'life0 mut self,
pipeline: &'static str,
) -> Pin<Box<dyn Future<Output = Result<Option<ReaderWatermark>>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
Given a pipeline, return the reader watermark from the database. This is used by the indexer
to determine the new
reader_lo or inclusive lower bound of available data.Source§fn pruner_watermark<'life0, 'async_trait>(
&'life0 mut self,
pipeline: &'static str,
delay: Duration,
) -> Pin<Box<dyn Future<Output = Result<Option<PrunerWatermark>>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn pruner_watermark<'life0, 'async_trait>(
&'life0 mut self,
pipeline: &'static str,
delay: Duration,
) -> Pin<Box<dyn Future<Output = Result<Option<PrunerWatermark>>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
Get the bounds for the region that the pruner is allowed to prune, and the time in
milliseconds the pruner must wait before it can begin pruning data for the given
pipeline.
The pruner is allowed to prune the region between the returned pruner_hi (inclusive) and
reader_lo (exclusive) after waiting until pruner_timestamp + delay has passed. This
minimizes the possibility for the pruner to delete data still expected by inflight read
requests.Source§fn set_committer_watermark<'life0, 'async_trait>(
&'life0 mut self,
pipeline: &'static str,
watermark: CommitterWatermark,
) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn set_committer_watermark<'life0, 'async_trait>(
&'life0 mut self,
pipeline: &'static str,
watermark: CommitterWatermark,
) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
Upsert the high watermark as long as it raises the watermark stored in the database. Returns
a boolean indicating whether the watermark was actually updated or not.
Source§fn set_reader_watermark<'life0, 'async_trait>(
&'life0 mut self,
pipeline: &'static str,
reader_lo: u64,
) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn set_reader_watermark<'life0, 'async_trait>(
&'life0 mut self,
pipeline: &'static str,
reader_lo: u64,
) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
Update the
reader_lo of an existing watermark entry only if it raises reader_lo. Readers
will reference this as the inclusive lower bound of available data for the corresponding
pipeline. Read moreSource§fn set_pruner_watermark<'life0, 'async_trait>(
&'life0 mut self,
pipeline: &'static str,
pruner_hi: u64,
) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn set_pruner_watermark<'life0, 'async_trait>(
&'life0 mut self,
pipeline: &'static str,
pruner_hi: u64,
) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
Update the pruner watermark, returns true if the watermark was actually updated
Source§impl<'a> Deref for Connection<'a>
impl<'a> Deref for Connection<'a>
Auto Trait Implementations§
impl<'a> Freeze for Connection<'a>
impl<'a> !RefUnwindSafe for Connection<'a>
impl<'a> Send for Connection<'a>
impl<'a> Sync for Connection<'a>
impl<'a> Unpin for Connection<'a>
impl<'a> !UnwindSafe for Connection<'a>
Blanket Implementations§
§impl<C> AsyncConnection for C
impl<C> AsyncConnection for C
§type ExecuteFuture<'conn, 'query> = <<C as Deref>::Target as AsyncConnection>::ExecuteFuture<'conn, 'query>
type ExecuteFuture<'conn, 'query> = <<C as Deref>::Target as AsyncConnection>::ExecuteFuture<'conn, 'query>
The future returned by
AsyncConnection::execute§type LoadFuture<'conn, 'query> = <<C as Deref>::Target as AsyncConnection>::LoadFuture<'conn, 'query>
type LoadFuture<'conn, 'query> = <<C as Deref>::Target as AsyncConnection>::LoadFuture<'conn, 'query>
The future returned by
AsyncConnection::load§type Stream<'conn, 'query> = <<C as Deref>::Target as AsyncConnection>::Stream<'conn, 'query>
type Stream<'conn, 'query> = <<C as Deref>::Target as AsyncConnection>::Stream<'conn, 'query>
The inner stream returned by
AsyncConnection::load§type Row<'conn, 'query> = <<C as Deref>::Target as AsyncConnection>::Row<'conn, 'query>
type Row<'conn, 'query> = <<C as Deref>::Target as AsyncConnection>::Row<'conn, 'query>
The row type used by the stream returned by
AsyncConnection::loadtype TransactionManager = PoolTransactionManager<<<C as Deref>::Target as AsyncConnection>::TransactionManager>
§fn establish<'life0, 'async_trait>(
_database_url: &'life0 str,
) -> Pin<Box<dyn Future<Output = Result<C, ConnectionError>> + Send + 'async_trait>>where
'life0: 'async_trait,
C: 'async_trait,
fn establish<'life0, 'async_trait>(
_database_url: &'life0 str,
) -> Pin<Box<dyn Future<Output = Result<C, ConnectionError>> + Send + 'async_trait>>where
'life0: 'async_trait,
C: 'async_trait,
Establishes a new connection to the database Read more
fn load<'conn, 'query, T>(
&'conn mut self,
source: T,
) -> <C as AsyncConnection>::LoadFuture<'conn, 'query>where
T: AsQuery + 'query,
<T as AsQuery>::Query: QueryFragment<<C as AsyncConnection>::Backend> + QueryId + 'query,
fn execute_returning_count<'conn, 'query, T>(
&'conn mut self,
source: T,
) -> <C as AsyncConnection>::ExecuteFuture<'conn, 'query>where
T: QueryFragment<<C as AsyncConnection>::Backend> + QueryId + 'query,
fn transaction_state( &mut self, ) -> &mut <<C as AsyncConnection>::TransactionManager as TransactionManager<C>>::TransactionStateData
§fn begin_test_transaction<'life0, 'async_trait>(
&'life0 mut self,
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where
'life0: 'async_trait,
C: 'async_trait,
fn begin_test_transaction<'life0, 'async_trait>(
&'life0 mut self,
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where
'life0: 'async_trait,
C: 'async_trait,
Creates a transaction that will never be committed. This is useful for
tests. Panics if called while inside of a transaction or
if called with a connection containing a broken transaction
fn instrumentation(&mut self) -> &mut (dyn Instrumentation + 'static)
§fn set_instrumentation(&mut self, instrumentation: impl Instrumentation)
fn set_instrumentation(&mut self, instrumentation: impl Instrumentation)
Set a specific [
Instrumentation] implementation for this connection§fn transaction<'a, 'life0, 'async_trait, R, E, F>(
&'life0 mut self,
callback: F,
) -> Pin<Box<dyn Future<Output = Result<R, E>> + Send + 'async_trait>>
fn transaction<'a, 'life0, 'async_trait, R, E, F>( &'life0 mut self, callback: F, ) -> Pin<Box<dyn Future<Output = Result<R, E>> + Send + 'async_trait>>
Executes the given function inside of a database transaction Read more
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> IntoSql for T
impl<T> IntoSql for T
§impl<T, Conn> RunQueryDsl<Conn> for T
impl<T, Conn> RunQueryDsl<Conn> for T
§fn execute<'conn, 'query>(
self,
conn: &'conn mut Conn,
) -> <Conn as AsyncConnection>::ExecuteFuture<'conn, 'query>where
Conn: AsyncConnection + Send,
Self: ExecuteDsl<Conn> + 'query,
fn execute<'conn, 'query>(
self,
conn: &'conn mut Conn,
) -> <Conn as AsyncConnection>::ExecuteFuture<'conn, 'query>where
Conn: AsyncConnection + Send,
Self: ExecuteDsl<Conn> + 'query,
Executes the given command, returning the number of rows affected. Read more
§fn load<'query, 'conn, U>(
self,
conn: &'conn mut Conn,
) -> AndThen<Self::LoadFuture<'conn>, TryCollect<Self::Stream<'conn>, Vec<U>>, fn(_: Self::Stream<'conn>) -> TryCollect<Self::Stream<'conn>, Vec<U>>>where
U: Send,
Conn: AsyncConnection,
Self: LoadQuery<'query, Conn, U> + 'query,
fn load<'query, 'conn, U>(
self,
conn: &'conn mut Conn,
) -> AndThen<Self::LoadFuture<'conn>, TryCollect<Self::Stream<'conn>, Vec<U>>, fn(_: Self::Stream<'conn>) -> TryCollect<Self::Stream<'conn>, Vec<U>>>where
U: Send,
Conn: AsyncConnection,
Self: LoadQuery<'query, Conn, U> + 'query,
§fn load_stream<'conn, 'query, U>(
self,
conn: &'conn mut Conn,
) -> Self::LoadFuture<'conn>where
Conn: AsyncConnection,
U: 'conn,
Self: LoadQuery<'query, Conn, U> + 'query,
fn load_stream<'conn, 'query, U>(
self,
conn: &'conn mut Conn,
) -> Self::LoadFuture<'conn>where
Conn: AsyncConnection,
U: 'conn,
Self: LoadQuery<'query, Conn, U> + 'query,
Executes the given query, returning a [
Stream] with the returned rows. Read more§fn get_result<'query, 'conn, U>(
self,
conn: &'conn mut Conn,
) -> AndThen<Self::LoadFuture<'conn>, Map<StreamFuture<Pin<Box<Self::Stream<'conn>>>>, fn(_: (Option<Result<U, Error>>, Pin<Box<Self::Stream<'conn>>>)) -> Result<U, Error>>, fn(_: Self::Stream<'conn>) -> Map<StreamFuture<Pin<Box<Self::Stream<'conn>>>>, fn(_: (Option<Result<U, Error>>, Pin<Box<Self::Stream<'conn>>>)) -> Result<U, Error>>>where
U: Send + 'conn,
Conn: AsyncConnection,
Self: LoadQuery<'query, Conn, U> + 'query,
fn get_result<'query, 'conn, U>(
self,
conn: &'conn mut Conn,
) -> AndThen<Self::LoadFuture<'conn>, Map<StreamFuture<Pin<Box<Self::Stream<'conn>>>>, fn(_: (Option<Result<U, Error>>, Pin<Box<Self::Stream<'conn>>>)) -> Result<U, Error>>, fn(_: Self::Stream<'conn>) -> Map<StreamFuture<Pin<Box<Self::Stream<'conn>>>>, fn(_: (Option<Result<U, Error>>, Pin<Box<Self::Stream<'conn>>>)) -> Result<U, Error>>>where
U: Send + 'conn,
Conn: AsyncConnection,
Self: LoadQuery<'query, Conn, U> + 'query,
Runs the command, and returns the affected row. Read more
§fn get_results<'query, 'conn, U>(
self,
conn: &'conn mut Conn,
) -> AndThen<Self::LoadFuture<'conn>, TryCollect<Self::Stream<'conn>, Vec<U>>, fn(_: Self::Stream<'conn>) -> TryCollect<Self::Stream<'conn>, Vec<U>>>where
U: Send,
Conn: AsyncConnection,
Self: LoadQuery<'query, Conn, U> + 'query,
fn get_results<'query, 'conn, U>(
self,
conn: &'conn mut Conn,
) -> AndThen<Self::LoadFuture<'conn>, TryCollect<Self::Stream<'conn>, Vec<U>>, fn(_: Self::Stream<'conn>) -> TryCollect<Self::Stream<'conn>, Vec<U>>>where
U: Send,
Conn: AsyncConnection,
Self: LoadQuery<'query, Conn, U> + 'query,
Runs the command, returning an
Vec with the affected rows. Read more§fn first<'query, 'conn, U>(
self,
conn: &'conn mut Conn,
) -> AndThen<<Self::Output as LoadQuery<'query, Conn, U>>::LoadFuture<'conn>, Map<StreamFuture<Pin<Box<<Self::Output as LoadQuery<'query, Conn, U>>::Stream<'conn>>>>, fn(_: (Option<Result<U, Error>>, Pin<Box<<Self::Output as LoadQuery<'query, Conn, U>>::Stream<'conn>>>)) -> Result<U, Error>>, fn(_: <Self::Output as LoadQuery<'query, Conn, U>>::Stream<'conn>) -> Map<StreamFuture<Pin<Box<<Self::Output as LoadQuery<'query, Conn, U>>::Stream<'conn>>>>, fn(_: (Option<Result<U, Error>>, Pin<Box<<Self::Output as LoadQuery<'query, Conn, U>>::Stream<'conn>>>)) -> Result<U, Error>>>
fn first<'query, 'conn, U>( self, conn: &'conn mut Conn, ) -> AndThen<<Self::Output as LoadQuery<'query, Conn, U>>::LoadFuture<'conn>, Map<StreamFuture<Pin<Box<<Self::Output as LoadQuery<'query, Conn, U>>::Stream<'conn>>>>, fn(_: (Option<Result<U, Error>>, Pin<Box<<Self::Output as LoadQuery<'query, Conn, U>>::Stream<'conn>>>)) -> Result<U, Error>>, fn(_: <Self::Output as LoadQuery<'query, Conn, U>>::Stream<'conn>) -> Map<StreamFuture<Pin<Box<<Self::Output as LoadQuery<'query, Conn, U>>::Stream<'conn>>>>, fn(_: (Option<Result<U, Error>>, Pin<Box<<Self::Output as LoadQuery<'query, Conn, U>>::Stream<'conn>>>)) -> Result<U, Error>>>
Attempts to load a single record. Read more