Trait sqlx_core::executor::Executor

source · 
pub trait Executor<'c>: Send + Debug + Sized {
    type Database: Database;

    // Required methods
    fn fetch_many<'e, 'q: 'e, E>(
        self,
        query: E,
    ) -> BoxStream<'e, Result<Either<<Self::Database as Database>::QueryResult, <Self::Database as Database>::Row>, Error>>
       where E: Execute<'q, Self::Database> + 'q,
             'c: 'e;
    fn fetch_optional<'e, 'q: 'e, E>(
        self,
        query: E,
    ) -> BoxFuture<'e, Result<Option<<Self::Database as Database>::Row>, Error>>
       where E: Execute<'q, Self::Database> + 'q,
             'c: 'e;
    fn prepare_with<'e, 'q: 'e>(
        self,
        sql: &'q str,
        parameters: &'e [<Self::Database as Database>::TypeInfo],
    ) -> BoxFuture<'e, Result<<Self::Database as HasStatement<'q>>::Statement, Error>>
       where 'c: 'e;

    // Provided methods
    fn execute<'e, 'q: 'e, E>(
        self,
        query: E,
    ) -> BoxFuture<'e, Result<<Self::Database as Database>::QueryResult, Error>>
       where E: Execute<'q, Self::Database> + 'q,
             'c: 'e { ... }
    fn execute_many<'e, 'q: 'e, E>(
        self,
        query: E,
    ) -> BoxStream<'e, Result<<Self::Database as Database>::QueryResult, Error>>
       where E: Execute<'q, Self::Database> + 'q,
             'c: 'e { ... }
    fn fetch<'e, 'q: 'e, E>(
        self,
        query: E,
    ) -> BoxStream<'e, Result<<Self::Database as Database>::Row, Error>>
       where E: Execute<'q, Self::Database> + 'q,
             'c: 'e { ... }
    fn fetch_all<'e, 'q: 'e, E>(
        self,
        query: E,
    ) -> BoxFuture<'e, Result<Vec<<Self::Database as Database>::Row>, Error>>
       where E: Execute<'q, Self::Database> + 'q,
             'c: 'e { ... }
    fn fetch_one<'e, 'q: 'e, E>(
        self,
        query: E,
    ) -> BoxFuture<'e, Result<<Self::Database as Database>::Row, Error>>
       where E: Execute<'q, Self::Database> + 'q,
             'c: 'e { ... }
    fn prepare<'e, 'q: 'e>(
        self,
        query: &'q str,
    ) -> BoxFuture<'e, Result<<Self::Database as HasStatement<'q>>::Statement, Error>>
       where 'c: 'e { ... }
}
Expand description

A type that contains or can provide a database connection to use for executing queries against the database.

No guarantees are provided that successive queries run on the same physical database connection.

A Connection is an Executor that guarantees that successive queries are ran on the same physical database connection.

Implemented for the following:

The Executor impls for Transaction and PoolConnection have been deleted because they cannot exist in the new crate architecture without rewriting the Executor trait entirely. To fix this breakage, simply add a dereference where an impl Executor is expected, as they both dereference to the inner connection type which will still implement it:

  • &mut transaction -> &mut *transaction
  • &mut connection -> &mut *connection

Required Associated Types§

source

type Database: Database

Required Methods§

source

fn fetch_many<'e, 'q: 'e, E>( self, query: E, ) -> BoxStream<'e, Result<Either<<Self::Database as Database>::QueryResult, <Self::Database as Database>::Row>, Error>>
where E: Execute<'q, Self::Database> + 'q, 'c: 'e,

Execute multiple queries and return the generated results as a stream from each query, in a stream.

source

fn fetch_optional<'e, 'q: 'e, E>( self, query: E, ) -> BoxFuture<'e, Result<Option<<Self::Database as Database>::Row>, Error>>
where E: Execute<'q, Self::Database> + 'q, 'c: 'e,

Execute the query and returns at most one row.

source

fn prepare_with<'e, 'q: 'e>( self, sql: &'q str, parameters: &'e [<Self::Database as Database>::TypeInfo], ) -> BoxFuture<'e, Result<<Self::Database as HasStatement<'q>>::Statement, Error>>
where 'c: 'e,

Prepare the SQL query, with parameter type information, to inspect the type information about its parameters and results.

Only some database drivers (PostgreSQL, MSSQL) can take advantage of this extra information to influence parameter type inference.

Provided Methods§

source

fn execute<'e, 'q: 'e, E>( self, query: E, ) -> BoxFuture<'e, Result<<Self::Database as Database>::QueryResult, Error>>
where E: Execute<'q, Self::Database> + 'q, 'c: 'e,

Execute the query and return the total number of rows affected.

source

fn execute_many<'e, 'q: 'e, E>( self, query: E, ) -> BoxStream<'e, Result<<Self::Database as Database>::QueryResult, Error>>
where E: Execute<'q, Self::Database> + 'q, 'c: 'e,

Execute multiple queries and return the rows affected from each query, in a stream.

source

fn fetch<'e, 'q: 'e, E>( self, query: E, ) -> BoxStream<'e, Result<<Self::Database as Database>::Row, Error>>
where E: Execute<'q, Self::Database> + 'q, 'c: 'e,

Execute the query and return the generated results as a stream.

source

fn fetch_all<'e, 'q: 'e, E>( self, query: E, ) -> BoxFuture<'e, Result<Vec<<Self::Database as Database>::Row>, Error>>
where E: Execute<'q, Self::Database> + 'q, 'c: 'e,

Execute the query and return all the generated results, collected into a Vec.

source

fn fetch_one<'e, 'q: 'e, E>( self, query: E, ) -> BoxFuture<'e, Result<<Self::Database as Database>::Row, Error>>
where E: Execute<'q, Self::Database> + 'q, 'c: 'e,

Execute the query and returns exactly one row.

source

fn prepare<'e, 'q: 'e>( self, query: &'q str, ) -> BoxFuture<'e, Result<<Self::Database as HasStatement<'q>>::Statement, Error>>
where 'c: 'e,

Prepare the SQL query to inspect the type information of its parameters and results.

Be advised that when using the query, query_as, or query_scalar functions, the query is transparently prepared and executed.

This explicit API is provided to allow access to the statement metadata available after it prepared but before the first row is returned.

Object Safety§

This trait is not object safe.

Implementors§

source§

impl<'p, DB: Database> Executor<'p> for &Pool<DB>
where for<'c> &'c mut DB::Connection: Executor<'c, Database = DB>,

§

type Database = DB