Skip to main content

Tx

actix_sqlx_tx

Struct Tx 

Source 
pub struct Tx<DB: Database, E = Error>(/* private fields */);
Expand description

An actix extractor for a database transaction.

&mut Tx implements sqlx::Executor so it can be used directly with sqlx::query() (and sqlx::query_as(), the corresponding macros, etc.):

use actix_sqlx_tx::Tx;
use sqlx::Sqlite;

async fn handler(mut tx: Tx<Sqlite>) -> Result<(), sqlx::Error> {
    sqlx::query("...").execute(&mut tx).await?;
    /* ... */
}

It also implements Deref<Target = sqlx::Transaction> and DerefMut, so you can call methods from Transaction and its traits:

use actix_sqlx_tx::Tx;
use sqlx::{Acquire as _, Sqlite};

async fn handler(mut tx: Tx<Sqlite>) -> Result<(), sqlx::Error> {
    let inner = tx.begin().await?;
    /* ... */
}

The E generic parameter controls the error type returned when the extractor fails. This can be used to configure the error response returned when the extractor fails:

use actix_web::{
    http::{header::ContentType, StatusCode},
    HttpResponse, ResponseError,
};
use actix_sqlx_tx::Tx;
use sqlx::Sqlite;
[derive(Debug)]
struct MyError(actix_sqlx_tx::Error);

// The error type must implement From<actix_sqlx_tx::Error>
impl From<actix_sqlx_tx::Error> for MyError {
    fn from(error: actix_sqlx_tx::Error) -> Self {
        Self(error)
    }
}

// The error type must implement ResponseError
impl ResponseError for MyError {
    fn error_response(&self) -> HttpResponse {
        HttpResponse::build(self.status_code())
            .insert_header(ContentType::html())
            .body(self.to_string())
    }

    fn status_code(&self) -> StatusCode {
        StatusCode::INTERNAL_SERVER_ERROR
    }
}

async fn handler(tx: Tx<Sqlite, MyError>) {
    /* ... */
}

Implementations§

Source§

impl<DB: Database, E> Tx<DB, E>

Source

pub async fn commit(self) -> Result<(), Error>

Explicitly commit the transaction.

By default, the transaction will be committed when a successful response is returned (specifically, when the Service middleware intercepts an HTTP 2XX response). This method allows the transaction to be committed explicitly.

Note: trying to use the Tx extractor again after calling commit will currently generate Error::OverlappingExtractors errors. This may change in future.

Trait Implementations§

Source§

impl<DB: Database, E> AsMut<Transaction<'static, DB>> for Tx<DB, E>

Source§

fn as_mut(&mut self) -> &mut Transaction<'static, DB>

Converts this type into a mutable reference of the (usually inferred) input type.
Source§

impl<DB: Database, E> AsRef<Transaction<'static, DB>> for Tx<DB, E>

Source§

fn as_ref(&self) -> &Transaction<'static, DB>

Converts this type into a shared reference of the (usually inferred) input type.
Source§

impl<DB: Debug + Database, E: Debug> Debug for Tx<DB, E>

Source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
Source§

impl<DB: Database, E> Deref for Tx<DB, E>

Source§

type Target = Transaction<'static, DB>

The resulting type after dereferencing.
Source§

fn deref(&self) -> &Self::Target

Dereferences the value.
Source§

impl<DB: Database, E> DerefMut for Tx<DB, E>

Source§

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.
Source§

impl<'c, E: Debug + Send> Executor<'c> for &'c mut Tx<Any, E>

Source§

type Database = Any

Source§

fn fetch_many<'e, 'q: 'e, Q>( self, query: Q, ) -> BoxStream<'e, Result<Either<<Self::Database as Database>::QueryResult, <Self::Database as Database>::Row>, Error>>
where Q: Execute<'q, Self::Database> + 'q, 'c: 'e,

Execute multiple queries and return the generated results as a stream from each query, in a stream.
Source§

fn fetch_optional<'e, 'q: 'e, Q>( self, query: Q, ) -> BoxFuture<'e, Result<Option<<Self::Database as Database>::Row>, Error>>
where Q: Execute<'q, Self::Database> + 'q, 'c: 'e,

Execute the query and returns at most one row.
Source§

fn prepare_with<'e, 'q: 'e>( self, sql: &'q str, parameters: &'e [<Self::Database as Database>::TypeInfo], ) -> BoxFuture<'e, Result<<Self::Database as HasStatement<'q>>::Statement, Error>>
where 'c: 'e,

Prepare the SQL query, with parameter type information, to inspect the type information about its parameters and results. Read more
Source§

fn execute<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::QueryResult, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and return the total number of rows affected.
Source§

fn execute_many<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::QueryResult, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute multiple queries and return the rows affected from each query, in a stream.
Source§

fn fetch<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::Row, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and return the generated results as a stream.
Source§

