Merge pull request #54 from fernandobatels/queryable_lifetime

Simplify `Queryable` trait

src/connection/mod.rs

@@ -446,19 +446,21 @@ where
     }
 }
 
-impl<'a, R, C> Queryable<'a, R> for Connection<C>
+impl<C> Queryable for Connection<C>
 where
-    R: FromRow + 'a,
-    C: FirebirdClient + 'a,
+    C: FirebirdClient,
 {
-    type Iter = StmtIter<'a, R, C>;
-
     /// Prepare, execute, return the rows and commit the sql query
     ///
     /// Use `()` for no parameters or a tuple of parameters
-    fn query_iter<P>(&'a mut self, sql: &str, params: P) -> Result<Self::Iter, FbError>
+    fn query_iter<'a, P, R>(
+        &'a mut self,
+        sql: &str,
+        params: P,
+    ) -> Result<Box<dyn Iterator<Item = Result<R, FbError>> + 'a>, FbError>
     where
         P: IntoParams,
+        R: FromRow + 'static,
     {
         let mut tr = Transaction::new(self)?;
 
@@ -476,7 +478,7 @@ where
                     _marker: Default::default(),
                 };
 
-                Ok(iter)
+                Ok(Box::new(iter))
             }
             Err(e) => {
                 // Return the statement to the cache

src/query.rs

@@ -7,35 +7,37 @@
 use rsfbclient_core::{FbError, FromRow, IntoParams};
 
 /// Implemented for types that can be used to execute sql queries
-pub trait Queryable<'a, R>
-where
-    R: FromRow + 'a,
-{
-    type Iter: Iterator<Item = Result<R, FbError>> + 'a;
-
+pub trait Queryable {
     /// Returns the results of the query as an iterator
     ///
     /// Use `()` for no parameters or a tuple of parameters
-    fn query_iter<P>(&'a mut self, sql: &str, params: P) -> Result<Self::Iter, FbError>
+    fn query_iter<'a, P, R>(
+        &'a mut self,
+        sql: &str,
+        params: P,
+    ) -> Result<Box<dyn Iterator<Item = Result<R, FbError>> + 'a>, FbError>
     where
-        P: IntoParams;
+        P: IntoParams,
+        R: FromRow + 'static;
 
     /// Returns the results of the query as a `Vec`
     ///
     /// Use `()` for no parameters or a tuple of parameters
-    fn query<P>(&'a mut self, sql: &str, params: P) -> Result<Vec<R>, FbError>
+    fn query<'a, P, R>(&'a mut self, sql: &str, params: P) -> Result<Vec<R>, FbError>
     where
         P: IntoParams,
+        R: FromRow + 'static,
     {
         self.query_iter(sql, params)?.collect()
     }
 
     /// Returns the first result of the query, or None
     ///
     /// Use `()` for no parameters or a tuple of parameters
-    fn query_first<P>(&'a mut self, sql: &str, params: P) -> Result<Option<R>, FbError>
+    fn query_first<'a, P, R>(&'a mut self, sql: &str, params: P) -> Result<Option<R>, FbError>
     where
         P: IntoParams,
+        R: FromRow + 'static,
     {
         self.query_iter(sql, params)?.next().transpose()
     }

src/transaction.rs

@@ -135,19 +135,21 @@ where
     }
 }
 
-impl<'a, R, C> Queryable<'a, R> for Transaction<'a, C>
+impl<'c, C> Queryable for Transaction<'c, C>
 where
-    R: FromRow + 'a,
     C: FirebirdClient,
 {
-    type Iter = StmtIter<'a, R, C>;
-
     /// Prepare, execute and return the rows of the sql query
     ///
     /// Use `()` for no parameters or a tuple of parameters
-    fn query_iter<P>(&'a mut self, sql: &str, params: P) -> Result<Self::Iter, FbError>
+    fn query_iter<'a, P, R>(
+        &'a mut self,
+        sql: &str,
+        params: P,
+    ) -> Result<Box<dyn Iterator<Item = Result<R, FbError>> + 'a>, FbError>
     where
         P: IntoParams,
+        R: FromRow + 'static,
     {
         // Get a statement from the cache
         let mut stmt_cache_data =
@@ -167,7 +169,7 @@ where
                     _marker: Default::default(),
                 };
 
-                Ok(iter)
+                Ok(Box::new(iter))
             }
             Err(e) => {
                 // Return the statement to the cache