Trait sqlx_core::executor::Executor

pub trait Executor<'c>: Send + Debug + Sized {
    type Database: Database;
    fn fetch_many<'e, 'q: 'e, E: 'q>(
        self, 
        query: E
    ) -> BoxStream<'e, Result<Either<<Self::Database as Database>::QueryResult, <Self::Database as Database>::Row>, Error>>
    where
        'c: 'e,
        E: Execute<'q, Self::Database>;
    fn fetch_optional<'e, 'q: 'e, E: 'q>(
        self, 
        query: E
    ) -> BoxFuture<'e, Result<Option<<Self::Database as Database>::Row>, Error>>
    where
        'c: 'e,
        E: Execute<'q, Self::Database>;
    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;

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

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:

• &Pool
• &mut PoolConnection
• &mut Connection

Associated Types

type Database: Database

Loading content...

Required methods

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

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

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

Execute the query and returns at most one row.

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.

Loading content...

Provided methods

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

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

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

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

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

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

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

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

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

Execute the query and returns exactly one row.

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.

Loading content...

Implementors

impl<'c> Executor<'c> for &'c mut AnyConnection

type Database = Any

fn fetch_many<'e, 'q: 'e, E: 'q>(
    self,
    mut query: E
) -> BoxStream<'e, Result<Either<AnyQueryResult, AnyRow>, Error>> where
    'c: 'e,
    E: Execute<'q, Self::Database>, 

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

fn prepare_with<'e, 'q: 'e>(
    self,
    sql: &'q str,
    _parameters: &[AnyTypeInfo]
) -> BoxFuture<'e, Result<AnyStatement<'q>, Error>> where
    'c: 'e, 

fn describe<'e, 'q: 'e>(
    self,
    sql: &'q str
) -> BoxFuture<'e, Result<Describe<Self::Database>, Error>> where
    'c: 'e, 

impl<'c> Executor<'c> for &'c mut MssqlConnection

type Database = Mssql

fn fetch_many<'e, 'q: 'e, E: 'q>(
    self,
    mut query: E
) -> BoxStream<'e, Result<Either<MssqlQueryResult, MssqlRow>, Error>> where
    'c: 'e,
    E: Execute<'q, Self::Database>, 

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

fn prepare_with<'e, 'q: 'e>(
    self,
    sql: &'q str,
    _parameters: &[MssqlTypeInfo]
) -> BoxFuture<'e, Result<MssqlStatement<'q>, Error>> where
    'c: 'e, 

fn describe<'e, 'q: 'e>(
    self,
    sql: &'q str
) -> BoxFuture<'e, Result<Describe<Self::Database>, Error>> where
    'c: 'e, 

impl<'c> Executor<'c> for &'c mut MySqlConnection

type Database = MySql

fn fetch_many<'e, 'q: 'e, E: 'q>(
    self,
    mut query: E
) -> BoxStream<'e, Result<Either<MySqlQueryResult, MySqlRow>, Error>> where
    'c: 'e,
    E: Execute<'q, Self::Database>, 

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

fn prepare_with<'e, 'q: 'e>(
    self,
    sql: &'q str,
    _parameters: &'e [MySqlTypeInfo]
) -> BoxFuture<'e, Result<MySqlStatement<'q>, Error>> where
    'c: 'e, 

impl<'c> Executor<'c> for &'c mut PoolConnection<Any>

type Database = Any

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

fn fetch_optional<'e, 'q: 'e, E: 'q>(
    self,
    query: E
) -> BoxFuture<'e, Result<Option<AnyRow>, Error>> where
    'c: 'e,
    E: Execute<'q, Any>, 

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

impl<'c> Executor<'c> for &'c mut PoolConnection<Mssql>

type Database = Mssql

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

fn fetch_optional<'e, 'q: 'e, E: 'q>(
    self,
    query: E
) -> BoxFuture<'e, Result<Option<MssqlRow>, Error>> where
    'c: 'e,
    E: Execute<'q, Mssql>, 

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

impl<'c> Executor<'c> for &'c mut PoolConnection<MySql>

type Database = MySql

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

fn fetch_optional<'e, 'q: 'e, E: 'q>(
    self,
    query: E
) -> BoxFuture<'e, Result<Option<MySqlRow>, Error>> where
    'c: 'e,
    E: Execute<'q, MySql>, 

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

impl<'c> Executor<'c> for &'c mut PoolConnection<Postgres>