fn fetch_all<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<Vec<<Self::Database as Database>::Row>, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and return all the generated results, collected into a Vec.
Source§

fn fetch_one<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::Row, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and returns exactly one row.
Source§

fn prepare<'e, 'q>( self, query: &'q str, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as HasStatement<'q>>::Statement, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e,

Prepare the SQL query to inspect the type information of its parameters and results. Read more
Source§

impl<'c, E: Debug + Send> Executor<'c> for &'c mut Tx<Mssql, E>

Source§

type Database = Mssql

Source§

fn fetch_many<'e, 'q: 'e, Q>( self, query: Q, ) -> BoxStream<'e, Result<Either<<Self::Database as Database>::QueryResult, <Self::Database as Database>::Row>, Error>>
where Q: Execute<'q, Self::Database> + 'q, 'c: 'e,

Execute multiple queries and return the generated results as a stream from each query, in a stream.
Source§

fn fetch_optional<'e, 'q: 'e, Q>( self, query: Q, ) -> BoxFuture<'e, Result<Option<<Self::Database as Database>::Row>, Error>>
where Q: Execute<'q, Self::Database> + 'q, 'c: 'e,

Execute the query and returns at most one row.
Source§

fn prepare_with<'e, 'q: 'e>( self, sql: &'q str, parameters: &'e [<Self::Database as Database>::TypeInfo], ) -> BoxFuture<'e, Result<<Self::Database as HasStatement<'q>>::Statement, Error>>
where 'c: 'e,

Prepare the SQL query, with parameter type information, to inspect the type information about its parameters and results. Read more
Source§

fn execute<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::QueryResult, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and return the total number of rows affected.
Source§

fn execute_many<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::QueryResult, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute multiple queries and return the rows affected from each query, in a stream.
Source§

fn fetch<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::Row, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and return the generated results as a stream.
Source§

fn fetch_all<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<Vec<<Self::Database as Database>::Row>, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and return all the generated results, collected into a Vec.
Source§

fn fetch_one<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::Row, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and returns exactly one row.
Source§

fn prepare<'e, 'q>( self, query: &'q str, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as HasStatement<'q>>::Statement, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e,

Prepare the SQL query to inspect the type information of its parameters and results. Read more
Source§

impl<'c, E: Debug + Send> Executor<'c> for &'c mut Tx<MySql, E>

Source§

type Database = MySql

Source§

fn fetch_many<'e, 'q: 'e, Q>( self, query: Q, ) -> BoxStream<'e, Result<Either<<Self::Database as Database>::QueryResult, <Self::Database as Database>::Row>, Error>>
where Q: Execute<'q, Self::Database> + 'q, 'c: 'e,

Execute multiple queries and return the generated results as a stream from each query, in a stream.
Source§

fn fetch_optional<'e, 'q: 'e, Q>( self, query: Q, ) -> BoxFuture<'e, Result<Option<<Self::Database as Database>::Row>, Error>>
where Q: Execute<'q, Self::Database> + 'q, 'c: 'e,

Execute the query and returns at most one row.
Source§

fn prepare_with<'e, 'q: 'e>( self, sql: &'q str, parameters: &'e [<Self::Database as Database>::TypeInfo], ) -> BoxFuture<'e, Result<<Self::Database as HasStatement<'q>>::Statement, Error>>
where 'c: 'e,

Prepare the SQL query, with parameter type information, to inspect the type information about its parameters and results. Read more
Source§

fn execute<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::QueryResult, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and return the total number of rows affected.
Source§

fn execute_many<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::QueryResult, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute multiple queries and return the rows affected from each query, in a stream.
Source§

fn fetch<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::Row, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and return the generated results as a stream.
Source§

fn fetch_all<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<Vec<<Self::Database as Database>::Row>, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and return all the generated results, collected into a Vec.
Source§

fn fetch_one<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::Row, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and returns exactly one row.
Source§

fn prepare<'e, 'q>( self, query: &'q str, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as HasStatement<'q>>::Statement, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e,

Prepare the SQL query to inspect the type information of its parameters and results. Read more
Source§

impl<'c, E: Debug + Send> Executor<'c> for &'c mut Tx<Postgres, E>

Source§

type Database = Postgres

Source§

fn fetch_many<'e, 'q: 'e, Q>( self, query: Q, ) -> BoxStream<'e, Result<Either<<Self::Database as Database>::QueryResult, <Self::Database as Database>::Row>, Error>>
where Q: Execute<'q, Self::Database> + 'q, 'c: 'e,

Execute multiple queries and return the generated results as a stream from each query, in a stream.
Source§

fn fetch_optional<'e, 'q: 'e, Q>( self, query: Q, ) -> BoxFuture<'e, Result<Option<<Self::Database as Database>::Row>, Error>>
where Q: Execute<'q, Self::Database> + 'q, 'c: 'e,

Execute the query and returns at most one row.
Source§

fn prepare_with<'e, 'q: 'e>( self, sql: &'q str, parameters: &'e [<Self::Database as Database>::TypeInfo], ) -> BoxFuture<'e, Result<<Self::Database as HasStatement<'q>>::Statement, Error>>
where 'c: 'e,

Prepare the SQL query, with parameter type information, to inspect the type information about its parameters and results. Read more
Source§

fn execute<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::QueryResult, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and return the total number of rows affected.
Source§

fn execute_many<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::QueryResult, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute multiple queries and return the rows affected from each query, in a stream.
Source§

fn fetch<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::Row, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and return the generated results as a stream.
Source§

fn fetch_all<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<Vec<<Self::Database as Database>::Row>, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and return all the generated results, collected into a Vec.
Source§

fn fetch_one<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::Row, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and returns exactly one row.
Source§

fn prepare<'e, 'q>( self, query: &'q str, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as HasStatement<'q>>::Statement, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e,

Prepare the SQL query to inspect the type information of its parameters and results. Read more
Source§

impl<'c, E: Debug + Send> Executor<'c> for &'c mut Tx<Sqlite, E>

Source§

type Database = Sqlite

Source§

fn fetch_many<'e, 'q: 'e, Q>( self, query: Q, ) -> BoxStream<'e, Result<Either<<Self::Database as Database>::QueryResult, <Self::Database as Database>::Row>, Error>>
where Q: Execute<'q, Self::Database> + 'q, 'c: 'e,

Execute multiple queries and return the generated results as a stream from each query, in a stream.
Source§

fn fetch_optional<'e, 'q: 'e, Q>( self, query: Q, ) -> BoxFuture<'e, Result<Option<<Self::Database as Database>::Row>, Error>>
where Q: Execute<'q, Self::Database> + 'q, 'c: 'e,

Execute the query and returns at most one row.
Source§

fn prepare_with<'e, 'q: 'e>( self, sql: &'q str, parameters: &'e [<Self::Database as Database>::TypeInfo], ) -> BoxFuture<'e, Result<<Self::Database as HasStatement<'q>>::Statement, Error>>
where 'c: 'e,

Prepare the SQL query, with parameter type information, to inspect the type information about its parameters and results. Read more
Source§

fn execute<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::QueryResult, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and return the total number of rows affected.
Source§

fn execute_many<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::QueryResult, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute multiple queries and return the rows affected from each query, in a stream.
Source§

fn fetch<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::Row, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and return the generated results as a stream.
Source§

fn fetch_all<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<Vec<<Self::Database as Database>::Row>, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and return all the generated results, collected into a Vec.
Source§

fn fetch_one<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::Row, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and returns exactly one row.
Source§

fn prepare<'e, 'q>( self, query: &'q str, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as HasStatement<'q>>::Statement, Error>> + Send + 'e>>
where 'q: 'e, 'c: 'e,

Prepare the SQL query to inspect the type information of its parameters and results. Read more
Source§

impl<DB: Database, E> FromRequest for Tx<DB, E>
where E: From<Error> + ResponseError + 'static,

Source§

type Error = E

The associated error which can be returned.
Source§

type Future = Pin<Box<dyn Future<Output = Result<Tx<DB, E>, <Tx<DB, E> as FromRequest>::Error>>>>

Future that resolves to a Self. Read more
Source§

fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future

Create a Self from request parts asynchronously.
Source§

fn extract(req: &HttpRequest) -> Self::Future

Create a Self from request head asynchronously. Read more

Auto Trait Implementations§

§

impl<DB, E = Error> !RefUnwindSafe for Tx<DB, E>

§

impl<DB, E = Error> !UnwindSafe for Tx<DB, E>

§

impl<DB, E> Freeze for Tx<DB, E>
where <DB as Database>::Connection: Freeze,

§

impl<DB, E> Send for Tx<DB, E>
where E: Send,

§

impl<DB, E> Sync for Tx<DB, E>
where E: Sync, <DB as Database>::Connection: Sync,

§

impl<DB, E> Unpin for Tx<DB, E>
where E: Unpin, <DB as Database>::Connection: Unpin,

§

impl<DB, E> UnsafeUnpin for Tx<DB, E>
where <DB as Database>::Connection: UnsafeUnpin,

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for DT
where ST: ?Sized, DT: ?Sized,

Source§

impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for DT
where ST: ?Sized, DT: ?Sized,

Source§

impl<T> Formattable for T
where T: Deref, <T as Deref>::Target: Formattable,

Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T> Instrument for T

Source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
Source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

impl<T> Read<Exclusive, BecauseExclusive> for T
where T: ?Sized,

Source§

impl<P, T> Receiver for P
where P: Deref<Target = T> + ?Sized, T: ?Sized,

Source§

type Target = T

🔬This is a nightly-only experimental API. (arbitrary_self_types)
The target type on which the method may be called.
Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

Source§

fn vzip(self) -> V

Source§

impl<T> WithSubscriber for T

Source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more