Struct WithStats

pub struct WithStats<T>(pub T);

Responses returned with statistics

Tuple Fields

0: T

Implementations

impl WithStats<Response>

pub fn take<R>( &mut self, index: impl QueryResult<R>, ) -> Option<(Stats, Result<R>)>

where R: DeserializeOwned,

Takes and returns records returned from the database

Similar to Response::take but this method returns None when you try taking an index that doesn’t correspond to a query statement.

Examples

use serde::Deserialize;

#[derive(Debug, Deserialize)]
struct User {
    id: String,
    balance: String
}

let mut response = db
    // Get `john`'s details
    .query("SELECT * FROM user:john")
    // List all users whose first name is John
    .query("SELECT * FROM user WHERE name.first = 'John'")
    // Get John's address
    .query("SELECT address FROM user:john")
    // Get all users' addresses
    .query("SELECT address FROM user")
    // Return stats along with query results
    .with_stats()
    .await?;

// Get the first (and only) user from the first query
if let Some((stats, result)) = response.take(0) {
    let execution_time = stats.execution_time;
    let user: Option<User> = result?;
}

// Get all users from the second query
if let Some((stats, result)) = response.take(1) {
    let execution_time = stats.execution_time;
    let users: Vec<User> = result?;
}

// Retrieve John's address without making a special struct for it
if let Some((stats, result)) = response.take((2, "address")) {
    let execution_time = stats.execution_time;
    let address: Option<String> = result?;
}

// Get all users' addresses
if let Some((stats, result)) = response.take((3, "address")) {
    let execution_time = stats.execution_time;
    let addresses: Vec<String> = result?;
}

pub fn take_errors(&mut self) -> HashMap<usize, (Stats, Error)>

Take all errors from the query response

The errors are keyed by the corresponding index of the statement that failed. Afterwards the response is left with only statements that did not produce any errors.

Examples

let errors = response.take_errors();

pub fn check(self) -> Result<Self>

Check query response for errors and return the first error, if any, or the response

Examples

response.check()?;

pub fn num_statements(&self) -> usize

Returns the number of statements in the query

Examples

let response = db.query("SELECT * FROM user:john; SELECT * FROM user;").await?;

assert_eq!(response.num_statements(), 2);

pub fn into_inner(self) -> Response

Returns the unwrapped response

Trait Implementations

impl<T: Debug> Debug for WithStats<T>

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

Formats the value using the given formatter.

impl<'r, Client> IntoFuture for WithStats<Query<'r, Client>>

where Client: Connection,

type Output = Result<WithStats<Response>, Error>

The output that the future will produce on completion.

type IntoFuture = Pin<Box<dyn Future<Output = <WithStats<Query<'r, Client>> as IntoFuture>::Output> + Sync + Send + 'r>>

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.