Merge branch 'release-v0.7.0' into release

sfackler · sfackler · commit 009d93e2807e · 2016-10-09T22:33:40.000-07:00
diff --git a/.gitignore b/.gitignore
@@ -1,2 +1,4 @@
 /target
 /Cargo.lock
+/.idea
+*.iml
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,18 +1,13 @@
 [package]
 name = "postgres_array"
-version = "0.6.2"
+version = "0.7.0"
 authors = ["Steven Fackler <sfackler@gmail.com>"]
 license = "MIT"
 description = "Array support for rust-postgres"
 repository = "https://github.com/sfackler/rust-postgres-array"
-documentation = "https://sfackler.github.io/rust-postgres-array/doc/v0.6.2/postgres_array"
+documentation = "https://sfackler.github.io/rust-postgres-array/doc/v0.7.0/postgres_array"
 
 [dependencies]
-postgres = "0.11"
-byteorder = "0.5"
-
-[dev-dependencies]
-rustc-serialize = "0.3"
-time = "0.1"
-uuid = "0.1"
-postgres = { version = "0.11", features = ["rustc-serialize", "time", "uuid"] }
+fallible-iterator = "0.1"
+postgres = "0.12"
+postgres-protocol = "0.1"
diff --git a/README.md b/README.md
@@ -1,6 +1,6 @@
 # rust-postgres-array
 [![Build Status](https://travis-ci.org/sfackler/rust-postgres-array.svg?branch=master)](https://travis-ci.org/sfackler/rust-postgres-array)
 
-[Documentation](https://sfackler.github.io/rust-postgres-array/doc/v0.6.2/postgres_array)
+[Documentation](https://sfackler.github.io/rust-postgres-array/doc/v0.7.0/postgres_array)
 
 Support for PostgreSQL arrays in [rust-postgres](https://github.com/sfackler/rust-postgres).
diff --git a/src/array.rs b/src/array.rs
@@ -19,7 +19,7 @@ impl<T: fmt::Display> fmt::Display for Array<T> {
                 try!(write!(fmt,
                             "[{}:{}]",
                             dim.lower_bound,
-                            dim.lower_bound + dim.len as isize - 1));
+                            dim.lower_bound + dim.len - 1));
             }
             try!(write!(fmt, "="));
         }
@@ -61,7 +61,7 @@ impl<T> Array<T> {
     /// elements specified by the dimensions.
     pub fn from_parts(data: Vec<T>, dimensions: Vec<Dimension>) -> Array<T> {
         assert!((data.is_empty() && dimensions.is_empty()) ||
-                data.len() == dimensions.iter().fold(1, |acc, i| acc * i.len),
+                data.len() as i32 == dimensions.iter().fold(1, |acc, i| acc * i.len),
                 "size mismatch");
         Array {
             dims: dimensions,
@@ -70,10 +70,10 @@ impl<T> Array<T> {
     }
 
     /// Creates a new one-dimensional array.
-    pub fn from_vec(data: Vec<T>, lower_bound: isize) -> Array<T> {
+    pub fn from_vec(data: Vec<T>, lower_bound: i32) -> Array<T> {
         Array {
             dims: vec![Dimension {
-                           len: data.len(),
+                           len: data.len() as i32,
                            lower_bound: lower_bound,
                        }],
             data: data,
@@ -84,7 +84,7 @@ impl<T> Array<T> {
     ///
     /// For example, the one dimensional array `[1, 2]` would turn into the
     /// two-dimensional array `[[1, 2]]`.
-    pub fn wrap(&mut self, lower_bound: isize) {
+    pub fn wrap(&mut self, lower_bound: i32) {
         self.dims.insert(0,
                          Dimension {
                              len: 1,
@@ -120,7 +120,7 @@ impl<T> Array<T> {
         &self.dims
     }
 
-    fn shift_idx(&self, indices: &[isize]) -> usize {
+    fn shift_idx(&self, indices: &[i32]) -> i32 {
         assert_eq!(self.dims.len(), indices.len());
         self.dims
             .iter()
@@ -144,6 +144,12 @@ impl<T> Array<T> {
     pub fn iter_mut<'a>(&'a mut self) -> IterMut<'a, T> {
         IterMut { inner: self.data.iter_mut() }
     }
+
+    /// Returns the underlying data vector for this Array in the
+    /// higher-dimensional equivalent of row-major order.
+    pub fn into_inner(self) -> Vec<T> {
+        self.data
+    }
 }
 
 /// A trait implemented by types that can index into an `Array`.
@@ -155,51 +161,51 @@ pub trait ArrayIndex {
     ///
     /// Panics if the value of `self` does not correspond to an in-bounds
     /// element of the `Array`.
-    fn index<T>(&self, array: &Array<T>) -> usize;
+    fn index<T>(&self, array: &Array<T>) -> i32;
 }
 
-impl<'a> ArrayIndex for &'a [isize] {
-    fn index<T>(&self, array: &Array<T>) -> usize {
+impl<'a> ArrayIndex for &'a [i32] {
+    fn index<T>(&self, array: &Array<T>) -> i32 {
         array.shift_idx(*self)
     }
 }
 
-impl ArrayIndex for isize {
-    fn index<T>(&self, array: &Array<T>) -> usize {
-        let slice: &[isize] = &[*self];
+impl ArrayIndex for i32 {
+    fn index<T>(&self, array: &Array<T>) -> i32 {
+        let slice: &[i32] = &[*self];
         ArrayIndex::index(&slice, array)
     }
 }
 
 macro_rules! tuple_impl {
     ($($name:ident : $t:ty),+) => {
         impl ArrayIndex for ($($t,)+) {
-            fn index<T>(&self, array: &Array<T>) -> usize {
+            fn index<T>(&self, array: &Array<T>) -> i32 {
                 let ($($name,)+) = *self;
-                let slice: &[isize] = &[$($name),+];
+                let slice: &[i32] = &[$($name),+];
                 ArrayIndex::index(&slice, array)
             }
         }
     }
 }
 
-tuple_impl!(a: isize);
-tuple_impl!(a: isize, b: isize);
-tuple_impl!(a: isize, b: isize, c: isize);
-tuple_impl!(a: isize, b: isize, c: isize, d: isize);
-tuple_impl!(a: isize, b: isize, c: isize, d: isize, e: isize);
-tuple_impl!(a: isize, b: isize, c: isize, d: isize, e: isize, f: isize);
-tuple_impl!(a: isize, b: isize, c: isize, d: isize, e: isize, f: isize, g: isize);
-tuple_impl!(a: isize, b: isize, c: isize, d: isize, e: isize, f: isize, g: isize, h: isize);
-tuple_impl!(a: isize, b: isize, c: isize, d: isize, e: isize, f: isize, g: isize, h: isize, i: isize);
+tuple_impl!(a: i32);
+tuple_impl!(a: i32, b: i32);
+tuple_impl!(a: i32, b: i32, c: i32);
+tuple_impl!(a: i32, b: i32, c: i32, d: i32);
+tuple_impl!(a: i32, b: i32, c: i32, d: i32, e: i32);
+tuple_impl!(a: i32, b: i32, c: i32, d: i32, e: i32, f: i32);
+tuple_impl!(a: i32, b: i32, c: i32, d: i32, e: i32, f: i32, g: i32);
+tuple_impl!(a: i32, b: i32, c: i32, d: i32, e: i32, f: i32, g: i32, h: i32);
+tuple_impl!(a: i32, b: i32, c: i32, d: i32, e: i32, f: i32, g: i32, h: i32, i: i32);
 
 /// Indexes into the `Array`, retrieving a reference to the contained
 /// value.
 ///
 /// Since `Array`s can be multi-dimensional, the `Index` trait is
 /// implemented for a variety of index types. In the most generic case, a
-/// `&[isize]` can be used. In addition, a bare `isize` as well as tuples
-/// of up to 10 `isize` values may be used for convenience.
+/// `&[i32]` can be used. In addition, a bare `i32` as well as tuples
+/// of up to 10 `i32` values may be used for convenience.
 ///
 /// # Panics
 ///
@@ -222,14 +228,14 @@ impl<T, I: ArrayIndex> Index<I> for Array<T> {
     type Output = T;
     fn index(&self, idx: I) -> &T {
         let idx = idx.index(self);
-        &self.data[idx]
+        &self.data[idx as usize]
     }
 }
 
 impl<T, I: ArrayIndex> IndexMut<I> for Array<T> {
     fn index_mut(&mut self, idx: I) -> &mut T {
         let idx = idx.index(self);
-        &mut self.data[idx]
+        &mut self.data[idx as usize]
     }
 }
 
diff --git a/src/impls.rs b/src/impls.rs
@@ -1,57 +1,33 @@
-use std::io::prelude::*;
-use std::error;
-use byteorder::{ReadBytesExt, WriteBytesExt, BigEndian};
-
-use postgres::{self, Result};
-use postgres::error::Error;
-use postgres::types::{Type, Kind, ToSql, FromSql, Oid, IsNull, SessionInfo};
+use fallible_iterator::FallibleIterator;
+use postgres::types::{Type, Kind, ToSql, FromSql, IsNull, SessionInfo};
+use postgres_protocol::types;
+use postgres_protocol;
+use std::error::Error;
 
 use {Array, Dimension};
 
 impl<T> FromSql for Array<T>
     where T: FromSql
 {
-    fn from_sql<R: Read>(ty: &Type, raw: &mut R, info: &SessionInfo) -> postgres::Result<Array<T>> {
-        let element_type = match ty.kind() {
-            &Kind::Array(ref ty) => ty,
-            _ => panic!("unexpected type {:?}", ty),
+    fn from_sql(ty: &Type, raw: &[u8], info: &SessionInfo) -> Result<Array<T>, Box<Error + Sync + Send>> {
+        let element_type = match *ty.kind() {
+            Kind::Array(ref ty) => ty,
+            _ => unreachable!(),
         };
 
-        let ndim = try!(raw.read_u32::<BigEndian>()) as usize;
-        let _has_null = try!(raw.read_i32::<BigEndian>()) == 1;
-        let _element_type: Oid = try!(raw.read_u32::<BigEndian>());
+        let array = try!(types::array_from_sql(raw));
 
-        let mut dim_info = Vec::with_capacity(ndim);
-        for _ in 0..ndim {
-            dim_info.push(Dimension {
-                len: try!(raw.read_u32::<BigEndian>()) as usize,
-                lower_bound: try!(raw.read_i32::<BigEndian>()) as isize,
-            });
-        }
-        let nele = if dim_info.len() == 0 {
-            0
-        } else {
-            dim_info.iter().fold(1, |product, info| product * info.len)
-        };
+        let dimensions = try!(array.dimensions()
+            .map(|d| {
+                Dimension { len: d.len, lower_bound: d.lower_bound }
+            })
+            .collect());
 
-        let mut elements = Vec::with_capacity(nele);
-        for _ in 0..nele {
-            let len = try!(raw.read_i32::<BigEndian>());
-            if len < 0 {
-                elements.push(try!(FromSql::from_sql_null(&element_type, info)));
-            } else {
-                let mut limit = raw.take(len as u64);
-                elements.push(try!(FromSql::from_sql(&element_type, &mut limit, info)));
-                if limit.limit() != 0 {
-                    let err: Box<error::Error + Sync + Send> = "from_sql call did not consume all \
-                                                                data"
-                                                                   .into();
-                    return Err(Error::Conversion(err));
-                }
-            }
-        }
+        let elements = try!(array.values()
+            .and_then(|v| FromSql::from_sql_nullable(element_type, v, info))
+            .collect());
 
-        Ok(Array::from_parts(elements, dim_info))
+        Ok(Array::from_parts(elements, dimensions))
     }
 
     fn accepts(ty: &Type) -> bool {
@@ -65,44 +41,34 @@ impl<T> FromSql for Array<T>
 impl<T> ToSql for Array<T>
     where T: ToSql
 {
-    fn to_sql<W: ?Sized + Write>(&self,
-                                 ty: &Type,
-                                 mut w: &mut W,
-                                 info: &SessionInfo)
-                                 -> postgres::Result<IsNull> {
+    fn to_sql(&self, ty: &Type, w: &mut Vec<u8>, info: &SessionInfo) -> Result<IsNull, Box<Error + Sync + Send>> {
         let element_type = match ty.kind() {
             &Kind::Array(ref ty) => ty,
-            _ => panic!("unexpected type {:?}", ty),
+            _ => unreachable!(),
         };
 
-        try!(w.write_i32::<BigEndian>(try!(downcast(self.dimensions().len()))));
-        try!(w.write_i32::<BigEndian>(1));
-        try!(w.write_u32::<BigEndian>(element_type.oid()));
-
-        for info in self.dimensions() {
-            try!(w.write_i32::<BigEndian>(try!(downcast(info.len))));
-
-            let bound = if info.lower_bound > i32::max_value() as isize ||
-                           info.lower_bound < i32::min_value() as isize {
-                let err: Box<error::Error + Sync + Send> = "value too large to transmit".into();
-                return Err(Error::Conversion(err));
-            } else {
-                info.lower_bound as i32
-            };
-            try!(w.write_i32::<BigEndian>(bound));
-        }
-
-        let mut inner_buf = vec![];
-        for v in self {
-            match try!(v.to_sql(element_type, &mut inner_buf, info)) {
-                IsNull::Yes => try!(w.write_i32::<BigEndian>(-1)),
-                IsNull::No => {
-                    try!(w.write_i32::<BigEndian>(try!(downcast(inner_buf.len()))));
-                    try!(w.write_all(&inner_buf));
+        let dimensions = self.dimensions()
+            .iter()
+            .map(|d| {
+                types::ArrayDimension {
+                    len: d.len,
+                    lower_bound: d.lower_bound,
                 }
-            }
-            inner_buf.clear();
-        }
+            });
+        let elements = self.iter();
+
+        try!(types::array_to_sql(dimensions,
+                                 true,
+                                 element_type.oid(),
+                                 elements,
+                                 |v, w| {
+                                     match v.to_sql(element_type, w, info) {
+                                         Ok(IsNull::Yes) => Ok(postgres_protocol::IsNull::Yes),
+                                         Ok(IsNull::No) => Ok(postgres_protocol::IsNull::No),
+                                         Err(e) => Err(e),
+                                     }
+                                 },
+                                 w));
 
         Ok(IsNull::No)
     }
@@ -117,26 +83,17 @@ impl<T> ToSql for Array<T>
     to_sql_checked!();
 }
 
-fn downcast(len: usize) -> Result<i32> {
-    if len > i32::max_value() as usize {
-        let err: Box<error::Error + Sync + Send> = "value too large to transmit".into();
-        Err(Error::Conversion(err))
-    } else {
-        Ok(len as i32)
-    }
-}
-
 #[cfg(test)]
 mod test {
     use std::fmt;
 
-    use postgres::{Connection, SslMode};
+    use postgres::{Connection, TlsMode};
     use postgres::types::{FromSql, ToSql};
     use Array;
 
     fn test_type<T: PartialEq + FromSql + ToSql, S: fmt::Display>(sql_type: &str,
                                                                   checks: &[(T, S)]) {
-        let conn = Connection::connect("postgres://postgres@localhost", SslMode::None).unwrap();
+        let conn = Connection::connect("postgres://postgres@localhost", TlsMode::None).unwrap();
         for &(ref val, ref repr) in checks.iter() {
             let stmt = conn.prepare(&format!("SELECT {}::{}", *repr, sql_type)).unwrap();
             let result = stmt.query(&[]).unwrap().iter().next().unwrap().get(0);
@@ -256,7 +213,7 @@ mod test {
 
     #[test]
     fn test_empty_array() {
-        let conn = Connection::connect("postgres://postgres@localhost", SslMode::None).unwrap();
+        let conn = Connection::connect("postgres://postgres@localhost", TlsMode::None).unwrap();
         let stmt = conn.prepare("SELECT '{}'::INT4[]").unwrap();
         stmt.query(&[]).unwrap().iter().next().unwrap().get::<_, Array<i32>>(0);
     }
diff --git a/src/lib.rs b/src/lib.rs

-Original file line number
+Diff line change
@@ @@ -1,2 +1,4 @@ @@
 /target
 /Cargo.lock
 +/.idea
 +*.iml