Struct tiberius::QueryResult

pub struct QueryResult<'a> { /* fields omitted */ }

A set of Streams of Rows resulting from a SELECT query. The QueryResult needs to be polled empty before sending another query to the Client, failing to do so causes a flush before the next query, slowing it down in an undeterministic way.

If executing multiple queries, the resulting streams will be split. Before polling the next results, a call to next_resultset with a response of true is needed. When the next_resultset returns false the results should not be polled anymore.

Example

let mut stream = client
    .query(
        "SELECT @P1 AS first; SELECT @P2 AS second",
        &[&1i32, &2i32],
    )
    .await?;

// Result of `SELECT 1`. Taking the `Stream` by reference, allowing us to
// poll it later again. We fetch the value with column index.
let first_result: Vec<Option<i32>> = stream
    .by_ref()
    .map_ok(|x| x.get::<i32, _>(0))
    .try_collect()
    .await?;

assert_eq!(Some(1), first_result[0]);

// Allows us to poll more results.
assert!(stream.next_resultset());

// Result of `SELECT 2`, this time fetching with the column name.
let second_result: Vec<Option<i32>> = stream
    .by_ref()
    .map_ok(|x| x.get::<i32, _>("second"))
    .try_collect()
    .await?;

assert_eq!(Some(2), second_result[0]);

// No more results left. We should not poll again.
assert!(!stream.next_resultset());

Implementations

impl<'a> QueryResult<'a>

pub fn columns(&'a self) -> Option<&[Column]>

Names of the columns of the current resultset. Order is the same as the order of columns in the rows. Needs to be called separately for every result set. None if query could not result anything.

Example

let mut result_set = client
    .query(
        "SELECT 1 AS foo; SELECT 2 AS bar",
        &[&1i32, &2i32, &3i32],
    )
    .await?;

let columns = result_set.columns().unwrap();
assert_eq!("foo", columns[0].name());

result_set.next_resultset();

let columns = result_set.columns().unwrap();
assert_eq!("bar", columns[0].name());

pub fn next_resultset(&mut self) -> bool

Returns true if stream has more result sets available. Must be called before polling again to get results from the next query.

pub async fn into_results(__arg0: Self) -> Result<Vec<Vec<Row>>>

Collects results from all queries in the stream into memory in the order of querying.

pub async fn into_first_result(self) -> Result<Vec<Row>>

Collects the output of the first query, dropping any further results.

pub async fn into_row(self) -> Result<Option<Row>>

Collects the first row from the output of the first query, dropping any further rows.

Trait Implementations

impl<'a> Debug for QueryResult<'a>

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

Formats the value using the given formatter.

impl<'a> Stream for QueryResult<'a>

type Item = Result<Row>

Values yielded by the stream.

fn poll_next(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.