Struct rusqlite::Rows

source ·
pub struct Rows<'stmt> { /* private fields */ }
Expand description

An handle for the resulting rows of a query.

Implementations§

source§

impl<'stmt> Rows<'stmt>

source

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.

source

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

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

use fallible_iterator::FallibleIterator;
fn query(stmt: &mut Statement) -> Result<Vec<i64>> {
    let rows = stmt.query([])?;
    rows.map(|r| r.get(0)).collect()
}
source

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.

source

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).

source

pub fn as_ref(&self) -> Option<&Statement<'stmt>>

Give access to the underlying statement

Trait Implementations§

source§

impl Drop for Rows<'_>

source§

fn drop(&mut self)

Executes the destructor for this type. Read more
source§

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

FallibleStreamingIterator differs from the standard library’s Iterator in two ways:

  • each call to next (sqlite3_step) can fail.
  • returned Row is valid until next is called again or Statement is reset or finalized.

While these iterators cannot be used with Rust for loops, while let loops offer a similar level of ergonomics:

fn query(stmt: &mut Statement) -> Result<()> {
    let mut rows = stmt.query([])?;
    while let Some(row) = rows.next()? {
        // scan columns value
    }
    Ok(())
}
§

type Error = Error

The error type of iteration.
§

type Item = Row<'stmt>

The type being iterated over.
source§

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

Advances the iterator to the next position. Read more
source§

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

Returns the current element. Read more
source§

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

Advances the iterator, returning the next element. Read more
source§

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

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

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

Determines if all elements of the iterator satisfy a predicate.
source§

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

Determines if any elements of the iterator satisfy a predicate.
source§

fn by_ref(&mut self) -> &mut Self
where Self: Sized,

Borrows an iterator, rather than consuming it. Read more
source§

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

Returns the number of remaining elements in the iterator.
source§

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

Returns an iterator which filters elements by a predicate.
source§

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

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

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

Calls a closure on each element of an iterator.
source§

fn fuse(self) -> Fuse<Self>
where Self: Sized,

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

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

Returns an iterator which applies a transform to elements.
source§

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

Returns an iterator which applies a transform to elements. Read more
source§

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

Returns an iterator that applies a transform to errors.
source§

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

Returns the nth element of the iterator.
source§

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

Returns the position of the first element matching a predicate.
source§

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

Returns an iterator which skips the first n elements.
source§

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

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

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

Returns an iterator which only returns the first n elements.
source§

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

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

Auto Trait Implementations§

§

impl<'stmt> Freeze for Rows<'stmt>

§

impl<'stmt> !RefUnwindSafe for Rows<'stmt>

§

impl<'stmt> !Send for Rows<'stmt>

§

impl<'stmt> !Sync for Rows<'stmt>

§

impl<'stmt> Unpin for Rows<'stmt>

§

impl<'stmt> !UnwindSafe for Rows<'stmt>

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.