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>> + 'e + Send, 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>> + 'e + Send, 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>> + 'e + Send, 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>> + 'e + Send, 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>> + 'e + Send, 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>> + 'e + Send, 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>> + 'e + Send, 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>> + 'e + Send, 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>> + 'e + Send, 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
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>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
[src]
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>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
[src]Execute multiple queries and return the generated results as a stream from each query, in a stream.
fn fetch_optional<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Option<<Self::Database as Database>::Row>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
[src]
fn fetch_optional<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Option<<Self::Database as Database>::Row>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
[src]Execute the query and returns at most one row.
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>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
[src]
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>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
[src]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
fn execute<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::QueryResult, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
[src]
fn execute<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::QueryResult, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
[src]Execute the query and return the total number of rows affected.
fn execute_many<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::QueryResult, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
[src]
fn execute_many<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::QueryResult, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
[src]Execute multiple queries and return the rows affected from each query, in a stream.
fn fetch<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::Row, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
[src]
fn fetch<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::Row, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
[src]Execute the query and return the generated results as a stream.
fn fetch_all<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Vec<<Self::Database as Database>::Row, Global>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
[src]
fn fetch_all<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Vec<<Self::Database as Database>::Row, Global>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
[src]Execute the query and return all the generated results, collected into a Vec
.
fn fetch_one<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::Row, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
[src]
fn fetch_one<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::Row, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
[src]Execute the query and returns exactly one row.
fn prepare<'e, 'q>(
self,
query: &'q str
) -> Pin<Box<dyn Future<Output = Result<<Self::Database as HasStatement<'q>>::Statement, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
[src]
fn prepare<'e, 'q>(
self,
query: &'q str
) -> Pin<Box<dyn Future<Output = Result<<Self::Database as HasStatement<'q>>::Statement, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
[src]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.
Implementors
impl<'c> Executor<'c> for &'c mut PoolConnection<Any>
[src]
impl<'c> Executor<'c> for &'c mut PoolConnection<Any>
[src]type Database = Any
pub fn fetch_many<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<Either<<Any as Database>::QueryResult, AnyRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Any>,
[src]
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<Either<<Any as Database>::QueryResult, AnyRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Any>,
pub fn fetch_optional<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Option<AnyRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Any>,
[src]
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Option<AnyRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Any>,
pub fn prepare_with<'e, 'q>(
self,
sql: &'q str,
parameters: &'e [<Any as Database>::TypeInfo]
) -> Pin<Box<dyn Future<Output = Result<<Any as HasStatement<'q>>::Statement, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
[src]
self,
sql: &'q str,
parameters: &'e [<Any as Database>::TypeInfo]
) -> Pin<Box<dyn Future<Output = Result<<Any as HasStatement<'q>>::Statement, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
impl<'c> Executor<'c> for &'c mut PoolConnection<Mssql>
[src]
impl<'c> Executor<'c> for &'c mut PoolConnection<Mssql>
[src]type Database = Mssql
pub fn fetch_many<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<Either<<Mssql as Database>::QueryResult, MssqlRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Mssql>,
[src]
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<Either<<Mssql as Database>::QueryResult, MssqlRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Mssql>,
pub fn fetch_optional<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Option<MssqlRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Mssql>,
[src]
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Option<MssqlRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Mssql>,
pub fn prepare_with<'e, 'q>(
self,
sql: &'q str,
parameters: &'e [<Mssql as Database>::TypeInfo]
) -> Pin<Box<dyn Future<Output = Result<<Mssql as HasStatement<'q>>::Statement, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
[src]
self,
sql: &'q str,
parameters: &'e [<Mssql as Database>::TypeInfo]
) -> Pin<Box<dyn Future<Output = Result<<Mssql as HasStatement<'q>>::Statement, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
impl<'c> Executor<'c> for &'c mut PoolConnection<MySql>
[src]
impl<'c> Executor<'c> for &'c mut PoolConnection<MySql>
[src]type Database = MySql
pub fn fetch_many<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<Either<<MySql as Database>::QueryResult, MySqlRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, MySql>,
[src]
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<Either<<MySql as Database>::QueryResult, MySqlRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, MySql>,
pub fn fetch_optional<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Option<MySqlRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, MySql>,
[src]
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Option<MySqlRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, MySql>,
pub fn prepare_with<'e, 'q>(
self,
sql: &'q str,
parameters: &'e [<MySql as Database>::TypeInfo]
) -> Pin<Box<dyn Future<Output = Result<<MySql as HasStatement<'q>>::Statement, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
[src]
self,
sql: &'q str,
parameters: &'e [<MySql as Database>::TypeInfo]
) -> Pin<Box<dyn Future<Output = Result<<MySql as HasStatement<'q>>::Statement, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
impl<'c> Executor<'c> for &'c mut PoolConnection<Postgres>
[src]
impl<'c> Executor<'c> for &'c mut PoolConnection<Postgres>
[src]type Database = Postgres
pub fn fetch_many<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<Either<<Postgres as Database>::QueryResult, PgRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Postgres>,
[src]
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<Either<<Postgres as Database>::QueryResult, PgRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Postgres>,
pub fn fetch_optional<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Option<PgRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Postgres>,
[src]
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Option<PgRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Postgres>,
pub fn prepare_with<'e, 'q>(
self,
sql: &'q str,
parameters: &'e [<Postgres as Database>::TypeInfo]
) -> Pin<Box<dyn Future<Output = Result<<Postgres as HasStatement<'q>>::Statement, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
[src]
self,
sql: &'q str,
parameters: &'e [<Postgres as Database>::TypeInfo]
) -> Pin<Box<dyn Future<Output = Result<<Postgres as HasStatement<'q>>::Statement, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
impl<'c> Executor<'c> for &'c mut PoolConnection<Sqlite>
[src]
impl<'c> Executor<'c> for &'c mut PoolConnection<Sqlite>
[src]type Database = Sqlite
pub fn fetch_many<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<Either<<Sqlite as Database>::QueryResult, SqliteRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Sqlite>,
[src]
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<Either<<Sqlite as Database>::QueryResult, SqliteRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Sqlite>,
pub fn fetch_optional<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Option<SqliteRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Sqlite>,
[src]
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Option<SqliteRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Sqlite>,
pub fn prepare_with<'e, 'q>(
self,
sql: &'q str,
parameters: &'e [<Sqlite as Database>::TypeInfo]
) -> Pin<Box<dyn Future<Output = Result<<Sqlite as HasStatement<'q>>::Statement, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
[src]
self,
sql: &'q str,
parameters: &'e [<Sqlite as Database>::TypeInfo]
) -> Pin<Box<dyn Future<Output = Result<<Sqlite as HasStatement<'q>>::Statement, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
impl<'c> Executor<'c> for &'c mut PgListener
[src]
impl<'c> Executor<'c> for &'c mut PgListener
[src]type Database = Postgres
pub fn fetch_many<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<Either<PgQueryResult, PgRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, <&'c mut PgListener as Executor<'c>>::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<Either<PgQueryResult, PgRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, <&'c mut PgListener as Executor<'c>>::Database>,
pub fn fetch_optional<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Option<PgRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, <&'c mut PgListener as Executor<'c>>::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Option<PgRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, <&'c mut PgListener as Executor<'c>>::Database>,
pub fn prepare_with<'e, 'q>(
self,
query: &'q str,
parameters: &'e [PgTypeInfo]
) -> Pin<Box<dyn Future<Output = Result<PgStatement<'q>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
[src]
self,
query: &'q str,
parameters: &'e [PgTypeInfo]
) -> Pin<Box<dyn Future<Output = Result<PgStatement<'q>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
impl<'c> Executor<'c> for &'c mut AnyConnection
[src]
impl<'c> Executor<'c> for &'c mut AnyConnection
[src]type Database = Any
pub fn fetch_many<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<Either<AnyQueryResult, AnyRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, <&'c mut AnyConnection as Executor<'c>>::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<Either<AnyQueryResult, AnyRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, <&'c mut AnyConnection as Executor<'c>>::Database>,
pub fn fetch_optional<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Option<AnyRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, <&'c mut AnyConnection as Executor<'c>>::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Option<AnyRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, <&'c mut AnyConnection as Executor<'c>>::Database>,
pub fn prepare_with<'e, 'q>(
self,
sql: &'q str,
_parameters: &[AnyTypeInfo]
) -> Pin<Box<dyn Future<Output = Result<AnyStatement<'q>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
[src]
self,
sql: &'q str,
_parameters: &[AnyTypeInfo]
) -> Pin<Box<dyn Future<Output = Result<AnyStatement<'q>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
pub fn describe<'e, 'q>(
self,
sql: &'q str
) -> Pin<Box<dyn Future<Output = Result<Describe<<&'c mut AnyConnection as Executor<'c>>::Database>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
[src]
self,
sql: &'q str
) -> Pin<Box<dyn Future<Output = Result<Describe<<&'c mut AnyConnection as Executor<'c>>::Database>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
impl<'c> Executor<'c> for &'c mut MssqlConnection
[src]
impl<'c> Executor<'c> for &'c mut MssqlConnection
[src]type Database = Mssql
pub fn fetch_many<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<Either<MssqlQueryResult, MssqlRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, <&'c mut MssqlConnection as Executor<'c>>::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<Either<MssqlQueryResult, MssqlRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, <&'c mut MssqlConnection as Executor<'c>>::Database>,
pub fn fetch_optional<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Option<MssqlRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, <&'c mut MssqlConnection as Executor<'c>>::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Option<MssqlRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, <&'c mut MssqlConnection as Executor<'c>>::Database>,
pub fn prepare_with<'e, 'q>(
self,
sql: &'q str,
_parameters: &[MssqlTypeInfo]
) -> Pin<Box<dyn Future<Output = Result<MssqlStatement<'q>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
[src]
self,
sql: &'q str,
_parameters: &[MssqlTypeInfo]
) -> Pin<Box<dyn Future<Output = Result<MssqlStatement<'q>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
pub fn describe<'e, 'q>(
self,
sql: &'q str
) -> Pin<Box<dyn Future<Output = Result<Describe<<&'c mut MssqlConnection as Executor<'c>>::Database>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
[src]
self,
sql: &'q str
) -> Pin<Box<dyn Future<Output = Result<Describe<<&'c mut MssqlConnection as Executor<'c>>::Database>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
impl<'c> Executor<'c> for &'c mut MySqlConnection
[src]
impl<'c> Executor<'c> for &'c mut MySqlConnection
[src]type Database = MySql
pub fn fetch_many<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<Either<MySqlQueryResult, MySqlRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, <&'c mut MySqlConnection as Executor<'c>>::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<Either<MySqlQueryResult, MySqlRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, <&'c mut MySqlConnection as Executor<'c>>::Database>,
pub fn fetch_optional<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Option<MySqlRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, <&'c mut MySqlConnection as Executor<'c>>::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Option<MySqlRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, <&'c mut MySqlConnection as Executor<'c>>::Database>,
pub fn prepare_with<'e, 'q>(
self,
sql: &'q str,
_parameters: &'e [MySqlTypeInfo]
) -> Pin<Box<dyn Future<Output = Result<MySqlStatement<'q>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
[src]
self,
sql: &'q str,
_parameters: &'e [MySqlTypeInfo]
) -> Pin<Box<dyn Future<Output = Result<MySqlStatement<'q>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
impl<'c> Executor<'c> for &'c mut PgConnection
[src]
impl<'c> Executor<'c> for &'c mut PgConnection
[src]type Database = Postgres
pub fn fetch_many<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<Either<PgQueryResult, PgRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, <&'c mut PgConnection as Executor<'c>>::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<Either<PgQueryResult, PgRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, <&'c mut PgConnection as Executor<'c>>::Database>,
pub fn fetch_optional<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Option<PgRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, <&'c mut PgConnection as Executor<'c>>::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Option<PgRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, <&'c mut PgConnection as Executor<'c>>::Database>,
pub fn prepare_with<'e, 'q>(
self,
sql: &'q str,
parameters: &'e [PgTypeInfo]
) -> Pin<Box<dyn Future<Output = Result<PgStatement<'q>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
[src]
self,
sql: &'q str,
parameters: &'e [PgTypeInfo]
) -> Pin<Box<dyn Future<Output = Result<PgStatement<'q>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
pub fn describe<'e, 'q>(
self,
sql: &'q str
) -> Pin<Box<dyn Future<Output = Result<Describe<<&'c mut PgConnection as Executor<'c>>::Database>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
[src]
self,
sql: &'q str
) -> Pin<Box<dyn Future<Output = Result<Describe<<&'c mut PgConnection as Executor<'c>>::Database>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
impl<'c> Executor<'c> for &'c mut SqliteConnection
[src]
impl<'c> Executor<'c> for &'c mut SqliteConnection
[src]type Database = Sqlite
pub fn fetch_many<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<Either<SqliteQueryResult, SqliteRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, <&'c mut SqliteConnection as Executor<'c>>::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<Either<SqliteQueryResult, SqliteRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, <&'c mut SqliteConnection as Executor<'c>>::Database>,
pub fn fetch_optional<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Option<SqliteRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, <&'c mut SqliteConnection as Executor<'c>>::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Option<SqliteRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, <&'c mut SqliteConnection as Executor<'c>>::Database>,
pub fn prepare_with<'e, 'q>(
self,
sql: &'q str,
_parameters: &[SqliteTypeInfo]
) -> Pin<Box<dyn Future<Output = Result<SqliteStatement<'q>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
[src]
self,
sql: &'q str,
_parameters: &[SqliteTypeInfo]
) -> Pin<Box<dyn Future<Output = Result<SqliteStatement<'q>, Error>> + 'e + Send, Global>> where
'q: 'e,
'c: 'e,
impl<'c, 't> Executor<'t> for &'t mut Transaction<'c, Any>
[src]
impl<'c, 't> Executor<'t> for &'t mut Transaction<'c, Any>
[src]type Database = Any
pub fn fetch_many<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<Either<<Any as Database>::QueryResult, AnyRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
't: 'e,
E: 'q + Execute<'q, <&'t mut Transaction<'c, Any> as Executor<'t>>::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<Either<<Any as Database>::QueryResult, AnyRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
't: 'e,
E: 'q + Execute<'q, <&'t mut Transaction<'c, Any> as Executor<'t>>::Database>,
pub fn fetch_optional<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Option<AnyRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
't: 'e,
E: 'q + Execute<'q, <&'t mut Transaction<'c, Any> as Executor<'t>>::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Option<AnyRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
't: 'e,
E: 'q + Execute<'q, <&'t mut Transaction<'c, Any> as Executor<'t>>::Database>,
pub fn prepare_with<'e, 'q>(
self,
sql: &'q str,
parameters: &'e [<<&'t mut Transaction<'c, Any> as Executor<'t>>::Database as Database>::TypeInfo]
) -> Pin<Box<dyn Future<Output = Result<<<&'t mut Transaction<'c, Any> as Executor<'t>>::Database as HasStatement<'q>>::Statement, Error>> + 'e + Send, Global>> where
'q: 'e,
't: 'e,
[src]
self,
sql: &'q str,
parameters: &'e [<<&'t mut Transaction<'c, Any> as Executor<'t>>::Database as Database>::TypeInfo]
) -> Pin<Box<dyn Future<Output = Result<<<&'t mut Transaction<'c, Any> as Executor<'t>>::Database as HasStatement<'q>>::Statement, Error>> + 'e + Send, Global>> where
'q: 'e,
't: 'e,
impl<'c, 't> Executor<'t> for &'t mut Transaction<'c, Mssql>
[src]
impl<'c, 't> Executor<'t> for &'t mut Transaction<'c, Mssql>
[src]type Database = Mssql
pub fn fetch_many<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<Either<<Mssql as Database>::QueryResult, MssqlRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
't: 'e,
E: 'q + Execute<'q, <&'t mut Transaction<'c, Mssql> as Executor<'t>>::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<Either<<Mssql as Database>::QueryResult, MssqlRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
't: 'e,
E: 'q + Execute<'q, <&'t mut Transaction<'c, Mssql> as Executor<'t>>::Database>,
pub fn fetch_optional<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Option<MssqlRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
't: 'e,
E: 'q + Execute<'q, <&'t mut Transaction<'c, Mssql> as Executor<'t>>::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Option<MssqlRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
't: 'e,
E: 'q + Execute<'q, <&'t mut Transaction<'c, Mssql> as Executor<'t>>::Database>,
pub fn prepare_with<'e, 'q>(
self,
sql: &'q str,
parameters: &'e [<<&'t mut Transaction<'c, Mssql> as Executor<'t>>::Database as Database>::TypeInfo]
) -> Pin<Box<dyn Future<Output = Result<<<&'t mut Transaction<'c, Mssql> as Executor<'t>>::Database as HasStatement<'q>>::Statement, Error>> + 'e + Send, Global>> where
'q: 'e,
't: 'e,
[src]
self,
sql: &'q str,
parameters: &'e [<<&'t mut Transaction<'c, Mssql> as Executor<'t>>::Database as Database>::TypeInfo]
) -> Pin<Box<dyn Future<Output = Result<<<&'t mut Transaction<'c, Mssql> as Executor<'t>>::Database as HasStatement<'q>>::Statement, Error>> + 'e + Send, Global>> where
'q: 'e,
't: 'e,
impl<'c, 't> Executor<'t> for &'t mut Transaction<'c, MySql>
[src]
impl<'c, 't> Executor<'t> for &'t mut Transaction<'c, MySql>
[src]type Database = MySql
pub fn fetch_many<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<Either<<MySql as Database>::QueryResult, MySqlRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
't: 'e,
E: 'q + Execute<'q, <&'t mut Transaction<'c, MySql> as Executor<'t>>::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<Either<<MySql as Database>::QueryResult, MySqlRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
't: 'e,
E: 'q + Execute<'q, <&'t mut Transaction<'c, MySql> as Executor<'t>>::Database>,
pub fn fetch_optional<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Option<MySqlRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
't: 'e,
E: 'q + Execute<'q, <&'t mut Transaction<'c, MySql> as Executor<'t>>::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Option<MySqlRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
't: 'e,
E: 'q + Execute<'q, <&'t mut Transaction<'c, MySql> as Executor<'t>>::Database>,
pub fn prepare_with<'e, 'q>(
self,
sql: &'q str,
parameters: &'e [<<&'t mut Transaction<'c, MySql> as Executor<'t>>::Database as Database>::TypeInfo]
) -> Pin<Box<dyn Future<Output = Result<<<&'t mut Transaction<'c, MySql> as Executor<'t>>::Database as HasStatement<'q>>::Statement, Error>> + 'e + Send, Global>> where
'q: 'e,
't: 'e,
[src]
self,
sql: &'q str,
parameters: &'e [<<&'t mut Transaction<'c, MySql> as Executor<'t>>::Database as Database>::TypeInfo]
) -> Pin<Box<dyn Future<Output = Result<<<&'t mut Transaction<'c, MySql> as Executor<'t>>::Database as HasStatement<'q>>::Statement, Error>> + 'e + Send, Global>> where
'q: 'e,
't: 'e,
impl<'c, 't> Executor<'t> for &'t mut Transaction<'c, Postgres>
[src]
impl<'c, 't> Executor<'t> for &'t mut Transaction<'c, Postgres>
[src]type Database = Postgres
pub fn fetch_many<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<Either<<Postgres as Database>::QueryResult, PgRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
't: 'e,
E: 'q + Execute<'q, <&'t mut Transaction<'c, Postgres> as Executor<'t>>::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<Either<<Postgres as Database>::QueryResult, PgRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
't: 'e,
E: 'q + Execute<'q, <&'t mut Transaction<'c, Postgres> as Executor<'t>>::Database>,
pub fn fetch_optional<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Option<PgRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
't: 'e,
E: 'q + Execute<'q, <&'t mut Transaction<'c, Postgres> as Executor<'t>>::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Option<PgRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
't: 'e,
E: 'q + Execute<'q, <&'t mut Transaction<'c, Postgres> as Executor<'t>>::Database>,
pub fn prepare_with<'e, 'q>(
self,
sql: &'q str,
parameters: &'e [<<&'t mut Transaction<'c, Postgres> as Executor<'t>>::Database as Database>::TypeInfo]
) -> Pin<Box<dyn Future<Output = Result<<<&'t mut Transaction<'c, Postgres> as Executor<'t>>::Database as HasStatement<'q>>::Statement, Error>> + 'e + Send, Global>> where
'q: 'e,
't: 'e,
[src]
self,
sql: &'q str,
parameters: &'e [<<&'t mut Transaction<'c, Postgres> as Executor<'t>>::Database as Database>::TypeInfo]
) -> Pin<Box<dyn Future<Output = Result<<<&'t mut Transaction<'c, Postgres> as Executor<'t>>::Database as HasStatement<'q>>::Statement, Error>> + 'e + Send, Global>> where
'q: 'e,
't: 'e,
impl<'c, 't> Executor<'t> for &'t mut Transaction<'c, Sqlite>
[src]
impl<'c, 't> Executor<'t> for &'t mut Transaction<'c, Sqlite>
[src]type Database = Sqlite
pub fn fetch_many<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<Either<<Sqlite as Database>::QueryResult, SqliteRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
't: 'e,
E: 'q + Execute<'q, <&'t mut Transaction<'c, Sqlite> as Executor<'t>>::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<Either<<Sqlite as Database>::QueryResult, SqliteRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
't: 'e,
E: 'q + Execute<'q, <&'t mut Transaction<'c, Sqlite> as Executor<'t>>::Database>,
pub fn fetch_optional<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Option<SqliteRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
't: 'e,
E: 'q + Execute<'q, <&'t mut Transaction<'c, Sqlite> as Executor<'t>>::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Option<SqliteRow>, Error>> + 'e + Send, Global>> where
'q: 'e,
't: 'e,
E: 'q + Execute<'q, <&'t mut Transaction<'c, Sqlite> as Executor<'t>>::Database>,
pub fn prepare_with<'e, 'q>(
self,
sql: &'q str,
parameters: &'e [<<&'t mut Transaction<'c, Sqlite> as Executor<'t>>::Database as Database>::TypeInfo]
) -> Pin<Box<dyn Future<Output = Result<<<&'t mut Transaction<'c, Sqlite> as Executor<'t>>::Database as HasStatement<'q>>::Statement, Error>> + 'e + Send, Global>> where
'q: 'e,
't: 'e,
[src]
self,
sql: &'q str,
parameters: &'e [<<&'t mut Transaction<'c, Sqlite> as Executor<'t>>::Database as Database>::TypeInfo]
) -> Pin<Box<dyn Future<Output = Result<<<&'t mut Transaction<'c, Sqlite> as Executor<'t>>::Database as HasStatement<'q>>::Statement, Error>> + 'e + Send, Global>> where
'q: 'e,
't: 'e,
impl<'p, '_, DB> Executor<'p> for &'_ Pool<DB> where
DB: Database,
&'c mut <DB as Database>::Connection: for<'c> Executor<'c>,
<&'c mut <DB as Database>::Connection as Executor<'c>>::Database == DB,
[src]
impl<'p, '_, DB> Executor<'p> for &'_ Pool<DB> where
DB: Database,
&'c mut <DB as Database>::Connection: for<'c> Executor<'c>,
<&'c mut <DB as Database>::Connection as Executor<'c>>::Database == DB,
[src]type Database = DB
pub fn fetch_many<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<Either<<DB as Database>::QueryResult, <DB as Database>::Row>, Error>> + 'e + Send, Global>> where
'q: 'e,
E: 'q + Execute<'q, <&'_ Pool<DB> as Executor<'p>>::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<Either<<DB as Database>::QueryResult, <DB as Database>::Row>, Error>> + 'e + Send, Global>> where
'q: 'e,
E: 'q + Execute<'q, <&'_ Pool<DB> as Executor<'p>>::Database>,
pub fn fetch_optional<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Option<<DB as Database>::Row>, Error>> + 'e + Send, Global>> where
'q: 'e,
E: 'q + Execute<'q, <&'_ Pool<DB> as Executor<'p>>::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Option<<DB as Database>::Row>, Error>> + 'e + Send, Global>> where
'q: 'e,
E: 'q + Execute<'q, <&'_ Pool<DB> as Executor<'p>>::Database>,
pub fn prepare_with<'e, 'q>(
self,
sql: &'q str,
parameters: &'e [<<&'_ Pool<DB> as Executor<'p>>::Database as Database>::TypeInfo]
) -> Pin<Box<dyn Future<Output = Result<<<&'_ Pool<DB> as Executor<'p>>::Database as HasStatement<'q>>::Statement, Error>> + 'e + Send, Global>> where
'q: 'e,
[src]
self,
sql: &'q str,
parameters: &'e [<<&'_ Pool<DB> as Executor<'p>>::Database as Database>::TypeInfo]
) -> Pin<Box<dyn Future<Output = Result<<<&'_ Pool<DB> as Executor<'p>>::Database as HasStatement<'q>>::Statement, Error>> + 'e + Send, Global>> where
'q: 'e,