Trait Statement

pub trait Statement: Send + Sealed {
    type Output: Send;

    // Required methods
    fn execute<S: SqlExecutor>(
        self,
        connection: &S,
    ) -> Result<Self::Output, S::Error>;
    fn execute_mut<S: SqlExecutorMut>(
        self,
        connection: &mut S,
    ) -> Result<Self::Output, S::Error>;
    fn execute_async<S: SqlExecutorAsync>(
        self,
        connection: &mut S,
    ) -> impl Future<Output = Result<Self::Output, S::Error>> + Send;

    // Provided methods
    fn then<Q: Statement>(self, statement: Q) -> Then<Self, Q>
       where Self: Sized { ... }
    fn pipe<Q: StatementWithInput<Input = Self::Output> + Send>(
        self,
        statement: Q,
    ) -> Pipe<Self, Q>
       where Self: Sized { ... }
    fn spanned(self, span: Span) -> TracedStatement<Self>
       where Self: Sized { ... }
    fn spanned_in_current(self) -> TracedStatement<Self>
       where Self: Sized { ... }
}

Basic abstraction that defers the execution of a SQL statement in order to reduce the duplication of sync and async code. Basic composability and chaining are also included.

The Send requirement is in theory not required for sync implementations, but this is not intended to be used outside of the scope of this crate.

Required Associated Types

type Output: Send

Output of this statement.

Required Methods

fn execute<S: SqlExecutor>( self, connection: &S, ) -> Result<Self::Output, S::Error>

Execute the statement and return the result.

Errors

If the statement fails, return error.

fn execute_mut<S: SqlExecutorMut>( self, connection: &mut S, ) -> Result<Self::Output, S::Error>

Execute the statement and return the result.

Errors

If the statement fails, return error.

fn execute_async<S: SqlExecutorAsync>( self, connection: &mut S, ) -> impl Future<Output = Result<Self::Output, S::Error>> + Send

Execute the statement and return the result.

Errors

If the statement fails, return error.

Provided Methods

fn then<Q: Statement>(self, statement: Q) -> Then<Self, Q>

where Self: Sized,

If this statement succeeds, then execute the next statement.

fn pipe<Q: StatementWithInput<Input = Self::Output> + Send>( self, statement: Q, ) -> Pipe<Self, Q>

where Self: Sized,

if the current statement succeeds, then execute the next statement with output of the current Statement.

fn spanned(self, span: Span) -> TracedStatement<Self>

where Self: Sized,

Instrument the current statement with the given Span

fn spanned_in_current(self) -> TracedStatement<Self>

where Self: Sized,

Instrument the current statement with currently active Span

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<Q: Statement> Statement for Option<Q>

type Output = Option<<Q as Statement>::Output>

fn execute<S: SqlExecutor>( self, connection: &S, ) -> Result<Self::Output, S::Error>

fn execute_mut<S: SqlExecutorMut>( self, connection: &mut S, ) -> Result<Self::Output, S::Error>

async fn execute_async<S: SqlExecutorAsync>( self, connection: &mut S, ) -> Result<Self::Output, S::Error>

Implementors

impl<A: Statement + Send, B: Statement + Send> Statement for Then<A, B>

type Output = <B as Statement>::Output

impl<A: Statement + Send, B: StatementWithInput<Input = A::Output> + Send> Statement for Pipe<A, B>

type Output = <B as StatementWithInput>::Output

impl<Q: Statement> Statement for TracedStatement<Q>

type Output = <Q as Statement>::Output