[−][src]Struct sqlx::Transaction
An in-progress database transaction or savepoint.
A transaction starts with a call to Pool::begin
or Connection::begin
.
A transaction should end with a call to commit
or rollback
. If neither are called
before the transaction goes out-of-scope, rollback
is called. In other
words, rollback
is called on drop
if the transaction is still in-progress.
A savepoint is a special mark inside a transaction that allows all commands that are executed after it was established to be rolled back, restoring the transaction state to what it was at the time of the savepoint.
Implementations
impl<'c, DB> Transaction<'c, DB> where
DB: Database,
[src]
DB: Database,
pub async fn commit(__arg0: Self) -> Result<(), Error>
[src]
Commits this transaction or savepoint.
pub async fn rollback(__arg0: Self) -> Result<(), Error>
[src]
Aborts this transaction or savepoint.
Trait Implementations
impl<'c, 't> Acquire<'t> for &'t mut Transaction<'c, Any>
[src]
type Database = Any
type Connection = &'t mut <Any as Database>::Connection
fn acquire(
self
) -> Pin<Box<dyn Future<Output = Result<<&'t mut Transaction<'c, Any> as Acquire<'t>>::Connection, Error>> + 't + Send>>
[src]
self
) -> Pin<Box<dyn Future<Output = Result<<&'t mut Transaction<'c, Any> as Acquire<'t>>::Connection, Error>> + 't + Send>>
fn begin(
self
) -> Pin<Box<dyn Future<Output = Result<Transaction<'t, Any>, Error>> + 't + Send>>
[src]
self
) -> Pin<Box<dyn Future<Output = Result<Transaction<'t, Any>, Error>> + 't + Send>>
impl<'c, 't> Acquire<'t> for &'t mut Transaction<'c, Sqlite>
[src]
type Database = Sqlite
type Connection = &'t mut <Sqlite as Database>::Connection
fn acquire(
self
) -> Pin<Box<dyn Future<Output = Result<<&'t mut Transaction<'c, Sqlite> as Acquire<'t>>::Connection, Error>> + 't + Send>>
[src]
self
) -> Pin<Box<dyn Future<Output = Result<<&'t mut Transaction<'c, Sqlite> as Acquire<'t>>::Connection, Error>> + 't + Send>>
fn begin(
self
) -> Pin<Box<dyn Future<Output = Result<Transaction<'t, Sqlite>, Error>> + 't + Send>>
[src]
self
) -> Pin<Box<dyn Future<Output = Result<Transaction<'t, Sqlite>, Error>> + 't + Send>>
impl<'c, 't> Acquire<'t> for &'t mut Transaction<'c, Postgres>
[src]
type Database = Postgres
type Connection = &'t mut <Postgres as Database>::Connection
fn acquire(
self
) -> Pin<Box<dyn Future<Output = Result<<&'t mut Transaction<'c, Postgres> as Acquire<'t>>::Connection, Error>> + 't + Send>>
[src]
self
) -> Pin<Box<dyn Future<Output = Result<<&'t mut Transaction<'c, Postgres> as Acquire<'t>>::Connection, Error>> + 't + Send>>
fn begin(
self
) -> Pin<Box<dyn Future<Output = Result<Transaction<'t, Postgres>, Error>> + 't + Send>>
[src]
self
) -> Pin<Box<dyn Future<Output = Result<Transaction<'t, Postgres>, Error>> + 't + Send>>
impl<'c, 't> Acquire<'t> for &'t mut Transaction<'c, Mssql>
[src]
type Database = Mssql
type Connection = &'t mut <Mssql as Database>::Connection
fn acquire(
self
) -> Pin<Box<dyn Future<Output = Result<<&'t mut Transaction<'c, Mssql> as Acquire<'t>>::Connection, Error>> + 't + Send>>
[src]
self
) -> Pin<Box<dyn Future<Output = Result<<&'t mut Transaction<'c, Mssql> as Acquire<'t>>::Connection, Error>> + 't + Send>>
fn begin(
self
) -> Pin<Box<dyn Future<Output = Result<Transaction<'t, Mssql>, Error>> + 't + Send>>
[src]
self
) -> Pin<Box<dyn Future<Output = Result<Transaction<'t, Mssql>, Error>> + 't + Send>>
impl<'c, 't> Acquire<'t> for &'t mut Transaction<'c, MySql>
[src]
type Database = MySql
type Connection = &'t mut <MySql as Database>::Connection
fn acquire(
self
) -> Pin<Box<dyn Future<Output = Result<<&'t mut Transaction<'c, MySql> as Acquire<'t>>::Connection, Error>> + 't + Send>>
[src]
self
) -> Pin<Box<dyn Future<Output = Result<<&'t mut Transaction<'c, MySql> as Acquire<'t>>::Connection, Error>> + 't + Send>>
fn begin(
self
) -> Pin<Box<dyn Future<Output = Result<Transaction<'t, MySql>, Error>> + 't + Send>>
[src]
self
) -> Pin<Box<dyn Future<Output = Result<Transaction<'t, MySql>, Error>> + 't + Send>>
impl<'c, DB> Debug for Transaction<'c, DB> where
DB: Database,
[src]
DB: Database,
impl<'c, DB> Deref for Transaction<'c, DB> where
DB: Database,
[src]
DB: Database,
type Target = <DB as Database>::Connection
The resulting type after dereferencing.
fn deref(&self) -> &<Transaction<'c, DB> as Deref>::Target
[src]
impl<'c, DB> DerefMut for Transaction<'c, DB> where
DB: Database,
[src]
DB: Database,
fn deref_mut(&mut self) -> &mut <Transaction<'c, DB> as Deref>::Target
[src]
impl<'c, DB> Drop for Transaction<'c, DB> where
DB: Database,
[src]
DB: Database,
impl<'c, 't> Executor<'t> for &'t mut Transaction<'c, Any>
[src]
type Database = Any
fn fetch_many<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<Either<<Any as Database>::Done, AnyRow>, Error>> + 'e + Send>> 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>::Done, AnyRow>, Error>> + 'e + Send>> where
'q: 'e,
't: 'e,
E: 'q + Execute<'q, <&'t mut Transaction<'c, Any> as Executor<'t>>::Database>,
fn fetch_optional<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Option<AnyRow>, Error>> + 'e + Send>> 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>> where
'q: 'e,
't: 'e,
E: 'q + Execute<'q, <&'t mut Transaction<'c, Any> as Executor<'t>>::Database>,
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>> 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>> where
'q: 'e,
't: 'e,
fn execute<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::Done, Error>> + 'e + Send>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::Done, Error>> + 'e + Send>> 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>::Done, Error>> + 'e + Send>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::Done, Error>> + 'e + Send>> 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>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::Row, Error>> + 'e + Send>> 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>, Error>> + 'e + Send>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Vec<<Self::Database as Database>::Row>, Error>> + 'e + Send>> 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>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::Row, Error>> + 'e + Send>> 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>> where
'q: 'e,
'c: 'e,
[src]
self,
query: &'q str
) -> Pin<Box<dyn Future<Output = Result<<Self::Database as HasStatement<'q>>::Statement, Error>> + 'e + Send>> where
'q: 'e,
'c: 'e,
impl<'c, 't> Executor<'t> for &'t mut Transaction<'c, Mssql>
[src]
type Database = Mssql
fn fetch_many<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<Either<<Mssql as Database>::Done, MssqlRow>, Error>> + 'e + Send>> 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>::Done, MssqlRow>, Error>> + 'e + Send>> where
'q: 'e,
't: 'e,
E: 'q + Execute<'q, <&'t mut Transaction<'c, Mssql> as Executor<'t>>::Database>,
fn fetch_optional<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Option<MssqlRow>, Error>> + 'e + Send>> 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>> where
'q: 'e,
't: 'e,
E: 'q + Execute<'q, <&'t mut Transaction<'c, Mssql> as Executor<'t>>::Database>,
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>> 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>> where
'q: 'e,
't: 'e,
fn execute<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::Done, Error>> + 'e + Send>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::Done, Error>> + 'e + Send>> 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>::Done, Error>> + 'e + Send>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::Done, Error>> + 'e + Send>> 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>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::Row, Error>> + 'e + Send>> 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>, Error>> + 'e + Send>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Vec<<Self::Database as Database>::Row>, Error>> + 'e + Send>> 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>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::Row, Error>> + 'e + Send>> 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>> where
'q: 'e,
'c: 'e,
[src]
self,
query: &'q str
) -> Pin<Box<dyn Future<Output = Result<<Self::Database as HasStatement<'q>>::Statement, Error>> + 'e + Send>> where
'q: 'e,
'c: 'e,
impl<'c, 't> Executor<'t> for &'t mut Transaction<'c, Postgres>
[src]
type Database = Postgres
fn fetch_many<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<Either<<Postgres as Database>::Done, PgRow>, Error>> + 'e + Send>> 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>::Done, PgRow>, Error>> + 'e + Send>> where
'q: 'e,
't: 'e,
E: 'q + Execute<'q, <&'t mut Transaction<'c, Postgres> as Executor<'t>>::Database>,
fn fetch_optional<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Option<PgRow>, Error>> + 'e + Send>> 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>> where
'q: 'e,
't: 'e,
E: 'q + Execute<'q, <&'t mut Transaction<'c, Postgres> as Executor<'t>>::Database>,
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>> 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>> where
'q: 'e,
't: 'e,
fn execute<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::Done, Error>> + 'e + Send>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::Done, Error>> + 'e + Send>> 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>::Done, Error>> + 'e + Send>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::Done, Error>> + 'e + Send>> 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>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::Row, Error>> + 'e + Send>> 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>, Error>> + 'e + Send>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Vec<<Self::Database as Database>::Row>, Error>> + 'e + Send>> 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>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::Row, Error>> + 'e + Send>> 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>> where
'q: 'e,
'c: 'e,
[src]
self,
query: &'q str
) -> Pin<Box<dyn Future<Output = Result<<Self::Database as HasStatement<'q>>::Statement, Error>> + 'e + Send>> where
'q: 'e,
'c: 'e,
impl<'c, 't> Executor<'t> for &'t mut Transaction<'c, MySql>
[src]
type Database = MySql
fn fetch_many<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<Either<<MySql as Database>::Done, MySqlRow>, Error>> + 'e + Send>> 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>::Done, MySqlRow>, Error>> + 'e + Send>> where
'q: 'e,
't: 'e,
E: 'q + Execute<'q, <&'t mut Transaction<'c, MySql> as Executor<'t>>::Database>,
fn fetch_optional<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Option<MySqlRow>, Error>> + 'e + Send>> 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>> where
'q: 'e,
't: 'e,
E: 'q + Execute<'q, <&'t mut Transaction<'c, MySql> as Executor<'t>>::Database>,
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>> 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>> where
'q: 'e,
't: 'e,
fn execute<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::Done, Error>> + 'e + Send>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::Done, Error>> + 'e + Send>> 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>::Done, Error>> + 'e + Send>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::Done, Error>> + 'e + Send>> 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>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::Row, Error>> + 'e + Send>> 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>, Error>> + 'e + Send>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Vec<<Self::Database as Database>::Row>, Error>> + 'e + Send>> 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>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::Row, Error>> + 'e + Send>> 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>> where
'q: 'e,
'c: 'e,
[src]
self,
query: &'q str
) -> Pin<Box<dyn Future<Output = Result<<Self::Database as HasStatement<'q>>::Statement, Error>> + 'e + Send>> where
'q: 'e,
'c: 'e,
impl<'c, 't> Executor<'t> for &'t mut Transaction<'c, Sqlite>
[src]
type Database = Sqlite
fn fetch_many<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<Either<<Sqlite as Database>::Done, SqliteRow>, Error>> + 'e + Send>> 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>::Done, SqliteRow>, Error>> + 'e + Send>> where
'q: 'e,
't: 'e,
E: 'q + Execute<'q, <&'t mut Transaction<'c, Sqlite> as Executor<'t>>::Database>,
fn fetch_optional<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Option<SqliteRow>, Error>> + 'e + Send>> 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>> where
'q: 'e,
't: 'e,
E: 'q + Execute<'q, <&'t mut Transaction<'c, Sqlite> as Executor<'t>>::Database>,
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>> 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>> where
'q: 'e,
't: 'e,
fn execute<'e, 'q, E>(
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::Done, Error>> + 'e + Send>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::Done, Error>> + 'e + Send>> 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>::Done, Error>> + 'e + Send>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::Done, Error>> + 'e + Send>> 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>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::Row, Error>> + 'e + Send>> 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>, Error>> + 'e + Send>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<Vec<<Self::Database as Database>::Row>, Error>> + 'e + Send>> 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>> where
'q: 'e,
'c: 'e,
E: 'q + Execute<'q, Self::Database>,
[src]
self,
query: E
) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::Row, Error>> + 'e + Send>> 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>> where
'q: 'e,
'c: 'e,
[src]
self,
query: &'q str
) -> Pin<Box<dyn Future<Output = Result<<Self::Database as HasStatement<'q>>::Statement, Error>> + 'e + Send>> where
'q: 'e,
'c: 'e,
Auto Trait Implementations
impl<'c, DB> !RefUnwindSafe for Transaction<'c, DB>
impl<'c, DB> Send for Transaction<'c, DB> where
<DB as Database>::Connection: Send,
<<DB as Database>::Connection as Connection>::Options: Send + Sync,
<DB as Database>::Connection: Send,
<<DB as Database>::Connection as Connection>::Options: Send + Sync,
impl<'c, DB> Sync for Transaction<'c, DB> where
<DB as Database>::Connection: Send + Sync,
<<DB as Database>::Connection as Connection>::Options: Send + Sync,
<DB as Database>::Connection: Send + Sync,
<<DB as Database>::Connection as Connection>::Options: Send + Sync,
impl<'c, DB> Unpin for Transaction<'c, DB> where
<DB as Database>::Connection: Unpin,
<DB as Database>::Connection: Unpin,
impl<'c, DB> !UnwindSafe for Transaction<'c, DB>
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> Same<T> for T
type Output = T
Should always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
V: MultiLane<T>,