pub struct Rows<'stmt> { /* private fields */ }
Expand description
An handle for the resulting rows of a query.
Implementations
sourceimpl<'stmt> Rows<'stmt>
impl<'stmt> Rows<'stmt>
sourcepub fn next(&mut self) -> Result<Option<&Row<'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
.
sourcepub fn map<F, B>(self, f: F) -> Map<'stmt, F>where
F: FnMut(&Row<'_>) -> Result<B>,
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()
}
sourcepub fn mapped<F, B>(self, f: F) -> MappedRows<'stmt, F>ⓘNotable traits for MappedRows<'_, F>impl<T, F> Iterator for MappedRows<'_, F>where
F: FnMut(&Row<'_>) -> Result<T>, type Item = Result<T>;
where
F: FnMut(&Row<'_>) -> Result<B>,
pub fn mapped<F, B>(self, f: F) -> MappedRows<'stmt, F>ⓘNotable traits for MappedRows<'_, F>impl<T, F> Iterator for MappedRows<'_, F>where
F: FnMut(&Row<'_>) -> Result<T>, type Item = Result<T>;
where
F: FnMut(&Row<'_>) -> Result<B>,
F: FnMut(&Row<'_>) -> Result<T>, type Item = Result<T>;
Map over this Rows
, converting it to a MappedRows
, which
implements Iterator
.
sourcepub fn and_then<F, T, E>(self, f: F) -> AndThenRows<'stmt, F>ⓘNotable traits for AndThenRows<'_, F>impl<T, E, F> Iterator for AndThenRows<'_, F>where
E: From<Error>,
F: FnMut(&Row<'_>) -> Result<T, E>, type Item = Result<T, E>;
where
F: FnMut(&Row<'_>) -> Result<T, E>,
pub fn and_then<F, T, E>(self, f: F) -> AndThenRows<'stmt, F>ⓘNotable traits for AndThenRows<'_, F>impl<T, E, F> Iterator for AndThenRows<'_, F>where
E: From<Error>,
F: FnMut(&Row<'_>) -> Result<T, E>, type Item = Result<T, E>;
where
F: FnMut(&Row<'_>) -> Result<T, E>,
E: From<Error>,
F: FnMut(&Row<'_>) -> Result<T, E>, type Item = Result<T, E>;
Map over this Rows
with a fallible function, converting it to a
AndThenRows
, which implements Iterator
(instead of
FallibleStreamingIterator
).
Trait Implementations
sourceimpl<'stmt> FallibleStreamingIterator for Rows<'stmt>
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 untilnext
is called again orStatement
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(())
}
sourcefn next(&mut self) -> Result<Option<&Self::Item>, Self::Error>
fn next(&mut self) -> Result<Option<&Self::Item>, Self::Error>
sourcefn size_hint(&self) -> (usize, Option<usize>)
fn size_hint(&self) -> (usize, Option<usize>)
sourcefn all<F>(&mut self, f: F) -> Result<bool, Self::Error>where
F: FnMut(&Self::Item) -> bool,
fn all<F>(&mut self, f: F) -> Result<bool, Self::Error>where
F: FnMut(&Self::Item) -> bool,
sourcefn any<F>(&mut self, f: F) -> Result<bool, Self::Error>where
F: FnMut(&Self::Item) -> bool,
fn any<F>(&mut self, f: F) -> Result<bool, Self::Error>where
F: FnMut(&Self::Item) -> bool,
sourcefn count(self) -> Result<usize, Self::Error>
fn count(self) -> Result<usize, Self::Error>
sourcefn filter<F>(self, f: F) -> Filter<Self, F>where
F: FnMut(&Self::Item) -> bool,
fn filter<F>(self, f: F) -> Filter<Self, F>where
F: FnMut(&Self::Item) -> bool,
sourcefn find<F>(&mut self, f: F) -> Result<Option<&Self::Item>, Self::Error>where
F: FnMut(&Self::Item) -> bool,
fn find<F>(&mut self, f: F) -> Result<Option<&Self::Item>, Self::Error>where
F: FnMut(&Self::Item) -> bool,
sourcefn for_each<F>(self, f: F) -> Result<(), Self::Error>where
F: FnMut(&Self::Item),
fn for_each<F>(self, f: F) -> Result<(), Self::Error>where
F: FnMut(&Self::Item),
sourcefn fuse(self) -> Fuse<Self>
fn fuse(self) -> Fuse<Self>
sourcefn map<F, B>(self, f: F) -> Map<Self, F, B>where
F: FnMut(&Self::Item) -> B,
fn map<F, B>(self, f: F) -> Map<Self, F, B>where
F: FnMut(&Self::Item) -> B,
sourcefn map_ref<F, B>(self, f: F) -> MapRef<Self, F>where
F: Fn(&Self::Item) -> &B,
B: ?Sized,
fn map_ref<F, B>(self, f: F) -> MapRef<Self, F>where
F: Fn(&Self::Item) -> &B,
B: ?Sized,
sourcefn map_err<F, B>(self, f: F) -> MapErr<Self, F>where
F: Fn(Self::Error) -> B,
fn map_err<F, B>(self, f: F) -> MapErr<Self, F>where
F: Fn(Self::Error) -> B,
sourcefn nth(&mut self, n: usize) -> Result<Option<&Self::Item>, Self::Error>
fn nth(&mut self, n: usize) -> Result<Option<&Self::Item>, Self::Error>
nth
element of the iterator.