pub struct Rows<'stmt> { /* private fields */ }
Expand description
An handle for the resulting rows of a query.
Implementations§
source§impl<'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>
pub fn map<F, B>(self, f: F) -> Map<'stmt, F>
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> ⓘ
pub fn mapped<F, B>(self, f: F) -> MappedRows<'stmt, F> ⓘ
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> ⓘ
pub fn and_then<F, T, E>(self, f: F) -> AndThenRows<'stmt, F> ⓘ
Map over this Rows
with a fallible function, converting it to a
AndThenRows
, which implements Iterator
(instead of
FallibleStreamingIterator
).
Trait Implementations§
source§impl<'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(())
}
source§fn next(&mut self) -> Result<Option<&Self::Item>, Self::Error>
fn next(&mut self) -> Result<Option<&Self::Item>, Self::Error>
source§fn size_hint(&self) -> (usize, Option<usize>)
fn size_hint(&self) -> (usize, Option<usize>)
source§fn all<F>(&mut self, f: F) -> Result<bool, Self::Error>
fn all<F>(&mut self, f: F) -> Result<bool, Self::Error>
source§fn any<F>(&mut self, f: F) -> Result<bool, Self::Error>
fn any<F>(&mut self, f: F) -> Result<bool, Self::Error>
source§fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
source§fn count(self) -> Result<usize, Self::Error>where
Self: Sized,
fn count(self) -> Result<usize, Self::Error>where
Self: Sized,
source§fn filter<F>(self, f: F) -> Filter<Self, F>
fn filter<F>(self, f: F) -> Filter<Self, F>
source§fn find<F>(&mut self, f: F) -> Result<Option<&Self::Item>, Self::Error>
fn find<F>(&mut self, f: F) -> Result<Option<&Self::Item>, Self::Error>
source§fn for_each<F>(self, f: F) -> Result<(), Self::Error>
fn for_each<F>(self, f: F) -> Result<(), Self::Error>
source§fn fuse(self) -> Fuse<Self>where
Self: Sized,
fn fuse(self) -> Fuse<Self>where
Self: Sized,
source§fn map<F, B>(self, f: F) -> Map<Self, F, B>
fn map<F, B>(self, f: F) -> Map<Self, F, B>
source§fn map_ref<F, B>(self, f: F) -> MapRef<Self, F>
fn map_ref<F, B>(self, f: F) -> MapRef<Self, F>
source§fn map_err<F, B>(self, f: F) -> MapErr<Self, F>
fn map_err<F, B>(self, f: F) -> MapErr<Self, F>
source§fn 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.source§fn position<F>(&mut self, f: F) -> Result<Option<usize>, Self::Error>
fn position<F>(&mut self, f: F) -> Result<Option<usize>, Self::Error>
source§fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
n
elements.