Struct Row 

pub struct Row { /* private fields */ }

A row of data from a query.

Data can be accessed either by copying through get or try_get methods, or moving by value using the IntoIterator implementation.

// by-reference
let row = client
    .query("SELECT @P1 AS col1", &[&"test"])
    .await?
    .into_row()
    .await?
    .unwrap();

assert_eq!(Some("test"), row.get("col1"));

// ...or by-value
let row = client
    .query("SELECT @P1 AS col1", &[&"test"])
    .await?
    .into_row()
    .await?
    .unwrap();

for val in row.into_iter() {
    assert_eq!(
        Some(String::from("test")),
        String::from_sql_owned(val)?
    )
}

Implementations

impl Row

pub fn columns(&self) -> &[Column]

Columns defining the row data. Columns listed here are in the same order as the resulting data.

Example

let row = client
    .query("SELECT 1 AS foo, 2 AS bar", &[])
    .await?
    .into_row()
    .await?
    .unwrap();

assert_eq!("foo", row.columns()[0].name());
assert_eq!("bar", row.columns()[1].name());

pub fn cells(&self) -> impl Iterator<Item = (&Column, &ColumnData<'static>)>

Return an iterator over row column-value pairs.

pub fn result_index(&self) -> usize

The result set number, starting from zero and increasing if the stream has results from more than one query.

pub fn len(&self) -> usize

Returns the number of columns in the row.

Example

let row = client
    .query("SELECT 1, 2", &[])
    .await?
    .into_row()
    .await?
    .unwrap();

assert_eq!(2, row.len());

pub fn get<'a, R, I>(&'a self, idx: I) -> Option<R>

where R: FromSql<'a>, I: QueryIdx,

Retrieve a column value for a given column index, which can either be the zero-indexed position or the name of the column.

Example

let row = client
    .query("SELECT @P1 AS col1", &[&1i32])
    .await?
    .into_row()
    .await?
    .unwrap();

assert_eq!(Some(1i32), row.get(0));
assert_eq!(Some(1i32), row.get("col1"));

Panics

• The requested type conversion (SQL->Rust) is not possible.
• The given index is out of bounds (column does not exist).

Use try_get for a non-panicking version of the function.

pub fn try_get<'a, R, I>(&'a self, idx: I) -> Result<Option<R>>

where R: FromSql<'a>, I: QueryIdx,

Retrieve a column’s value for a given column index.

pub fn get_column_data<I>(&self, idx: I) -> Result<&ColumnData<'static>>

where I: QueryIdx,

Retrieve a column’s data for a given column index.

pub fn into_token_row(self) -> TokenRow<'static>

Consumes the row, returning the underlying TokenRow holding the raw column data as received from the server.

This is useful when direct access to the raw ColumnData values is needed instead of converting them through get or try_get.

Trait Implementations

impl Debug for Row

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Row

Available on crate feature serde only.

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl IntoIterator for Row

type Item = ColumnData<'static>

The type of the elements being iterated over.

type IntoIter = IntoIter<<Row as IntoIterator>::Item>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl Serialize for Row

Available on crate feature serde only.

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.