Hide Cursor, and just return a Box<Iterator> instead

This will allow us to abstract the `Connection` to be
non-backend-specific, without also having to do the same for `Cursor`.

Author: sgrif

diesel/src/connection/mod.rs

@@ -4,8 +4,6 @@ mod cursor;
 #[doc(hidden)]
 pub mod raw;
 
-pub use self::cursor::Cursor;
-
 use std::cell::Cell;
 use std::ffi::{CString, CStr};
 use std::rc::Rc;
@@ -22,6 +20,7 @@ use query_builder::pg::PgQueryBuilder;
 use query_dsl::{FilterDsl, LimitDsl};
 use query_source::{Table, Queryable};
 use result::*;
+use self::cursor::Cursor;
 use self::raw::RawConnection;
 use types::{NativeSqlType, ToSql};
 
@@ -123,13 +122,14 @@ impl Connection {
     }
 
     #[doc(hidden)]
-    pub fn query_all<T, U>(&self, source: T) -> QueryResult<Cursor<T::SqlType, U>> where
+    pub fn query_all<'a, T, U: 'a>(&self, source: T) -> QueryResult<Box<Iterator<Item=U> + 'a>> where
         T: AsQuery,
         T::Query: QueryFragment,
         U: Queryable<T::SqlType>,
     {
         let (sql, params, types) = self.prepare_query(&source.as_query());
-        self.exec_sql_params(&sql, &params, &Some(types)).map(Cursor::new)
+        self.exec_sql_params(&sql, &params, &Some(types))
+            .map(|r| Box::new(Cursor::new(r)) as Box<Iterator<Item=U>>)
     }
 
     fn exec_sql_params(&self, query: &str, param_data: &Vec<Option<Vec<u8>>>, param_types: &Option<Vec<u32>>) -> QueryResult<DbResult> {

diesel/src/lib.rs

@@ -71,7 +71,7 @@ pub mod prelude {
     pub use result::{QueryResult, TransactionError, TransactionResult, ConnectionError, ConnectionResult, OptionalExtension};
 }
 
-pub use connection::{Connection, Cursor};
+pub use connection::Connection;
 pub use prelude::*;
 #[doc(inline)]
 pub use query_builder::functions::{insert, update, delete, select};

diesel/src/query_dsl/load_dsl.rs

@@ -1,4 +1,4 @@
-use connection::{Connection, Cursor};
+use connection::Connection;
 use query_builder::{Query, QueryFragment, AsQuery};
 use query_source::Queryable;
 use result::QueryResult;
@@ -11,8 +11,8 @@ pub trait LoadDsl: AsQuery + Sized where
 {
     /// Executes the given query, returning an `Iterator` over the returned
     /// rows.
-    fn load<U>(self, conn: &Connection) -> QueryResult<Cursor<Self::SqlType, U>> where
-        U: Queryable<Self::SqlType>
+    fn load<'a, U>(self, conn: &Connection) -> QueryResult<Box<Iterator<Item=U> + 'a>> where
+        U: Queryable<Self::SqlType> + 'a,
     {
         conn.query_all(self)
     }
@@ -40,8 +40,8 @@ pub trait LoadDsl: AsQuery + Sized where
     }
 
     /// Runs the command, returning an `Iterator` over the affected rows.
-    fn get_results<U>(self, conn: &Connection) -> QueryResult<Cursor<Self::SqlType, U>> where
-        U: Queryable<Self::SqlType>
+    fn get_results<'a, U>(self, conn: &Connection) -> QueryResult<Box<Iterator<Item=U> + 'a>> where
+        U: Queryable<Self::SqlType> + 'a,
     {
         self.load(conn)
     }

diesel/src/types/mod.rs

@@ -57,7 +57,7 @@ pub type BigSerial = BigInt;
 #[derive(Clone, Copy, Default)] pub struct Nullable<T: NativeSqlType + NotNull>(T);
 #[derive(Clone, Copy, Default)] pub struct Array<T: NativeSqlType>(T);
 
-pub trait NativeSqlType {
+pub trait NativeSqlType: 'static {
     fn oid(&self) -> u32;
     fn array_oid(&self) -> u32;
     fn new() -> Self where Self: Sized;

diesel_tests/tests/compile-fail/select_carries_correct_result_type_info.rs

@@ -19,8 +19,6 @@ fn main() {
 
     let ids: Vec<i32> = select_name.load(&connection).unwrap().collect();
     //~^ ERROR the trait `diesel::query_source::Queryable<diesel::types::VarChar>` is not implemented for the type `i32`
-    //~| ERROR E0277
     let names: Vec<String> = select_id.load(&connection).unwrap().collect();
     //~^ ERROR the trait `diesel::query_source::Queryable<diesel::types::Integer>` is not implemented
-    //~| ERROR E0277
 }

diesel_tests/tests/filter_operators.rs

@@ -125,9 +125,7 @@ trait TestResultHelpers<U> {
     fn as_vec(self) -> Vec<U>;
 }
 
-impl<ST, U> TestResultHelpers<U> for QueryResult<Cursor<ST, U>> where
-    Cursor<ST, U>: Iterator<Item=U>,
-{
+impl<U> TestResultHelpers<U> for QueryResult<Box<Iterator<Item=U>>> {
     fn as_vec(self) -> Vec<U> {
         self.unwrap().collect()
     }