Trait Executor 

pub trait Executor {
    type Rows<'a>: RowStream + 'a
       where Self: 'a;
    type Statement<'a>: PreparedStatement<Rows<'a> = Self::Rows<'a>> + 'a
       where Self: 'a;

    // Required methods
    fn driver(&self) -> Driver;
    fn query(
        &mut self,
        sql: &str,
    ) -> impl Future<Output = Result<Self::Rows<'_>>> + Send;
    fn query_prepared_source<P>(
        &mut self,
        sql: &str,
        params: &P,
    ) -> impl Future<Output = Result<Self::Rows<'_>>> + Send
       where P: ParamSource + Sync + ?Sized;
    fn prepare(
        &mut self,
        sql: &str,
    ) -> impl Future<Output = Result<Self::Statement<'_>>> + Send;
}

Something that can run SQL.

This is the trait behind query and prepare. [Connection], [Pool], crate::PoolTransaction, crate::PooledConnection, crate::PooledTransaction, and crate::Transaction all implement it.

Use this trait when you want generic code that can work with either a plain connection, a pool, or a transaction.

Rows<'a> is the stream type returned while the executor is borrowed for 'a. Statement<'a> is the prepared statement type returned from Self::prepare.

Required Associated Types

type Rows<'a>: RowStream + 'a where Self: 'a

Row stream returned by this executor.

type Statement<'a>: PreparedStatement<Rows<'a> = Self::Rows<'a>> + 'a where Self: 'a

Prepared statement returned by this executor.

Required Methods

fn driver(&self) -> Driver

Returns the selected database driver.

fn query( &mut self, sql: &str, ) -> impl Future<Output = Result<Self::Rows<'_>>> + Send

Runs SQL without explicit bound parameters.

For SQL with parameters, most code should use query or Self::prepare instead of calling Self::query_prepared_source directly.

fn query_prepared_source<P>( &mut self, sql: &str, params: &P, ) -> impl Future<Output = Result<Self::Rows<'_>>> + Send

where P: ParamSource + Sync + ?Sized,

Runs SQL with a borrowed parameter source.

This is the low-level path used by Query when parameters were bound. Most callers should not need to use it directly.

fn prepare( &mut self, sql: &str, ) -> impl Future<Output = Result<Self::Statement<'_>>> + Send

Prepares SQL for repeated use.

Reuse this when the same SQL runs many times on the same executor.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl Executor for &Pool

type Rows<'a> = Rows<'a> where Self: 'a

type Statement<'a> = PoolStatement where Self: 'a

impl Executor for &mut Connection

type Rows<'a> = Rows<'a> where Self: 'a

type Statement<'a> = Statement<'a> where Self: 'a

impl Executor for &mut Pool

type Rows<'a> = Rows<'a> where Self: 'a

type Statement<'a> = PoolStatement where Self: 'a

impl Executor for &mut PoolTransaction

type Rows<'a> = Rows<'a> where Self: 'a

type Statement<'a> = PooledStatement<'a> where Self: 'a

impl Executor for &mut PooledConnection

type Rows<'a> = Rows<'a> where Self: 'a

type Statement<'a> = PooledStatement<'a> where Self: 'a

impl Executor for &mut PooledTransaction<'_>

type Rows<'a> = Rows<'a> where Self: 'a

type Statement<'a> = PooledStatement<'a> where Self: 'a

impl Executor for &mut Transaction<'_>

type Rows<'a> = Rows<'a> where Self: 'a

type Statement<'a> = Statement<'a> where Self: 'a

impl Executor for Connection

type Rows<'a> = Rows<'a> where Self: 'a

type Statement<'a> = Statement<'a> where Self: 'a

impl Executor for Pool

type Rows<'a> = Rows<'a> where Self: 'a

type Statement<'a> = PoolStatement where Self: 'a

impl Executor for PoolTransaction

type Rows<'a> = Rows<'a> where Self: 'a

type Statement<'a> = PooledStatement<'a> where Self: 'a

impl Executor for PooledConnection

type Rows<'a> = Rows<'a> where Self: 'a

type Statement<'a> = PooledStatement<'a> where Self: 'a

impl Executor for PooledTransaction<'_>

type Rows<'a> = Rows<'a> where Self: 'a

type Statement<'a> = PooledStatement<'a> where Self: 'a

impl Executor for Transaction<'_>

type Rows<'a> = Rows<'a> where Self: 'a

type Statement<'a> = Statement<'a> where Self: 'a