Update to new postgres

Author: sfackler

Cargo.toml

@@ -8,11 +8,6 @@ repository = "https://github.com/sfackler/rust-postgres-array"
 documentation = "https://sfackler.github.io/rust-postgres-array/doc/v0.6.2/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 ={git = "https://github.com/sfackler/rust-postgres" }
+postgres-protocol = "0.1"

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 asisize+ dim.len asisize - 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() == dimensions.iter().fold(1, |acc, i| acc * i.lenasusize),
 "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,
@@ -128,7 +128,7 @@ impl<T> Array<T>{
 .rev()
 .fold((0,1), |(acc, stride),(dim, idx)| {
 let shifted = dim.shift(idx);
-(acc + shifted * stride, dim.len* stride)
+(acc + shifted * stride, dim.lenasusize* stride)
 })
 .0
 }

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);
 }

src/lib.rs

@@ -1,9 +1,10 @@
 //! Multi-dimensional arrays with per-dimension specifiable lower bounds
 #![doc(html_root_url="https://sfackler.github.io/rust-postgres-array/doc/v0.6.2")]
 
-#[macro_use(to_sql_checked)]
+externcrate fallible_iterator;
+#[macro_use]
 externcrate postgres;
-externcratebyteorder;
+externcratepostgres_protocol;
 
 #[doc(inline)]
 pubuse array::Array;
@@ -15,19 +16,19 @@ mod impls;
 #[derive(Debug,Clone,Copy,PartialEq,Eq)]
 pubstructDimension{
 /// The length of the dimension.
-publen:usize,
+publen:i32,
 /// The index of the first element of the dimension.
-publower_bound:isize,
+publower_bound:i32,
 }
 
 implDimension{
 fnshift(&self,idx:isize) -> usize{
-let offset = self.lower_bound;
+let offset = self.lower_boundasisize;
 assert!(idx >= offset,"out of bounds array access");
 assert!(offset >= 0 || idx <= 0 || usize::max_value() - (-offset)asusize >= idx asusize,
 "out of bounds array access");
 let shifted = idx.wrapping_sub(offset)asusize;
-assert!(shifted < self.len,"out of bounds array access");
+assert!(shifted < self.lenasusize,"out of bounds array access");
  shifted
 }
 }