Merge branch 'release-v0.5.1' into release

Author: sfackler

Cargo.toml

@@ -1,14 +1,14 @@
 [package]
 name = "postgres_array"
-version = "0.5.0"
+version = "0.5.1"
 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.5.0/postgres_array"
+documentation = "https://sfackler.github.io/rust-postgres-array/doc/v0.5.1/postgres_array"
 
 [dependencies]
-postgres = "0.9"
+postgres = ">= 0.9, < 0.11"
 byteorder = "0.3"
 
 [dev-dependencies]

README.md

@@ -3,4 +3,4 @@
 
 Support for PostgreSQL arrays in [rust-postgres](https://github.com/sfackler/rust-postgres).
 
-Documentation is available at https://sfackler.github.io/rust-postgres-array/doc/v0.5.0/postgres_array.
+Documentation is available at https://sfackler.github.io/rust-postgres-array/doc/v0.5.1/postgres_array.

src/array.rs

@@ -1,16 +1,50 @@
 use std::ops::{Index, IndexMut};
 use std::slice;
 use std::vec;
+use std::fmt;
 
 use Dimension;
 
 /// A multi-dimensional array.
-#[derive(Debug, PartialEq, Eq, Clone)]
+#[derive(PartialEq, Eq, Clone)]
 pub struct Array<T> {
     dims: Vec<Dimension>,
     data: Vec<T>,
 }
 
+impl<T: fmt::Debug> fmt::Debug for Array<T> {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        if self.dims.iter().any(|dim| dim.lower_bound != 1) {
+            for dim in &self.dims {
+                try!(write!(fmt, "[{}:{}]", dim.lower_bound,
+                            dim.lower_bound + dim.len as isize - 1));
+            }
+            try!(write!(fmt, "="));
+        }
+        fmt_helper(0, &self.dims, &mut self.data.iter(), fmt)
+    }
+}
+
+fn fmt_helper<'a, T, I>(depth: usize,
+                        dims: &[Dimension],
+                        mut data: &mut I,
+                        fmt: &mut fmt::Formatter)
+                        -> fmt::Result
+        where I: Iterator<Item=&'a T>, T: 'a+fmt::Debug {
+    if depth == dims.len() {
+        return write!(fmt, "{:?}", data.next().unwrap());
+    }
+
+    try!(write!(fmt, "{{"));
+    for i in 0..dims[depth].len {
+        if i != 0 {
+            try!(write!(fmt, ","));
+        }
+        try!(fmt_helper(depth + 1, dims, data, fmt));
+    }
+    write!(fmt, "}}")
+}
+
 impl<T> Array<T> {
     /// Creates a new `Array` from its underlying components.
     ///

src/impls.rs

@@ -2,7 +2,7 @@ use std::io::prelude::*;
 use std::error;
 use byteorder::{ReadBytesExt, WriteBytesExt, BigEndian};
 
-use postgres;
+use postgres::{self, Result};
 use postgres::error::Error;
 use postgres::types::{Type, Kind, ToSql, FromSql, Oid, IsNull, SessionInfo};
 
@@ -68,21 +68,29 @@ impl<T> ToSql for Array<T> where T: ToSql {
             _ => panic!("unexpected type {:?}", ty),
         };
 
-        try!(w.write_u32::<BigEndian>(self.dimensions().len() as u32));
+        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_u32::<BigEndian>(info.len as u32));
-            try!(w.write_i32::<BigEndian>(info.lower_bound as i32));
+            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>(inner_buf.len() as i32));
+                    try!(w.write_i32::<BigEndian>(try!(downcast(inner_buf.len()))));
                     try!(w.write_all(&inner_buf));
                 }
             }
@@ -102,6 +110,15 @@ impl<T> ToSql for Array<T> where T: ToSql {
     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;

src/lib.rs

@@ -1,5 +1,5 @@
 //! Multi-dimensional arrays with per-dimension specifiable lower bounds
-#![doc(html_root_url="https://sfackler.github.io/rust-postgres-array/doc/v0.5.0")]
+#![doc(html_root_url="https://sfackler.github.io/rust-postgres-array/doc/v0.5.1")]
 
 #[macro_use(to_sql_checked)]
 extern crate postgres;
@@ -118,4 +118,19 @@ mod tests {
         a[(0, 0)] = 3;
         assert_eq!(3, a[(0, 0)]);
     }
+
+    #[test]
+    fn test_debug() {
+        let a = Array::from_vec(vec![0i32, 1, 2, 3, 4], 1);
+        assert_eq!("{0,1,2,3,4}", &format!("{:?}", a));
+
+        let a = Array::from_vec(vec![0i32, 1, 2, 3, 4], -3);
+        assert_eq!("[-3:1]={0,1,2,3,4}", &format!("{:?}", a));
+
+        let mut a = Array::from_vec(vec![1i32, 2, 3], 3);
+        a.wrap(-2);
+        a.push(Array::from_vec(vec![4, 5, 6], 3));
+        a.wrap(1);
+        assert_eq!("[1:1][-2:-1][3:5]={{{1,2,3},{4,5,6}}}", &format!("{:?}", a));
+    }
 }