Trait sqlx::Executor [−][src]
pub trait Executor<'c>: Send + Debug {
type Database: Database;
fn fetch_many<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<Either<<Self::Database as Database>::QueryResult, <Self::Database as Database>::Row>, Error>> + Send + 'e, Global>>
where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>;
fn fetch_optional<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Option<<Self::Database as Database>::Row>, Error>> + Send + 'e, Global>>
where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>;
fn prepare_with<'e, 'q>(
self,
sql: &'q str,
parameters: &'e [<Self::Database as Database>::TypeInfo]
) -> Pin<Box<dyn Future<Output = Result<<Self::Database as HasStatement<'q>>::Statement, Error>> + Send + 'e, Global>>
where
'q: 'e,
'c: 'e;
fn execute<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::QueryResult, Error>> + Send + 'e, Global>>
where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
{ ... }
fn execute_many<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::QueryResult, Error>> + Send + 'e, Global>>
where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
{ ... }
fn fetch<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::Row, Error>> + Send + 'e, Global>>
where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
{ ... }
fn fetch_all<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Vec<<Self::Database as Database>::Row, Global>, Error>> + Send + 'e, Global>>
where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
{ ... }
fn fetch_one<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::Row, Error>> + Send + 'e, Global>>
where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
{ ... }
fn prepare<'e, 'q>(
self,
query: &'q str
) -> Pin<Box<dyn Future<Output = Result<<Self::Database as HasStatement<'q>>::Statement, Error>> + Send + 'e, Global>>
where
'q: 'e,
'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:
Associated Types
Required methods
Execute multiple queries and return the generated results as a stream from each query, in a stream.
Execute the query and returns at most one row.
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
Execute the query and return the total number of rows affected.
Execute multiple queries and return the rows affected from each query, in a stream.
Execute the query and return the generated results as a stream.
Execute the query and return all the generated results, collected into a Vec.
Execute the query and returns exactly one row.
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.