Struct Response

pub struct Response { /* private fields */ }

The response type of a Surreal::query request

Implementations

impl Response

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

where R: DeserializeOwned,

Takes and returns records returned from the database

A query that only returns one result can be deserialized into an Option<T>, while those that return multiple results should be deserialized into a Vec<T>.

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")
    .await?;

// Get the first (and only) user from the first query
let user: Option<User> = response.take(0)?;

// Get all users from the second query
let users: Vec<User> = response.take(1)?;

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

// Get all users' addresses
let addresses: Vec<String> = response.take((3, "address"))?;

// You can continue taking more fields on the same response
// object when extracting individual fields
let mut response = db.query("SELECT * FROM user").await?;

// Since the query we want to access is at index 0, we can use
// a shortcut instead of `response.take((0, "field"))`
let ids: Vec<String> = response.take("id")?;
let names: Vec<String> = response.take("name")?;
let addresses: Vec<String> = response.take("address")?;

The indices are stable. Taking one index doesn’t affect the numbering of the other indices, so you can take them in any order you see fit.

pub fn stream<R>( &mut self, index: impl QueryStream<R>, ) -> Result<QueryStream<R>>

Takes and streams records returned from a LIVE SELECT query

This is the counterpart to Response::take used to stream the results of a live query.

Examples

use serde::Deserialize;
use surrealdb::Notification;
use surrealdb::Value;

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

let mut response = db
    // Stream all changes to the user table
    .query("LIVE SELECT * FROM user")
    .await?;

// Stream the result of the live query at the given index
// while deserialising into the User type
let mut stream = response.stream::<Notification<User>>(0)?;

// Stream raw values instead
let mut stream = response.stream::<Value>(0)?;

// Combine and stream all `LIVE SELECT` statements in this query
let mut stream = response.stream::<Value>(())?;

Consume the stream the same way you would any other type that implements futures::Stream.

pub fn take_errors(&mut self) -> HashMap<usize, 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);

Trait Implementations

impl Debug for Response

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

Formats the value using the given formatter.