Merge branch 'release-v0.7.0' into release

Author: sfackler

.gitignore

@@ -1,2 +1,4 @@
 /target
 /Cargo.lock
+/.idea
+*.iml

Cargo.toml

@@ -1,18 +1,13 @@
 [package]
 name = "postgres_array"
-version = "0.6.2"
+version = "0.7.0"
 authors = ["Steven Fackler <[email protected]>"]
 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"

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).

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 asisize- 1));
+ dim.lower_bound + dim.len - 1));
 }
  try!(write!(fmt,"="));
 }
@@ -61,7 +61,7 @@ impl<T> Array<T>{
 /// elements specified by the dimensions.
 pubfnfrom_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()asi32== 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.
-pubfnfrom_vec(data:Vec<T>,lower_bound:isize) -> Array<T>{
+pubfnfrom_vec(data:Vec<T>,lower_bound:i32) -> Array<T>{
 Array{
 dims:vec![Dimension{
- len: data.len(),
+ len: data.len()asi32,
  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]]`.
-pubfnwrap(&mutself,lower_bound:isize){
+pubfnwrap(&mutself,lower_bound:i32){
 self.dims.insert(0,
 Dimension{
 len:1,
@@ -120,7 +120,7 @@ impl<T> Array<T>{
 &self.dims
 }
 
-fnshift_idx(&self,indices:&[isize]) -> usize{
+fnshift_idx(&self,indices:&[i32]) -> i32{
 assert_eq!(self.dims.len(), indices.len());
 self.dims
 .iter()
@@ -144,6 +144,12 @@ impl<T> Array<T>{
 pubfniter_mut<'a>(&'amutself) -> 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.
+pubfninto_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`.
-fnindex<T>(&self,array:&Array<T>) -> usize;
+fnindex<T>(&self,array:&Array<T>) -> i32;
 }
 
-impl<'a>ArrayIndexfor&'a[isize]{
-fnindex<T>(&self,array:&Array<T>) -> usize{
+impl<'a>ArrayIndexfor&'a[i32]{
+fnindex<T>(&self,array:&Array<T>) -> i32{
  array.shift_idx(*self)
 }
 }
 
-implArrayIndexforisize{
-fnindex<T>(&self,array:&Array<T>) -> usize{
-let slice:&[isize] = &[*self];
+implArrayIndexfori32{
+fnindex<T>(&self,array:&Array<T>) -> i32{
+let slice:&[i32] = &[*self];
 ArrayIndex::index(&slice, array)
 }
 }
 
 macro_rules! tuple_impl {
 ($($name:ident : $t:ty),+) => {
 implArrayIndexfor($($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>{
 typeOutput = T;
 fnindex(&self,idx:I) -> &T{
 let idx = idx.index(self);
-&self.data[idx]
+&self.data[idxasusize]
 }
 }
 
 impl<T,I:ArrayIndex>IndexMut<I>forArray<T>{
 fnindex_mut(&mutself,idx:I) -> &mutT{
 let idx = idx.index(self);
-&mutself.data[idx]
+&mutself.data[idxasusize]
 }
 }
 

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>FromSqlforArray<T>
 whereT:FromSql
 {
-fnfrom_sql<R:Read>(ty:&Type,raw:&mutR,info:&SessionInfo) -> postgres::Result<Array<T>>{
-let element_type = match ty.kind(){
-&Kind::Array(ref ty) => ty,
- _ => panic!("unexpected type{:?}", ty),
+fnfrom_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>())asusize;
-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));
 
-letmut dim_info = Vec::with_capacity(ndim);
-for _ in0..ndim {
- dim_info.push(Dimension{
-len: try!(raw.read_u32::<BigEndian>())asusize,
-lower_bound: try!(raw.read_i32::<BigEndian>())asisize,
-});
-}
-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());
 
-letmut elements = Vec::with_capacity(nele);
-for _ in0..nele {
-let len = try!(raw.read_i32::<BigEndian>());
-if len < 0{
- elements.push(try!(FromSql::from_sql_null(&element_type, info)));
-}else{
-letmut limit = raw.take(len asu64);
- 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();
-returnErr(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))
 }
 
 fnaccepts(ty:&Type) -> bool{
@@ -65,44 +41,34 @@ impl<T> FromSql for Array<T>
 impl<T>ToSqlforArray<T>
 whereT:ToSql
 {
-fnto_sql<W: ?Sized + Write>(&self,
-ty:&Type,
-mutw:&mutW,
-info:&SessionInfo)
- -> postgres::Result<IsNull>{
+fnto_sql(&self,ty:&Type,w:&mutVec<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 inself.dimensions(){
- try!(w.write_i32::<BigEndian>(try!(downcast(info.len))));
-
-let bound = if info.lower_bound > i32::max_value()asisize ||
- info.lower_bound < i32::min_value()asisize{
-let err:Box<error::Error + Sync + Send> = "value too large to transmit".into();
-returnErr(Error::Conversion(err));
-}else{
- info.lower_boundasi32
-};
- try!(w.write_i32::<BigEndian>(bound));
-}
-
-letmut inner_buf = vec![];
-for v inself{
-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!();
 }
 
-fndowncast(len:usize) -> Result<i32>{
-if len > i32::max_value()asusize{
-let err:Box<error::Error + Sync + Send> = "value too large to transmit".into();
-Err(Error::Conversion(err))
-}else{
-Ok(len asi32)
-}
-}
-
 #[cfg(test)]
 mod test {
 use std::fmt;
 
-use postgres::{Connection,SslMode};
+use postgres::{Connection,TlsMode};
 use postgres::types::{FromSql,ToSql};
 useArray;
 
 fntest_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]
 fntest_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);
 }