Struct scylla::transport::query_result::QueryResult

#[non_exhaustive]
pub struct QueryResult {
    pub rows: Option<Vec<Row>>,
    pub warnings: Vec<String>,
    pub tracing_id: Option<Uuid>,
    pub paging_state: Option<Bytes>,
    pub col_specs: Vec<ColumnSpec>,
    pub serialized_size: usize,
}

Result of a single query
Contains all rows returned by the database and some more information

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

rows: Option<Vec<Row>>

Rows returned by the database.
Queries like SELECT will have Some(Vec), while queries like INSERT will have None.
Can contain an empty Vec.

warnings: Vec<String>

Warnings returned by the database

tracing_id: Option<Uuid>

CQL Tracing uuid - can only be Some if tracing is enabled for this query

paging_state: Option<Bytes>

Paging state returned from the server

col_specs: Vec<ColumnSpec>

Column specification returned from the server

serialized_size: usize

The original size of the serialized rows in request

Implementations

impl QueryResult

pub fn rows_num(&self) -> Result<usize, RowsExpectedError>

Returns the number of received rows.
Fails when the query isn’t of a type that could return rows, same as rows().

pub fn rows(self) -> Result<Vec<Row>, RowsExpectedError>

Returns the received rows when present.
If QueryResult.rows is None, which means that this query is not supposed to return rows (e.g INSERT), returns an error.
Can return an empty Vec.

pub fn rows_typed<RowT: FromRow>( self ) -> Result<TypedRowIter<RowT>, RowsExpectedError>

Returns the received rows parsed as the given type.
Equal to rows()?.into_typed().
Fails when the query isn’t of a type that could return rows, same as rows().

pub fn result_not_rows(&self) -> Result<(), RowsNotExpectedError>

Returns Ok for a result of a query that shouldn’t contain any rows.
Will return Ok for INSERT result, but a SELECT result, even an empty one, will cause an error.
Opposite of rows().

pub fn rows_or_empty(self) -> Vec<Row>

Returns rows when QueryResult.rows is Some, otherwise an empty Vec.
Equal to rows().unwrap_or_default().

pub fn rows_typed_or_empty<RowT: FromRow>(self) -> TypedRowIter<RowT>

Returns rows parsed as the given type.
When QueryResult.rows is None, returns 0 rows.
Equal to rows_or_empty().into_typed::<RowT>().

pub fn first_row(self) -> Result<Row, FirstRowError>

Returns first row from the received rows.
When the first row is not available, returns an error.

pub fn first_row_typed<RowT: FromRow>(self) -> Result<RowT, FirstRowTypedError>

Returns first row from the received rows parsed as the given type.
When the first row is not available, returns an error.

pub fn maybe_first_row(self) -> Result<Option<Row>, RowsExpectedError>

Returns Option<RowT> containing the first of a result.
Fails when the query isn’t of a type that could return rows, same as rows().

pub fn maybe_first_row_typed<RowT: FromRow>( self ) -> Result<Option<RowT>, MaybeFirstRowTypedError>

Returns Option<RowT> containing the first of a result.
Fails when the query isn’t of a type that could return rows, same as rows().

pub fn single_row(self) -> Result<Row, SingleRowError>

Returns the only received row.
Fails if the result is anything else than a single row.\

pub fn single_row_typed<RowT: FromRow>( self ) -> Result<RowT, SingleRowTypedError>

Returns the only received row parsed as the given type.
Fails if the result is anything else than a single row.\

pub fn get_column_spec<'a>( &'a self, name: &str ) -> Option<(usize, &'a ColumnSpec)>

Returns a column specification for a column with given name, or None if not found

Trait Implementations

impl Debug for QueryResult

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

Formats the value using the given formatter.

impl Default for QueryResult

fn default() -> QueryResult

Returns the “default value” for a type.