type Database = Postgres

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

fn fetch_optional<'e, 'q: 'e, E: 'q>(
    self,
    query: E
) -> BoxFuture<'e, Result<Option<PgRow>, Error>> where
    'c: 'e,
    E: Execute<'q, Postgres>, 

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

impl<'c> Executor<'c> for &'c mut PoolConnection<Sqlite>

type Database = Sqlite

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

fn fetch_optional<'e, 'q: 'e, E: 'q>(
    self,
    query: E
) -> BoxFuture<'e, Result<Option<SqliteRow>, Error>> where
    'c: 'e,
    E: Execute<'q, Sqlite>, 

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

impl<'c> Executor<'c> for &'c mut PgConnection

type Database = Postgres

fn fetch_many<'e, 'q: 'e, E: 'q>(
    self,
    mut query: E
) -> BoxStream<'e, Result<Either<PgQueryResult, PgRow>, Error>> where
    'c: 'e,
    E: Execute<'q, Self::Database>, 

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

fn prepare_with<'e, 'q: 'e>(
    self,
    sql: &'q str,
    parameters: &'e [PgTypeInfo]
) -> BoxFuture<'e, Result<PgStatement<'q>, Error>> where
    'c: 'e, 

fn describe<'e, 'q: 'e>(
    self,
    sql: &'q str
) -> BoxFuture<'e, Result<Describe<Self::Database>, Error>> where
    'c: 'e, 

impl<'c> Executor<'c> for &'c mut PgListener

type Database = Postgres

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

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

fn prepare_with<'e, 'q: 'e>(
    self,
    query: &'q str,
    parameters: &'e [PgTypeInfo]
) -> BoxFuture<'e, Result<PgStatement<'q>, Error>> where
    'c: 'e, 

impl<'c> Executor<'c> for &'c mut SqliteConnection

type Database = Sqlite

fn fetch_many<'e, 'q: 'e, E: 'q>(
    self,
    mut query: E
) -> BoxStream<'e, Result<Either<SqliteQueryResult, SqliteRow>, Error>> where
    'c: 'e,
    E: Execute<'q, Self::Database>, 

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

fn prepare_with<'e, 'q: 'e>(
    self,
    sql: &'q str,
    _parameters: &[SqliteTypeInfo]
) -> BoxFuture<'e, Result<SqliteStatement<'q>, Error>> where
    'c: 'e, 

impl<'c, 't> Executor<'t> for &'t mut Transaction<'c, Any>

type Database = Any

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

fn fetch_optional<'e, 'q: 'e, E: 'q>(
    self,
    query: E
) -> BoxFuture<'e, Result<Option<AnyRow>, Error>> where
    't: 'e,
    E: Execute<'q, Self::Database>, 

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
    't: 'e, 

impl<'c, 't> Executor<'t> for &'t mut Transaction<'c, Mssql>

type Database = Mssql

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

fn fetch_optional<'e, 'q: 'e, E: 'q>(
    self,
    query: E
) -> BoxFuture<'e, Result<Option<MssqlRow>, Error>> where
    't: 'e,
    E: Execute<'q, Self::Database>, 

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
    't: 'e, 

impl<'c, 't> Executor<'t> for &'t mut Transaction<'c, MySql>

type Database = MySql

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

fn fetch_optional<'e, 'q: 'e, E: 'q>(
    self,
    query: E
) -> BoxFuture<'e, Result<Option<MySqlRow>, Error>> where
    't: 'e,
    E: Execute<'q, Self::Database>, 

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
    't: 'e, 

impl<'c, 't> Executor<'t> for &'t mut Transaction<'c, Postgres>

type Database = Postgres

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

fn fetch_optional<'e, 'q: 'e, E: 'q>(
    self,
    query: E
) -> BoxFuture<'e, Result<Option<PgRow>, Error>> where
    't: 'e,
    E: Execute<'q, Self::Database>, 

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
    't: 'e, 

impl<'c, 't> Executor<'t> for &'t mut Transaction<'c, Sqlite>

type Database = Sqlite

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

fn fetch_optional<'e, 'q: 'e, E: 'q>(
    self,
    query: E
) -> BoxFuture<'e, Result<Option<SqliteRow>, Error>> where
    't: 'e,
    E: Execute<'q, Self::Database>, 

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
    't: 'e, 

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

type Database = DB

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

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

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>>

Loading content...