Struct sqlx::Transaction [−][src]
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(self) -> Result<(), Error>[src]
Commits this transaction or savepoint.
pub async fn rollback(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
pub fn acquire(
self
) -> Pin<Box<dyn Future<Output = Result<<&'t mut Transaction<'c, Any> as Acquire<'t>>::Connection, Error>> + 't + Send, Global>>[src]
self
) -> Pin<Box<dyn Future<Output = Result<<&'t mut Transaction<'c, Any> as Acquire<'t>>::Connection, Error>> + 't + Send, Global>>
pub fn begin(
self
) -> Pin<Box<dyn Future<Output = Result<Transaction<'t, Any>, Error>> + 't + Send, Global>>[src]
self
) -> Pin<Box<dyn Future<Output = Result<Transaction<'t, Any>, Error>> + 't + Send, Global>>
impl<'c, 't> Acquire<'t> for &'t mut Transaction<'c, Postgres>[src]
type Database = Postgres
type Connection = &'t mut <Postgres as Database>::Connection
pub fn acquire(
self
) -> Pin<Box<dyn Future<Output = Result<<&'t mut Transaction<'c, Postgres> as Acquire<'t>>::Connection, Error>> + 't + Send, Global>>[src]
self
) -> Pin<Box<dyn Future<Output = Result<<&'t mut Transaction<'c, Postgres> as Acquire<'t>>::Connection, Error>> + 't + Send, Global>>
pub fn begin(
self
) -> Pin<Box<dyn Future<Output = Result<Transaction<'t, Postgres>, Error>> + 't + Send, Global>>[src]
self
) -> Pin<Box<dyn Future<Output = Result<Transaction<'t, Postgres>, Error>> + 't + Send, Global>>
impl<'c, 't> Acquire<'t> for &'t mut Transaction<'c, MySql>[src]
type Database = MySql
type Connection = &'t mut <MySql as Database>::Connection
pub fn acquire(
self
) -> Pin<Box<dyn Future<Output = Result<<&'t mut Transaction<'c, MySql> as Acquire<'t>>::Connection, Error>> + 't + Send, Global>>[src]
self
) -> Pin<Box<dyn Future<Output = Result<<&'t mut Transaction<'c, MySql> as Acquire<'t>>::Connection, Error>> + 't + Send, Global>>
pub fn begin(
self
) -> Pin<Box<dyn Future<Output = Result<Transaction<'t, MySql>, Error>> + 't + Send, Global>>[src]
self
) -> Pin<Box<dyn Future<Output = Result<Transaction<'t, MySql>, Error>> + 't + Send, Global>>
impl<'c, 't> Acquire<'t> for &'t mut Transaction<'c, Sqlite>[src]
type Database = Sqlite
type Connection = &'t mut <Sqlite as Database>::Connection
pub fn acquire(
self
) -> Pin<Box<dyn Future<Output = Result<<&'t mut Transaction<'c, Sqlite> as Acquire<'t>>::Connection, Error>> + 't + Send, Global>>[src]
self
) -> Pin<Box<dyn Future<Output = Result<<&'t mut Transaction<'c, Sqlite> as Acquire<'t>>::Connection, Error>> + 't + Send, Global>>
pub fn begin(
self
) -> Pin<Box<dyn Future<Output = Result<Transaction<'t, Sqlite>, Error>> + 't + Send, Global>>[src]
self
) -> Pin<Box<dyn Future<Output = Result<Transaction<'t, Sqlite>, Error>> + 't + Send, Global>>
impl<'c, 't> Acquire<'t> for &'t mut Transaction<'c, Mssql>[src]
type Database = Mssql
type Connection = &'t mut <Mssql as Database>::Connection
pub fn acquire(
self
) -> Pin<Box<dyn Future<Output = Result<<&'t mut Transaction<'c, Mssql> as Acquire<'t>>::Connection, Error>> + 't + Send, Global>>[src]
self
) -> Pin<Box<dyn Future<Output = Result<<&'t mut Transaction<'c, Mssql> as Acquire<'t>>::Connection, Error>> + 't + Send, Global>>
pub fn begin(
self
) -> Pin<Box<dyn Future<Output = Result<Transaction<'t, Mssql>, Error>> + 't + Send, Global>>[src]
self
) -> Pin<Box<dyn Future<Output = Result<Transaction<'t, Mssql>, Error>> + 't + Send, Global>>
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.
pub fn deref(&self) -> &<Transaction<'c, DB> as Deref>::Target[src]
impl<'c, DB> DerefMut for Transaction<'c, DB> where
DB: Database, [src]
DB: Database,
pub 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, 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,
pub 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]
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>,
pub 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]
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>,
pub 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]
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>,
pub 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]
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>,
pub 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]
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>,
pub 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]
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,
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,
pub 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]
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>,
pub 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]
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>,
pub 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]
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>,
pub 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]
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>,
pub 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]
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>,
pub 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]
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,
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,
pub 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]
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>,
pub 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]
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>,
pub 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]
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>,
pub 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]
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>,
pub 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]
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>,
pub 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]
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,
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,
pub 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]
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>,
pub 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]
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>,
pub 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]
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>,
pub 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]
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>,
pub 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]
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>,
pub 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]
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,
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,
pub 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]
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>,
pub 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]
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>,
pub 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]
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>,
pub 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]
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>,
pub 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]
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>,
pub 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]
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,
Auto Trait Implementations
impl<'c, DB> !RefUnwindSafe for Transaction<'c, DB>[src]
impl<'c, DB> Send for Transaction<'c, DB>[src]
impl<'c, DB> Sync for Transaction<'c, DB> where
<DB as Database>::Connection: Sync, [src]
<DB as Database>::Connection: Sync,
impl<'c, DB> Unpin for Transaction<'c, DB> where
<DB as Database>::Connection: Unpin, [src]
<DB as Database>::Connection: Unpin,
impl<'c, DB> !UnwindSafe for Transaction<'c, DB>[src]
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,
pub fn borrow_mut(&mut self) -> &mut T[src]
impl<T> Conv for T
impl<T> Conv for T
impl<T> FmtForward for T
pub fn fmt_binary(self) -> FmtBinary<Self> where
Self: Binary,
Self: Binary,
pub fn fmt_display(self) -> FmtDisplay<Self> where
Self: Display,
Self: Display,
pub fn fmt_lower_exp(self) -> FmtLowerExp<Self> where
Self: LowerExp,
Self: LowerExp,
pub fn fmt_lower_hex(self) -> FmtLowerHex<Self> where
Self: LowerHex,
Self: LowerHex,
pub fn fmt_octal(self) -> FmtOctal<Self> where
Self: Octal,
Self: Octal,
pub fn fmt_pointer(self) -> FmtPointer<Self> where
Self: Pointer,
Self: Pointer,
pub fn fmt_upper_exp(self) -> FmtUpperExp<Self> where
Self: UpperExp,
Self: UpperExp,
pub fn fmt_upper_hex(self) -> FmtUpperHex<Self> where
Self: UpperHex,
Self: UpperHex,
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
U: From<T>, [src]
U: From<T>,
impl<T> Pipe for T where
T: ?Sized,
T: ?Sized,
pub fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
pub fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where
R: 'a,
R: 'a,
pub fn pipe_ref_mut<'a, R>(
&'a mut self,
func: impl FnOnce(&'a mut Self) -> R
) -> R where
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut Self) -> R
) -> R where
R: 'a,
pub fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R where
Self: Borrow<B>,
R: 'a,
B: 'a + ?Sized,
Self: Borrow<B>,
R: 'a,
B: 'a + ?Sized,
pub fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R where
Self: BorrowMut<B>,
R: 'a,
B: 'a + ?Sized,
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R where
Self: BorrowMut<B>,
R: 'a,
B: 'a + ?Sized,
pub fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R where
Self: AsRef<U>,
U: 'a + ?Sized,
R: 'a,
Self: AsRef<U>,
U: 'a + ?Sized,
R: 'a,
pub fn pipe_as_mut<'a, U, R>(
&'a mut self,
func: impl FnOnce(&'a mut U) -> R
) -> R where
Self: AsMut<U>,
U: 'a + ?Sized,
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut U) -> R
) -> R where
Self: AsMut<U>,
U: 'a + ?Sized,
R: 'a,
pub fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Deref<Target = T>,
T: 'a + ?Sized,
R: 'a,
Self: Deref<Target = T>,
T: 'a + ?Sized,
R: 'a,
pub fn pipe_deref_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: DerefMut<Target = T> + Deref,
T: 'a + ?Sized,
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: DerefMut<Target = T> + Deref,
T: 'a + ?Sized,
R: 'a,
impl<T> Pipe for T
impl<T> PipeAsRef for T
pub fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: AsRef<T>,
T: 'a,
R: 'a,
Self: AsRef<T>,
T: 'a,
R: 'a,
pub fn pipe_as_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: AsMut<T>,
T: 'a,
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: AsMut<T>,
T: 'a,
R: 'a,
impl<T> PipeBorrow for T
pub fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Borrow<T>,
T: 'a,
R: 'a,
Self: Borrow<T>,
T: 'a,
R: 'a,
pub fn pipe_borrow_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: BorrowMut<T>,
T: 'a,
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: BorrowMut<T>,
T: 'a,
R: 'a,
impl<T> PipeDeref for T
pub fn pipe_deref<'a, R>(
&'a self,
func: impl FnOnce(&'a Self::Target) -> R
) -> R where
Self: Deref,
R: 'a,
&'a self,
func: impl FnOnce(&'a Self::Target) -> R
) -> R where
Self: Deref,
R: 'a,
pub fn pipe_deref_mut<'a, R>(
&'a mut self,
func: impl FnOnce(&'a mut Self::Target) -> R
) -> R where
Self: DerefMut,
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut Self::Target) -> R
) -> R where
Self: DerefMut,
R: 'a,
impl<T> PipeRef for T
pub fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where
R: 'a,
R: 'a,
pub fn pipe_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where
R: 'a,
R: 'a,
impl<T> Same<T> for T
type Output = T
Should always be Self
impl<T> Tap for T
pub fn tap(self, func: impl FnOnce(&Self)) -> Self
pub fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self
pub fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,
Self: Borrow<B>,
B: ?Sized,
pub fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,
Self: BorrowMut<B>,
B: ?Sized,
pub fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self where
Self: AsRef<R>,
R: ?Sized,
Self: AsRef<R>,
R: ?Sized,
pub fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,
Self: AsMut<R>,
R: ?Sized,
pub fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self where
Self: Deref<Target = T>,
T: ?Sized,
Self: Deref<Target = T>,
T: ?Sized,
pub fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self where
Self: DerefMut<Target = T> + Deref,
T: ?Sized,
Self: DerefMut<Target = T> + Deref,
T: ?Sized,
pub fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
pub fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
pub fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,
Self: Borrow<B>,
B: ?Sized,
pub fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,
Self: BorrowMut<B>,
B: ?Sized,
pub fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self where
Self: AsRef<R>,
R: ?Sized,
Self: AsRef<R>,
R: ?Sized,
pub fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,
Self: AsMut<R>,
R: ?Sized,
pub fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self where
Self: Deref<Target = T>,
T: ?Sized,
Self: Deref<Target = T>,
T: ?Sized,
pub fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self where
Self: DerefMut<Target = T> + Deref,
T: ?Sized,
Self: DerefMut<Target = T> + Deref,
T: ?Sized,
impl<T> Tap for T
pub fn tap<F, R>(self, func: F) -> Self where
F: FnOnce(&Self) -> R,
F: FnOnce(&Self) -> R,
pub fn tap_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&Self) -> R,
F: FnOnce(&Self) -> R,
pub fn tap_mut<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R,
F: FnOnce(&mut Self) -> R,
pub fn tap_mut_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R,
F: FnOnce(&mut Self) -> R,
impl<T, U> TapAsRef<U> for T where
U: ?Sized,
U: ?Sized,
pub fn tap_ref<F, R>(self, func: F) -> Self where
Self: AsRef<T>,
F: FnOnce(&T) -> R,
Self: AsRef<T>,
F: FnOnce(&T) -> R,
pub fn tap_ref_dbg<F, R>(self, func: F) -> Self where
Self: AsRef<T>,
F: FnOnce(&T) -> R,
Self: AsRef<T>,
F: FnOnce(&T) -> R,
pub fn tap_ref_mut<F, R>(self, func: F) -> Self where
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
pub fn tap_ref_mut_dbg<F, R>(self, func: F) -> Self where
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
impl<T, U> TapBorrow<U> for T where
U: ?Sized,
U: ?Sized,
pub fn tap_borrow<F, R>(self, func: F) -> Self where
Self: Borrow<T>,
F: FnOnce(&T) -> R,
Self: Borrow<T>,
F: FnOnce(&T) -> R,
pub fn tap_borrow_dbg<F, R>(self, func: F) -> Self where
Self: Borrow<T>,
F: FnOnce(&T) -> R,
Self: Borrow<T>,
F: FnOnce(&T) -> R,
pub fn tap_borrow_mut<F, R>(self, func: F) -> Self where
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
pub fn tap_borrow_mut_dbg<F, R>(self, func: F) -> Self where
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
impl<T> TapDeref for T
pub fn tap_deref<F, R>(self, func: F) -> Self where
Self: Deref,
F: FnOnce(&Self::Target) -> R,
Self: Deref,
F: FnOnce(&Self::Target) -> R,
pub fn tap_deref_dbg<F, R>(self, func: F) -> Self where
Self: Deref,
F: FnOnce(&Self::Target) -> R,
Self: Deref,
F: FnOnce(&Self::Target) -> R,
pub fn tap_deref_mut<F, R>(self, func: F) -> Self where
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
pub fn tap_deref_mut_dbg<F, R>(self, func: F) -> Self where
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
impl<T> TryConv for T
impl<T> TryConv for T
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.
pub 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.
pub 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>,