Struct sqlx::Transaction

pub struct Transaction<T> where
    T: Connection + Send + 'static,  { /* fields omitted */ }

Methods

impl<T> Transaction<T> where
    T: Connection + Send + 'static, 

pub async fn begin(__arg0: Self) -> Result<Transaction<T>, Error>

pub async fn commit(__arg0: Self) -> Result<T, Error>

pub async fn rollback(__arg0: Self) -> Result<T, Error>

Trait Implementations

impl<T> Connection for Transaction<T> where
    T: Connection, 

fn close(
    self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'static + Send>>

Close this database connection.

fn ping(&mut self) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send>>

Verifies a connection to the database is still alive.

impl<Conn> Deref for Transaction<Conn> where
    Conn: Connection, 

type Target = Conn

The resulting type after dereferencing.

fn deref(&self) -> &<Transaction<Conn> as Deref>::Target

Dereferences the value.

impl<Conn> DerefMut for Transaction<Conn> where
    Conn: Connection, 

fn deref_mut(&mut self) -> &mut <Transaction<Conn> as Deref>::Target

Mutably dereferences the value.

impl<Conn> Drop for Transaction<Conn> where
    Conn: Connection, 

fn drop(&mut self)

Executes the destructor for this type.

impl<T> Executor for Transaction<T> where
    T: Connection, 

type Database = <T as Executor>::Database

fn send<'e, 'q>(
    &'e mut self,
    commands: &'q str
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'e + Send>> where
    'q: 'e, 

Send a raw SQL command to the database.

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

Execute the query, returning the number of rows affected.

fn fetch<'e, 'q>(
    &'e mut self,
    query: &'q str,
    args: <<Transaction<T> as Executor>::Database as Database>::Arguments
) -> Pin<Box<dyn Stream<Item = Result<<<Transaction<T> as Executor>::Database as Database>::Row, Error>> + 'e + Send>> where
    'q: 'e, 

Executes the query and returns a [Stream] of [Row].

fn fetch_optional<'e, 'q>(
    &'e mut self,
    query: &'q str,
    args: <<Transaction<T> as Executor>::Database as Database>::Arguments
) -> Pin<Box<dyn Future<Output = Result<Option<<<Transaction<T> as Executor>::Database as Database>::Row>, Error>> + 'e + Send>> where
    'q: 'e, 

Executes the query and returns up to resulting record.

fn describe<'e, 'q>(
    &'e mut self,
    query: &'q str
) -> Pin<Box<dyn Future<Output = Result<Describe<<Transaction<T> as Executor>::Database>, Error>> + 'e + Send>> where
    'q: 'e, 

fn fetch_one<'e, 'q>(
    &'e mut self,
    query: &'q str,
    args: <Self::Database as Database>::Arguments
) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::Row, Error>> + 'e + Send>> where
    'q: 'e, 

Execute the query and return at most one resulting record.