Struct Map

pub struct Map<'q, DB, F, A>
where
    DB: Database,
{
    inner: Query<'q, DB, A>,
    mapper: F,
}

A single SQL query that will map its results to an owned Rust type.

Executes as a prepared statement.

Returned by Query::try_map, query!(), etc. Has most of the same methods as Query but the return types are changed to reflect the mapping. However, there is no equivalent of Query::execute as it doesn’t make sense to map the result type and then ignore it.

Query::bind is also omitted; stylistically we recommend placing your .bind() calls before .try_map(). This is also to prevent adding superfluous binds to the result of query!() et al.

Fields

inner: Query<'q, DB, A>

mapper: F

Implementations

impl<'q, DB, F, O, A> Map<'q, DB, F, A>

where DB: Database, F: FnMut(<DB as Database>::Row) -> Result<O, Error> + Send, O: Send + Unpin, A: 'q + Send + IntoArguments<'q, DB>,

pub fn map<G, P>( self, g: G, ) -> Map<'q, DB, impl FnMut(<DB as Database>::Row) + Send, A>

where G: FnMut(O) -> P + Send, P: Unpin,

Map each row in the result to another type.

See try_map for a fallible version of this method.

The query_as method will construct a mapped query using a FromRow implementation.

pub fn try_map<G, P>( self, g: G, ) -> Map<'q, DB, impl FnMut(<DB as Database>::Row) + Send, A>

where G: FnMut(O) -> Result<P, Error> + Send, P: Unpin,

Map each row in the result to another type.

The query_as method will construct a mapped query using a FromRow implementation.

pub fn fetch<'e, 'c, E>( self, executor: E, ) -> Pin<Box<dyn Stream<Item = Result<O, Error>> + Send + 'e>>

where 'c: 'e, 'q: 'e, E: 'e + Executor<'c, Database = DB>, DB: 'e, F: 'e, O: 'e,

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

pub fn fetch_many<'e, 'c, E>( self, executor: E, ) -> Pin<Box<dyn Stream<Item = Result<Either<<DB as Database>::QueryResult, O>, Error>> + Send + 'e>>

where 'c: 'e, 'q: 'e, E: 'e + Executor<'c, Database = DB>, DB: 'e, F: 'e, O: 'e,

👎Deprecated: Only the SQLite driver supports multiple statements in one prepared statement and that behavior is deprecated. Use sqlx::raw_sql() instead.

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

pub async fn fetch_all<'e, 'c, E>(self, executor: E) -> Result<Vec<O>, Error>

where 'c: 'e, 'q: 'e, E: 'e + Executor<'c, Database = DB>, DB: 'e, F: 'e, O: 'e,

Execute the query and return all the resulting rows collected into a Vec.

Note: beware result set size.

This will attempt to collect the full result set of the query into memory.

To avoid exhausting available memory, ensure the result set has a known upper bound, e.g. using LIMIT.

pub async fn fetch_one<'e, 'c, E>(self, executor: E) -> Result<O, Error>

where 'c: 'e, 'q: 'e, E: 'e + Executor<'c, Database = DB>, DB: 'e, F: 'e, O: 'e,

Execute the query, returning the first row or [Error::RowNotFound] otherwise.

Note: for best performance, ensure the query returns at most one row.

Depending on the driver implementation, if your query can return more than one row, it may lead to wasted CPU time and bandwidth on the database server.

Even when the driver implementation takes this into account, ensuring the query returns at most one row can result in a more optimal query plan.

If your query has a WHERE clause filtering a unique column by a single value, you’re good.

Otherwise, you might want to add LIMIT 1 to your query.

pub async fn fetch_optional<'e, 'c, E>( self, executor: E, ) -> Result<Option<O>, Error>

where 'c: 'e, 'q: 'e, E: 'e + Executor<'c, Database = DB>, DB: 'e, F: 'e, O: 'e,

Execute the query, returning the first row or None otherwise.

Note: for best performance, ensure the query returns at most one row.

Depending on the driver implementation, if your query can return more than one row, it may lead to wasted CPU time and bandwidth on the database server.

Even when the driver implementation takes this into account, ensuring the query returns at most one row can result in a more optimal query plan.

If your query has a WHERE clause filtering a unique column by a single value, you’re good.

Otherwise, you might want to add LIMIT 1 to your query.

Trait Implementations

impl<'q, DB, F, A> Execute<'q, DB> for Map<'q, DB, F, A>

where F: Send, A: Send + IntoArguments<'q, DB>, DB: Database,

fn sql(&self) -> &'q str

Gets the SQL that will be executed.

fn statement(&self) -> Option<&<DB as Database>::Statement<'q>>

Gets the previously cached statement, if available.

fn take_arguments( &mut self, ) -> Result<Option<<DB as Database>::Arguments<'q>>, Box<dyn Error + Sync + Send>>

Returns the arguments to be bound against the query string.

fn persistent(&self) -> bool

Returns true if the statement should be cached.