Trait sqlx_core::executor::Executor

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

    pub fn execute<'e, 'q: 'e, E: 'q>(
        self, 
        query: E
    ) -> BoxFuture<'e, Result<<Self::Database as Database>::Done, Error>>
    where
        'c: 'e,
        E: Execute<'q, Self::Database>,
    { ... }
    pub fn execute_many<'e, 'q: 'e, E: 'q>(
        self, 
        query: E
    ) -> BoxStream<'e, Result<<Self::Database as Database>::Done, Error>>
    where
        'c: 'e,
        E: Execute<'q, Self::Database>,
    { ... }
    pub 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>,
    { ... }
    pub 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>,
    { ... }
    pub 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>,
    { ... }
    pub 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

pub fn fetch_many<'e, 'q: 'e, E: 'q>(
    self,
    query: E
) -> BoxStream<'e, Result<Either<<Self::Database as Database>::Done, <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.

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

pub 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

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

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

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

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

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

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

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

pub 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

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

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

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

pub 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

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

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

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

pub 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

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

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

pub 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

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

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

pub 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

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

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

pub 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

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

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

pub 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

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

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

pub 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

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

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

pub 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

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

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

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

pub 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

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

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

pub 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

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

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

pub 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

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

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

pub 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

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

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

pub 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

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

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

pub 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

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

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

pub 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

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

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

pub 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

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

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

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