Struct rusqlite::Rows [−][src]
#[must_use = "Rows is lazy and will do nothing unless consumed"]pub struct Rows<'stmt> { /* fields omitted */ }
An handle for the resulting rows of a query.
Implementations
impl<'stmt> Rows<'stmt>
[src]
pub fn column_names(&self) -> Option<Vec<&str>>
[src]
Get all the column names.
pub fn column_count(&self) -> Option<usize>
[src]
Return the number of columns.
pub fn column_name(&self, col: usize) -> Option<Result<&str>>
[src]
Return the name of the column.
pub fn column_index(&self, name: &str) -> Option<Result<usize>>
[src]
Return the index of the column.
pub fn columns(&self) -> Option<Vec<Column<'_>>>
[src]
Returns a slice describing the columns of the Rows.
impl<'stmt> Rows<'stmt>
[src]
pub fn next(&mut self) -> Result<Option<&Row<'stmt>>>
[src]
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>,
[src]
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() }
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>,
[src]
Notable traits for MappedRows<'_, F>
impl<T, F> Iterator for MappedRows<'_, F> where
F: FnMut(&Row<'_>) -> Result<T>, type Item = Result<T>;
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>ⓘ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>,
[src]
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>;
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<'_>
[src]
impl<'stmt> FallibleStreamingIterator for Rows<'stmt>
[src]
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(()) }
type Error = Error
The error type of iteration.
type Item = Row<'stmt>
The type being iterated over.
fn advance(&mut self) -> Result<()>
[src]
fn get(&self) -> Option<&Row<'stmt>>
[src]
pub fn next(&mut self) -> Result<Option<&Self::Item>, Self::Error>
[src]
pub fn size_hint(&self) -> (usize, Option<usize>)
[src]
pub fn all<F>(&mut self, f: F) -> Result<bool, Self::Error> where
F: FnMut(&Self::Item) -> bool,
[src]
F: FnMut(&Self::Item) -> bool,
pub fn any<F>(&mut self, f: F) -> Result<bool, Self::Error> where
F: FnMut(&Self::Item) -> bool,
[src]
F: FnMut(&Self::Item) -> bool,
pub fn by_ref(&mut self) -> &mut Self
[src]
pub fn count(self) -> Result<usize, Self::Error>
[src]
pub fn filter<F>(self, f: F) -> Filter<Self, F> where
F: FnMut(&Self::Item) -> bool,
[src]
F: FnMut(&Self::Item) -> bool,
pub fn find<F>(&mut self, f: F) -> Result<Option<&Self::Item>, Self::Error> where
F: FnMut(&Self::Item) -> bool,
[src]
F: FnMut(&Self::Item) -> bool,
pub fn for_each<F>(self, f: F) -> Result<(), Self::Error> where
F: FnMut(&Self::Item),
[src]
F: FnMut(&Self::Item),
pub fn fuse(self) -> Fuse<Self>
[src]
pub fn map<F, B>(self, f: F) -> Map<Self, F, B> where
F: FnMut(&Self::Item) -> B,
[src]
F: FnMut(&Self::Item) -> B,
pub fn map_ref<F, B>(self, f: F) -> MapRef<Self, F> where
F: Fn(&Self::Item) -> &B,
B: ?Sized,
[src]
F: Fn(&Self::Item) -> &B,
B: ?Sized,
pub fn map_err<F, B>(self, f: F) -> MapErr<Self, F> where
F: Fn(Self::Error) -> B,
[src]
F: Fn(Self::Error) -> B,
pub fn nth(&mut self, n: usize) -> Result<Option<&Self::Item>, Self::Error>
[src]
pub fn position<F>(&mut self, f: F) -> Result<Option<usize>, Self::Error> where
F: FnMut(&Self::Item) -> bool,
[src]
F: FnMut(&Self::Item) -> bool,
pub fn skip(self, n: usize) -> Skip<Self>
[src]
pub fn skip_while<F>(self, f: F) -> SkipWhile<Self, F> where
F: FnMut(&Self::Item) -> bool,
[src]
F: FnMut(&Self::Item) -> bool,
pub fn take(self, n: usize) -> Take<Self>
[src]
pub fn take_while<F>(self, f: F) -> TakeWhile<Self, F> where
F: FnMut(&Self::Item) -> bool,
[src]
F: FnMut(&Self::Item) -> bool,
Auto Trait Implementations
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
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,