Trait sqlx::Executor

pub trait Executor: Send {
    type Database: Database;
    fn execute<'e, 'q, 'c, E>(
        &'c mut self, 
        query: E
    ) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'e + Send>>
    where
        'q: 'e,
        'c: 'e,
        E: 'e + Execute<'q, Self::Database>;
    fn fetch<'q, E>(
        &'e mut self, 
        query: E
    ) -> <Self::Database as HasCursor<'e, 'q>>::Cursor
    where
        E: Execute<'q, Self::Database>;
}

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 run on the same physical database connection.

Implementations are provided for &Pool, &mut PoolConnection, and &mut Connection.

Associated Types

type Database: Database

The specific database that this type is implemented for.

Loading content...

Required methods

fn execute<'e, 'q, 'c, E>(
    &'c mut self,
    query: E
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'e + Send>> where
    'q: 'e,
    'c: 'e,
    E: 'e + Execute<'q, Self::Database>, 

Executes the query for its side-effects and discarding any potential result rows.

Returns the number of rows affected, or 0 if not applicable.

fn fetch<'q, E>(
    &'e mut self,
    query: E
) -> <Self::Database as HasCursor<'e, 'q>>::Cursor where
    E: Execute<'q, Self::Database>, 

Executes a query for its result.

Returns a Cursor that can be used to iterate through the Rows of the result.

Loading content...

Implementations on Foreign Types

impl<'_, T> Executor for &'_ mut T where
    T: Executor, 

type Database = <T as Executor>::Database

fn execute<'e, 'q, 'c, E>(
    &'c mut self,
    query: E
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'e + Send>> where
    'q: 'e,
    'c: 'e,
    E: 'e + Execute<'q, <&'_ mut T as Executor>::Database>, 

fn fetch<'q, E>(
    &'e mut self,
    query: E
) -> <<&'_ mut T as Executor>::Database as HasCursor<'e, 'q>>::Cursor where
    E: Execute<'q, <&'_ mut T as Executor>::Database>, 

Loading content...

Implementors

impl Executor for PgListener

type Database = Postgres

fn execute<'e, 'q, 'c, E>(
    &'c mut self,
    query: E
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'e + Send>> where
    'q: 'e,
    'c: 'e,
    E: 'e + Execute<'q, <PgListener as Executor>::Database>, 

fn fetch<'q, E>(&mut self, query: E) -> PgCursor<'q> where
    E: Execute<'q, <PgListener as Executor>::Database>, 

impl Executor for MySqlConnection

type Database = MySql

fn execute<'e, 'q, 'c, E>(
    &'c mut self,
    query: E
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'e + Send>> where
    'q: 'e,
    'c: 'e,
    E: 'e + Execute<'q, <MySqlConnection as Executor>::Database>, 

fn fetch<'q, E>(&mut self, query: E) -> MySqlCursor<'q> where
    E: Execute<'q, <MySqlConnection as Executor>::Database>, 

impl Executor for PgConnection

type Database = Postgres

fn execute<'e, 'q, 'c, E>(
    &'c mut self,
    query: E
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'e + Send>> where
    'q: 'e,
    'c: 'e,
    E: 'e + Execute<'q, <PgConnection as Executor>::Database>, 

fn fetch<'q, E>(&mut self, query: E) -> PgCursor<'q> where
    E: Execute<'q, <PgConnection as Executor>::Database>, 

impl Executor for SqliteConnection

type Database = Sqlite

fn execute<'e, 'q, 'c, E>(
    &'c mut self,
    query: E
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'e + Send>> where
    'q: 'e,
    'c: 'e,
    E: 'e + Execute<'q, <SqliteConnection as Executor>::Database>, 

fn fetch<'q, E>(&mut self, query: E) -> SqliteCursor<'q> where
    E: Execute<'q, <SqliteConnection as Executor>::Database>, 

impl<'p, C, DB> Executor for &'p Pool<C> where
    C: Connect<Database = DB>,
    DB: Database<Connection = C, Database = DB> + HasCursor<'c, 'q>, 

type Database = DB

fn execute<'e, 'q, 'c, E>(
    &'c mut self,
    query: E
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'e + Send>> where
    'q: 'e,
    'c: 'e,
    E: 'e + Execute<'q, <&'p Pool<C> as Executor>::Database>, 

fn fetch<'q, E>(
    &'e mut self,
    query: E
) -> <<&'p Pool<C> as Executor>::Database as HasCursor<'e, 'q>>::Cursor where
    E: Execute<'q, DB>, 

impl<C> Executor for PoolConnection<C> where
    C: Connect, 

type Database = <C as Executor>::Database

fn execute<'e, 'q, 'c, E>(
    &'c mut self,
    query: E
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'e + Send>> where
    'q: 'e,
    'c: 'e,
    E: 'e + Execute<'q, <PoolConnection<C> as Executor>::Database>, 

fn fetch<'q, E>(
    &'e mut self,
    query: E
) -> <<C as Executor>::Database as HasCursor<'e, 'q>>::Cursor where
    E: Execute<'q, <PoolConnection<C> as Executor>::Database>, 

impl<DB, C> Executor for Transaction<C> where
    C: Connection<Database = DB>,
    DB: Database, 

type Database = <C as Executor>::Database

fn execute<'e, 'q, 'c, E>(
    &'c mut self,
    query: E
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'e + Send>> where
    'q: 'e,
    'c: 'e,
    E: 'e + Execute<'q, <Transaction<C> as Executor>::Database>, 

fn fetch<'q, E>(
    &'e mut self,
    query: E
) -> <<Transaction<C> as Executor>::Database as HasCursor<'e, 'q>>::Cursor where
    E: Execute<'q, <Transaction<C> as Executor>::Database>, 

Loading content...