Struct rusqlite::Rows

pub struct Rows<'stmt> { /* fields omitted */ }

An handle for the resulting rows of a query.

Methods

impl<'stmt> Rows<'stmt>

pub fn column_names(&self) -> Option<Vec<&str>>

Get all the column names.

pub fn column_count(&self) -> Option<usize>

Return the number of columns.

pub fn column_name(&self, col: usize) -> Option<Result<&str>>

Return the name of the column.

pub fn column_index(&self, name: &str) -> Option<Result<usize>>

Return the index of the column.

pub fn columns(&self) -> Option<Vec<Column>>

Returns a slice describing the columns of the Rows.

impl<'stmt> Rows<'stmt>

pub fn next(&mut self) -> Result<Option<&Row<'stmt>>>

Attempt to get the next row from the query. Returns Ok(Some(Row)) if there is another row, Err(...) if there was an error getting the next row, and Ok(None) if all rows have been retrieved.

Note

This interface is not compatible with Rust's Iterator trait, because the lifetime of the returned row is tied to the lifetime of self. This is a fallible "streaming iterator". For a more natural interface, consider using query_map or query_and_then instead, which return types that implement Iterator.

pub fn map<F, B>(self, f: F) -> Map<'stmt, F> where
    F: FnMut(&Row) -> Result<B>, 

pub fn mapped<F, B>(self, f: F) -> MappedRows<'stmt, F> where
    F: FnMut(&Row) -> Result<B>, 

Map over this Rows, converting it to a MappedRows, which implements Iterator.

pub fn and_then<F, T, E>(self, f: F) -> AndThenRows<'stmt, F> where
    F: FnMut(&Row) -> Result<T, E>, 

Map over this Rows with a fallible function, converting it to a AndThenRows, which implements Iterator (instead of FallibleStreamingIterator).

Trait Implementations

impl<'_> Drop for Rows<'_>

fn drop(&mut self)

Executes the destructor for this type.

impl<'stmt> FallibleStreamingIterator for Rows<'stmt>

type Error = Error

The error type of iteration.

type Item = Row<'stmt>

The type being iterated over.

fn advance(&mut self) -> Result<()>

Advances the iterator to the next position.

fn get(&self) -> Option<&Row<'stmt>>

Returns the current element.

fn next(&mut self) -> Result<Option<&Self::Item>, Self::Error>

Advances the iterator, returning the next element.

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

Returns bounds on the number of remaining elements in the iterator.

fn all<F>(&mut self, f: F) -> Result<bool, Self::Error> where
    F: FnMut(&Self::Item) -> bool, 

Determines if all elements of the iterator satisfy a predicate.

fn any<F>(&mut self, f: F) -> Result<bool, Self::Error> where
    F: FnMut(&Self::Item) -> bool, 

Determines if any elements of the iterator satisfy a predicate.

fn by_ref(&mut self) -> &mut Self

Borrows an iterator, rather than consuming it.

fn count(self) -> Result<usize, Self::Error>

Returns the number of remaining elements in the iterator.

fn filter<F>(self, f: F) -> Filter<Self, F> where
    F: FnMut(&Self::Item) -> bool, 

Returns an iterator which filters elements by a predicate.

fn find<F>(&mut self, f: F) -> Result<Option<&Self::Item>, Self::Error> where
    F: FnMut(&Self::Item) -> bool, 

Returns the first element of the iterator which satisfies a predicate.

fn for_each<F>(self, f: F) -> Result<(), Self::Error> where
    F: FnMut(&Self::Item), 

Calls a closure on each element of an iterator.

fn fuse(self) -> Fuse<Self>

Returns an iterator which is well-behaved at the beginning and end of iteration.

fn map<F, B>(self, f: F) -> Map<Self, F, B> where
    F: FnMut(&Self::Item) -> B, 

Returns an iterator which applies a transform to elements.

fn map_ref<F, B>(self, f: F) -> MapRef<Self, F> where
    B: ?Sized,
    F: Fn(&Self::Item) -> &B, 

Returns an iterator which applies a transform to elements.

fn map_err<F, B>(self, f: F) -> MapErr<Self, F> where
    F: Fn(Self::Error) -> B, 

Returns an iterator that applies a transform to errors.

fn nth(&mut self, n: usize) -> Result<Option<&Self::Item>, Self::Error>

Returns the nth element of the iterator.

fn position<F>(&mut self, f: F) -> Result<Option<usize>, Self::Error> where
    F: FnMut(&Self::Item) -> bool, 

Returns the position of the first element matching a predicate.

fn skip(self, n: usize) -> Skip<Self>

Returns an iterator which skips the first n elements.

fn skip_while<F>(self, f: F) -> SkipWhile<Self, F> where
    F: FnMut(&Self::Item) -> bool, 

Returns an iterator which skips the first sequence of elements matching a predicate.

fn take(self, n: usize) -> Take<Self>

Returns an iterator which only returns the first n elements.

fn take_while<F>(self, f: F) -> TakeWhile<Self, F> where
    F: FnMut(&Self::Item) -> bool, 

Returns an iterator which only returns the first sequence of elements matching a predicate.