Struct DTraceConnection 

pub struct DTraceConnection<C: Connection> { /* private fields */ }

A Connection wrapper that inserts DTrace probe points.

See the module-level documentation for more details.

Implementations

impl<C: Connection> DTraceConnection<C>

pub fn id(&self) -> Uuid

Trait Implementations

impl<C> Connection for DTraceConnection<C>

where C: Connection<TransactionManager = AnsiTransactionManager>, C::Backend: Default, <C::Backend as Backend>::QueryBuilder: Default,

type Backend = <C as Connection>::Backend

The backend this type connects to

type TransactionManager = DTraceTransactionManager<C>

The transaction manager implementation used by this connection

fn establish(database_url: &str) -> ConnectionResult<Self>

Establishes a new connection to the database

fn execute_returning_count<T>(&mut self, source: &T) -> QueryResult<usize>

where T: QueryFragment<Self::Backend> + QueryId,

Execute a single SQL statements given by a query and return number of affected rows

fn transaction_state( &mut self, ) -> &mut <DTraceTransactionManager<C> as TransactionManager<DTraceConnection<C>>>::TransactionStateData

Get access to the current transaction state of this connection

fn instrumentation(&mut self) -> &mut dyn Instrumentation

Get the instrumentation instance stored in this connection

fn set_instrumentation(&mut self, instrumentation: impl Instrumentation)

Set a specific Instrumentation implementation for this connection

fn set_prepared_statement_cache_size(&mut self, size: CacheSize)

Set the prepared statement cache size to CacheSize for this connection

fn transaction<T, E, F>(&mut self, f: F) -> Result<T, E>

where F: FnOnce(&mut Self) -> Result<T, E>, E: From<Error>,

Executes the given function inside of a database transaction

fn begin_test_transaction(&mut self) -> Result<(), Error>

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 test_transaction<T, E, F>(&mut self, f: F) -> T

where F: FnOnce(&mut Self) -> Result<T, E>, E: Debug,

Executes the given function inside a transaction, but does not commit it. Panics if the given function returns an error.

impl<C: Debug + Connection> Debug for DTraceConnection<C>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<C: Connection> Deref for DTraceConnection<C>

type Target = C

The resulting type after dereferencing.

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

Dereferences the value.

impl<C: Connection> DerefMut for DTraceConnection<C>

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

Mutably dereferences the value.

impl<C> LoadConnection for DTraceConnection<C>

where C: Connection<TransactionManager = AnsiTransactionManager> + LoadConnection, C::Backend: Default, <C::Backend as Backend>::QueryBuilder: Default,

type Cursor<'conn, 'query> = <C as LoadConnection>::Cursor<'conn, 'query> where Self: 'conn

The cursor type returned by LoadConnection::load

type Row<'conn, 'query> = <C as LoadConnection>::Row<'conn, 'query> where Self: 'conn

The row type used as Iterator::Item for the iterator implementation of LoadConnection::Cursor

fn load<'conn, 'query, T>( &'conn mut self, source: T, ) -> QueryResult<Self::Cursor<'conn, 'query>>

where T: Query + QueryFragment<Self::Backend> + QueryId + 'query, Self::Backend: QueryMetadata<T::SqlType>,

Executes a given query and returns any requested values

impl<C> R2D2Connection for DTraceConnection<C>

where C: R2D2Connection + Connection<TransactionManager = AnsiTransactionManager>, C::Backend: Default, <C::Backend as Backend>::QueryBuilder: Default,

fn ping(&mut self) -> QueryResult<()>

Check if a connection is still valid

fn is_broken(&mut self) -> bool

Checks if the connection is broken and should not be reused

impl<C: Connection> SimpleConnection for DTraceConnection<C>

fn batch_execute(&mut self, query: &str) -> QueryResult<()>

Execute multiple SQL statements within the same string.

impl<C> TransactionManager<DTraceConnection<C>> for DTraceTransactionManager<C>

where C: Connection<TransactionManager = AnsiTransactionManager>, C::Backend: Default, <C::Backend as Backend>::QueryBuilder: Default,

type TransactionStateData = AnsiTransactionManager

Data stored as part of the connection implementation to track the current transaction state of a connection

fn begin_transaction(conn: &mut DTraceConnection<C>) -> QueryResult<()>

Begin a new transaction or savepoint

fn rollback_transaction(conn: &mut DTraceConnection<C>) -> QueryResult<()>

Rollback the inner-most transaction or savepoint

fn commit_transaction(conn: &mut DTraceConnection<C>) -> QueryResult<()>

Commit the inner-most transaction or savepoint

fn transaction_manager_status_mut( conn: &mut DTraceConnection<C>, ) -> &mut TransactionManagerStatus

Fetch the current transaction status as mutable

fn transaction<F, R, E>(conn: &mut Conn, callback: F) -> Result<R, E>

where F: FnOnce(&mut Conn) -> Result<R, E>, E: From<Error>,

Executes the given function inside of a database transaction

fn is_broken_transaction_manager(conn: &mut Conn) -> bool

This methods checks if the connection manager is considered to be broken by connection pool implementations

impl<C> ConnectionSealed for DTraceConnection<C>

where C: Connection<TransactionManager = AnsiTransactionManager>, C::Backend: Default, <C::Backend as Backend>::QueryBuilder: Default,