| use fallible_iterator::FallibleIterator; |
| use fallible_streaming_iterator::FallibleStreamingIterator; |
| use std::convert; |
| |
| use super::{Error, Result, Statement}; |
| use crate::types::{FromSql, FromSqlError, ValueRef}; |
| |
| /// An handle for the resulting rows of a query. |
| #[must_use = "Rows is lazy and will do nothing unless consumed"] |
| pub struct Rows<'stmt> { |
| pub(crate) stmt: Option<&'stmt Statement<'stmt>>, |
| row: Option<Row<'stmt>>, |
| } |
| |
| impl<'stmt> Rows<'stmt> { |
| fn reset(&mut self) { |
| if let Some(stmt) = self.stmt.take() { |
| stmt.reset(); |
| } |
| } |
| |
| /// 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`. |
| #[allow(clippy::should_implement_trait)] // cannot implement Iterator |
| pub fn next(&mut self) -> Result<Option<&Row<'stmt>>> { |
| self.advance()?; |
| Ok((*self).get()) |
| } |
| |
| /// Map over this `Rows`, converting it to a [`Map`], which |
| /// implements `FallibleIterator`. |
| /// ```rust,no_run |
| /// use fallible_iterator::FallibleIterator; |
| /// # use rusqlite::{Result, Statement, NO_PARAMS}; |
| /// fn query(stmt: &mut Statement) -> Result<Vec<i64>> { |
| /// let rows = stmt.query(NO_PARAMS)?; |
| /// rows.map(|r| r.get(0)).collect() |
| /// } |
| /// ``` |
| // FIXME Hide FallibleStreamingIterator::map |
| pub fn map<F, B>(self, f: F) -> Map<'stmt, F> |
| where |
| F: FnMut(&Row<'_>) -> Result<B>, |
| { |
| Map { rows: self, f } |
| } |
| |
| /// Map over this `Rows`, converting it to a [`MappedRows`], which |
| /// implements `Iterator`. |
| pub fn mapped<F, B>(self, f: F) -> MappedRows<'stmt, F> |
| where |
| F: FnMut(&Row<'_>) -> Result<B>, |
| { |
| MappedRows { rows: self, map: f } |
| } |
| |
| /// Map over this `Rows` with a fallible function, converting it to a |
| /// [`AndThenRows`], which implements `Iterator` (instead of |
| /// `FallibleStreamingIterator`). |
| pub fn and_then<F, T, E>(self, f: F) -> AndThenRows<'stmt, F> |
| where |
| F: FnMut(&Row<'_>) -> Result<T, E>, |
| { |
| AndThenRows { rows: self, map: f } |
| } |
| } |
| |
| impl<'stmt> Rows<'stmt> { |
| pub(crate) fn new(stmt: &'stmt Statement<'stmt>) -> Rows<'stmt> { |
| Rows { |
| stmt: Some(stmt), |
| row: None, |
| } |
| } |
| |
| pub(crate) fn get_expected_row(&mut self) -> Result<&Row<'stmt>> { |
| match self.next()? { |
| Some(row) => Ok(row), |
| None => Err(Error::QueryReturnedNoRows), |
| } |
| } |
| } |
| |
| impl Drop for Rows<'_> { |
| fn drop(&mut self) { |
| self.reset(); |
| } |
| } |
| |
| /// `F` is used to tranform the _streaming_ iterator into a _fallible_ iterator. |
| #[must_use = "iterators are lazy and do nothing unless consumed"] |
| pub struct Map<'stmt, F> { |
| rows: Rows<'stmt>, |
| f: F, |
| } |
| |
| impl<F, B> FallibleIterator for Map<'_, F> |
| where |
| F: FnMut(&Row<'_>) -> Result<B>, |
| { |
| type Error = Error; |
| type Item = B; |
| |
| fn next(&mut self) -> Result<Option<B>> { |
| match self.rows.next()? { |
| Some(v) => Ok(Some((self.f)(v)?)), |
| None => Ok(None), |
| } |
| } |
| } |
| |
| /// An iterator over the mapped resulting rows of a query. |
| /// |
| /// `F` is used to tranform the _streaming_ iterator into a _standard_ iterator. |
| #[must_use = "iterators are lazy and do nothing unless consumed"] |
| pub struct MappedRows<'stmt, F> { |
| rows: Rows<'stmt>, |
| map: F, |
| } |
| |
| impl<'stmt, T, F> MappedRows<'stmt, F> |
| where |
| F: FnMut(&Row<'_>) -> Result<T>, |
| { |
| pub(crate) fn new(rows: Rows<'stmt>, f: F) -> MappedRows<'stmt, F> { |
| MappedRows { rows, map: f } |
| } |
| } |
| |
| impl<T, F> Iterator for MappedRows<'_, F> |
| where |
| F: FnMut(&Row<'_>) -> Result<T>, |
| { |
| type Item = Result<T>; |
| |
| fn next(&mut self) -> Option<Result<T>> { |
| let map = &mut self.map; |
| self.rows |
| .next() |
| .transpose() |
| .map(|row_result| row_result.and_then(|row| (map)(&row))) |
| } |
| } |
| |
| /// An iterator over the mapped resulting rows of a query, with an Error type |
| /// unifying with Error. |
| #[must_use = "iterators are lazy and do nothing unless consumed"] |
| pub struct AndThenRows<'stmt, F> { |
| rows: Rows<'stmt>, |
| map: F, |
| } |
| |
| impl<'stmt, T, E, F> AndThenRows<'stmt, F> |
| where |
| F: FnMut(&Row<'_>) -> Result<T, E>, |
| { |
| pub(crate) fn new(rows: Rows<'stmt>, f: F) -> AndThenRows<'stmt, F> { |
| AndThenRows { rows, map: f } |
| } |
| } |
| |
| impl<T, E, F> Iterator for AndThenRows<'_, F> |
| where |
| E: convert::From<Error>, |
| F: FnMut(&Row<'_>) -> Result<T, E>, |
| { |
| type Item = Result<T, E>; |
| |
| fn next(&mut self) -> Option<Self::Item> { |
| let map = &mut self.map; |
| self.rows |
| .next() |
| .transpose() |
| .map(|row_result| row_result.map_err(E::from).and_then(|row| (map)(&row))) |
| } |
| } |
| |
| /// `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: |
| /// ```rust,no_run |
| /// # use rusqlite::{Result, Statement, NO_PARAMS}; |
| /// fn query(stmt: &mut Statement) -> Result<()> { |
| /// let mut rows = stmt.query(NO_PARAMS)?; |
| /// while let Some(row) = rows.next()? { |
| /// // scan columns value |
| /// } |
| /// Ok(()) |
| /// } |
| /// ``` |
| impl<'stmt> FallibleStreamingIterator for Rows<'stmt> { |
| type Error = Error; |
| type Item = Row<'stmt>; |
| |
| fn advance(&mut self) -> Result<()> { |
| match self.stmt { |
| Some(ref stmt) => match stmt.step() { |
| Ok(true) => { |
| self.row = Some(Row { stmt }); |
| Ok(()) |
| } |
| Ok(false) => { |
| self.reset(); |
| self.row = None; |
| Ok(()) |
| } |
| Err(e) => { |
| self.reset(); |
| self.row = None; |
| Err(e) |
| } |
| }, |
| None => { |
| self.row = None; |
| Ok(()) |
| } |
| } |
| } |
| |
| fn get(&self) -> Option<&Row<'stmt>> { |
| self.row.as_ref() |
| } |
| } |
| |
| /// A single result row of a query. |
| pub struct Row<'stmt> { |
| pub(crate) stmt: &'stmt Statement<'stmt>, |
| } |
| |
| impl<'stmt> Row<'stmt> { |
| /// Get the value of a particular column of the result row. |
| /// |
| /// ## Failure |
| /// |
| /// Panics if calling `row.get(idx)` would return an error, |
| /// including: |
| /// |
| /// * If the underlying SQLite column type is not a valid type as a source |
| /// for `T` |
| /// * If the underlying SQLite integral value is outside the range |
| /// representable by `T` |
| /// * If `idx` is outside the range of columns in the returned query |
| pub fn get_unwrap<I: RowIndex, T: FromSql>(&self, idx: I) -> T { |
| self.get(idx).unwrap() |
| } |
| |
| /// Get the value of a particular column of the result row. |
| /// |
| /// ## Failure |
| /// |
| /// Returns an `Error::InvalidColumnType` if the underlying SQLite column |
| /// type is not a valid type as a source for `T`. |
| /// |
| /// Returns an `Error::InvalidColumnIndex` if `idx` is outside the valid |
| /// column range for this row. |
| /// |
| /// Returns an `Error::InvalidColumnName` if `idx` is not a valid column |
| /// name for this row. |
| /// |
| /// If the result type is i128 (which requires the `i128_blob` feature to be |
| /// enabled), and the underlying SQLite column is a blob whose size is not |
| /// 16 bytes, `Error::InvalidColumnType` will also be returned. |
| pub fn get<I: RowIndex, T: FromSql>(&self, idx: I) -> Result<T> { |
| let idx = idx.idx(self.stmt)?; |
| let value = self.stmt.value_ref(idx); |
| FromSql::column_result(value).map_err(|err| match err { |
| FromSqlError::InvalidType => Error::InvalidColumnType( |
| idx, |
| self.stmt.column_name_unwrap(idx).into(), |
| value.data_type(), |
| ), |
| FromSqlError::OutOfRange(i) => Error::IntegralValueOutOfRange(idx, i), |
| FromSqlError::Other(err) => { |
| Error::FromSqlConversionFailure(idx as usize, value.data_type(), err) |
| } |
| #[cfg(feature = "i128_blob")] |
| FromSqlError::InvalidI128Size(_) => Error::InvalidColumnType( |
| idx, |
| self.stmt.column_name_unwrap(idx).into(), |
| value.data_type(), |
| ), |
| #[cfg(feature = "uuid")] |
| FromSqlError::InvalidUuidSize(_) => Error::InvalidColumnType( |
| idx, |
| self.stmt.column_name_unwrap(idx).into(), |
| value.data_type(), |
| ), |
| }) |
| } |
| |
| /// Get the value of a particular column of the result row as a `ValueRef`, |
| /// allowing data to be read out of a row without copying. |
| /// |
| /// This `ValueRef` is valid only as long as this Row, which is enforced by |
| /// it's lifetime. This means that while this method is completely safe, |
| /// it can be somewhat difficult to use, and most callers will be better |
| /// served by `get` or `get`. |
| /// |
| /// ## Failure |
| /// |
| /// Returns an `Error::InvalidColumnIndex` if `idx` is outside the valid |
| /// column range for this row. |
| /// |
| /// Returns an `Error::InvalidColumnName` if `idx` is not a valid column |
| /// name for this row. |
| pub fn get_raw_checked<I: RowIndex>(&self, idx: I) -> Result<ValueRef<'_>> { |
| let idx = idx.idx(self.stmt)?; |
| // Narrowing from `ValueRef<'stmt>` (which `self.stmt.value_ref(idx)` |
| // returns) to `ValueRef<'a>` is needed because it's only valid until |
| // the next call to sqlite3_step. |
| let val_ref = self.stmt.value_ref(idx); |
| Ok(val_ref) |
| } |
| |
| /// Get the value of a particular column of the result row as a `ValueRef`, |
| /// allowing data to be read out of a row without copying. |
| /// |
| /// This `ValueRef` is valid only as long as this Row, which is enforced by |
| /// it's lifetime. This means that while this method is completely safe, |
| /// it can be difficult to use, and most callers will be better served by |
| /// `get` or `get`. |
| /// |
| /// ## Failure |
| /// |
| /// Panics if calling `row.get_raw_checked(idx)` would return an error, |
| /// including: |
| /// |
| /// * If `idx` is outside the range of columns in the returned query. |
| /// * If `idx` is not a valid column name for this row. |
| pub fn get_raw<I: RowIndex>(&self, idx: I) -> ValueRef<'_> { |
| self.get_raw_checked(idx).unwrap() |
| } |
| } |
| |
| /// A trait implemented by types that can index into columns of a row. |
| pub trait RowIndex { |
| /// Returns the index of the appropriate column, or `None` if no such |
| /// column exists. |
| fn idx(&self, stmt: &Statement<'_>) -> Result<usize>; |
| } |
| |
| impl RowIndex for usize { |
| #[inline] |
| fn idx(&self, stmt: &Statement<'_>) -> Result<usize> { |
| if *self >= stmt.column_count() { |
| Err(Error::InvalidColumnIndex(*self)) |
| } else { |
| Ok(*self) |
| } |
| } |
| } |
| |
| impl RowIndex for &'_ str { |
| #[inline] |
| fn idx(&self, stmt: &Statement<'_>) -> Result<usize> { |
| stmt.column_index(*self) |
| } |
| } |
| |
| macro_rules! tuple_try_from_row { |
| ($($field:ident),*) => { |
| impl<'a, $($field,)*> convert::TryFrom<&'a Row<'a>> for ($($field,)*) where $($field: FromSql,)* { |
| type Error = crate::Error; |
| |
| // we end with index += 1, which rustc warns about |
| // unused_variables and unused_mut are allowed for () |
| #[allow(unused_assignments, unused_variables, unused_mut)] |
| fn try_from(row: &'a Row<'a>) -> Result<Self> { |
| let mut index = 0; |
| $( |
| #[allow(non_snake_case)] |
| let $field = row.get::<_, $field>(index)?; |
| index += 1; |
| )* |
| Ok(($($field,)*)) |
| } |
| } |
| } |
| } |
| |
| macro_rules! tuples_try_from_row { |
| () => { |
| // not very useful, but maybe some other macro users will find this helpful |
| tuple_try_from_row!(); |
| }; |
| ($first:ident $(, $remaining:ident)*) => { |
| tuple_try_from_row!($first $(, $remaining)*); |
| tuples_try_from_row!($($remaining),*); |
| }; |
| } |
| |
| tuples_try_from_row!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P); |
| |
| #[cfg(test)] |
| mod tests { |
| #![allow(clippy::redundant_closure)] // false positives due to lifetime issues; clippy issue #5594 |
| |
| #[test] |
| fn test_try_from_row_for_tuple_1() { |
| use crate::{Connection, ToSql}; |
| use std::convert::TryFrom; |
| |
| let conn = Connection::open_in_memory().expect("failed to create in-memoory database"); |
| conn.execute( |
| "CREATE TABLE test (a INTEGER)", |
| std::iter::empty::<&dyn ToSql>(), |
| ) |
| .expect("failed to create table"); |
| conn.execute( |
| "INSERT INTO test VALUES (42)", |
| std::iter::empty::<&dyn ToSql>(), |
| ) |
| .expect("failed to insert value"); |
| let val = conn |
| .query_row( |
| "SELECT a FROM test", |
| std::iter::empty::<&dyn ToSql>(), |
| |row| <(u32,)>::try_from(row), |
| ) |
| .expect("failed to query row"); |
| assert_eq!(val, (42,)); |
| let fail = conn.query_row( |
| "SELECT a FROM test", |
| std::iter::empty::<&dyn ToSql>(), |
| |row| <(u32, u32)>::try_from(row), |
| ); |
| assert!(fail.is_err()); |
| } |
| |
| #[test] |
| fn test_try_from_row_for_tuple_2() { |
| use crate::{Connection, ToSql}; |
| use std::convert::TryFrom; |
| |
| let conn = Connection::open_in_memory().expect("failed to create in-memoory database"); |
| conn.execute( |
| "CREATE TABLE test (a INTEGER, b INTEGER)", |
| std::iter::empty::<&dyn ToSql>(), |
| ) |
| .expect("failed to create table"); |
| conn.execute( |
| "INSERT INTO test VALUES (42, 47)", |
| std::iter::empty::<&dyn ToSql>(), |
| ) |
| .expect("failed to insert value"); |
| let val = conn |
| .query_row( |
| "SELECT a, b FROM test", |
| std::iter::empty::<&dyn ToSql>(), |
| |row| <(u32, u32)>::try_from(row), |
| ) |
| .expect("failed to query row"); |
| assert_eq!(val, (42, 47)); |
| let fail = conn.query_row( |
| "SELECT a, b FROM test", |
| std::iter::empty::<&dyn ToSql>(), |
| |row| <(u32, u32, u32)>::try_from(row), |
| ); |
| assert!(fail.is_err()); |
| } |
| |
| #[test] |
| fn test_try_from_row_for_tuple_16() { |
| use crate::{Connection, ToSql}; |
| use std::convert::TryFrom; |
| |
| let create_table = "CREATE TABLE test ( |
| a INTEGER, |
| b INTEGER, |
| c INTEGER, |
| d INTEGER, |
| e INTEGER, |
| f INTEGER, |
| g INTEGER, |
| h INTEGER, |
| i INTEGER, |
| j INTEGER, |
| k INTEGER, |
| l INTEGER, |
| m INTEGER, |
| n INTEGER, |
| o INTEGER, |
| p INTEGER |
| )"; |
| |
| let insert_values = "INSERT INTO test VALUES ( |
| 0, |
| 1, |
| 2, |
| 3, |
| 4, |
| 5, |
| 6, |
| 7, |
| 8, |
| 9, |
| 10, |
| 11, |
| 12, |
| 13, |
| 14, |
| 15 |
| )"; |
| |
| type BigTuple = ( |
| u32, |
| u32, |
| u32, |
| u32, |
| u32, |
| u32, |
| u32, |
| u32, |
| u32, |
| u32, |
| u32, |
| u32, |
| u32, |
| u32, |
| u32, |
| u32, |
| ); |
| |
| let conn = Connection::open_in_memory().expect("failed to create in-memoory database"); |
| conn.execute(create_table, std::iter::empty::<&dyn ToSql>()) |
| .expect("failed to create table"); |
| conn.execute(insert_values, std::iter::empty::<&dyn ToSql>()) |
| .expect("failed to insert value"); |
| let val = conn |
| .query_row( |
| "SELECT * FROM test", |
| std::iter::empty::<&dyn ToSql>(), |
| |row| BigTuple::try_from(row), |
| ) |
| .expect("failed to query row"); |
| // Debug is not implemented for tuples of 16 |
| assert_eq!(val.0, 0); |
| assert_eq!(val.1, 1); |
| assert_eq!(val.2, 2); |
| assert_eq!(val.3, 3); |
| assert_eq!(val.4, 4); |
| assert_eq!(val.5, 5); |
| assert_eq!(val.6, 6); |
| assert_eq!(val.7, 7); |
| assert_eq!(val.8, 8); |
| assert_eq!(val.9, 9); |
| assert_eq!(val.10, 10); |
| assert_eq!(val.11, 11); |
| assert_eq!(val.12, 12); |
| assert_eq!(val.13, 13); |
| assert_eq!(val.14, 14); |
| assert_eq!(val.15, 15); |
| |
| // We don't test one bigger because it's unimplemented |
| } |
| } |
