Support BYTEA[]

Author: sfackler

README.md

@@ -262,6 +262,10 @@ types. The driver currently supports the following conversions:
             <td>types::array::ArrayBase&lt;Option&lt;bool&gt;&gt;</td>
             <td>BOOL[], BOOL[][], ...</td>
         </tr>
+        <tr>
+            <td>types::array::ArrayBase&lt;Option&lt;~[u8]&gt;&gt;</td>
+            <td>BYTEA[], BYTEA[][], ...</td>
+        </tr>
         <tr>
             <td>types::array::ArrayBase&lt;Option&lt;i32&gt;&gt;</td>
             <td>INT4[], INT4[][], ...</td>

test.rs

@@ -457,6 +457,12 @@ fn test_boolarray_params() {
     test_array_params!("BOOL", false, "f", true, "t", true, "t");
 }
 
+#[test]
+fn test_byteaarray_params() {
+    test_array_params!("BYTEA", ~[0u8, 1], r#""\\x0001""#, ~[254u8, 255u8],
+                       r#""\\xfeff""#, ~[10u8, 11u8], r#""\\x0a0b""#);
+}
+
 #[test]
 fn test_hstore_params() {
     macro_rules! make_map(

types/mod.rs

@@ -86,6 +86,8 @@ pub enum PostgresType {
     PgFloat8,
     /// BOOL[]
     PgBoolArray,
+    /// BYTEA[]
+    PgByteAArray,
     /// INT4[]
     PgInt4Array,
     /// INT8[]
@@ -136,6 +138,7 @@ impl PostgresType {
             FLOAT4OID => PgFloat4,
             FLOAT8OID => PgFloat8,
             BOOLARRAYOID => PgBoolArray,
+            BYTEAARRAYOID => PgByteAArray,
             INT4ARRAYOID => PgInt4Array,
             INT8ARRAYOID => PgInt8Array,
             FLOAT4ARRAYOID => PgFloat4Array,
@@ -194,32 +197,38 @@ pub trait FromSql {
 }
 
 trait RawFromSql {
-    fn raw_from_sql<R: Reader>(raw: &mut R) -> Self;
+    fn raw_from_sql<R: Reader>(len: uint, raw: &mut R) -> Self;
 }
 
 macro_rules! raw_from_impl(
     ($t:ty, $f:ident) => (
         impl RawFromSql for $t {
-            fn raw_from_sql<R: Reader>(raw: &mut R) -> $t {
+            fn raw_from_sql<R: Reader>(_len: uint, raw: &mut R) -> $t {
                 raw.$f()
             }
         }
     )
 )
 
 impl RawFromSql for bool {
-    fn raw_from_sql<R: Reader>(raw: &mut R) -> bool {
+    fn raw_from_sql<R: Reader>(_len: uint, raw: &mut R) -> bool {
         raw.read_u8() != 0
     }
 }
 
+impl RawFromSql for ~[u8] {
+    fn raw_from_sql<R: Reader>(len: uint, raw: &mut R) -> ~[u8] {
+        raw.read_bytes(len)
+    }
+}
+
 raw_from_impl!(i32, read_be_i32)
 raw_from_impl!(i64, read_be_i64)
 raw_from_impl!(f32, read_be_f32)
 raw_from_impl!(f64, read_be_f64)
 
 impl RawFromSql for Timespec {
-    fn raw_from_sql<R: Reader>(raw: &mut R) -> Timespec {
+    fn raw_from_sql<R: Reader>(_len: uint, raw: &mut R) -> Timespec {
         let t = raw.read_be_i64();
         let mut sec = t / USEC_PER_SEC + TIME_SEC_CONVERSION;
         let mut usec = t % USEC_PER_SEC;
@@ -248,7 +257,7 @@ macro_rules! from_raw_from_impl(
     ($($expected:pat)|+, $t:ty) => (
         from_map_impl!($($expected)|+, $t, |buf| {
             let mut reader = BufReader::new(buf.as_slice());
-            RawFromSql::raw_from_sql(&mut reader)
+            RawFromSql::raw_from_sql(buf.len(), &mut reader)
         })
     )
 )
@@ -276,6 +285,8 @@ macro_rules! from_option_impl(
 
 from_raw_from_impl!(PgBool, bool)
 from_option_impl!(bool)
+from_raw_from_impl!(PgByteA, ~[u8])
+from_option_impl!(~[u8])
 from_raw_from_impl!(PgInt4, i32)
 from_option_impl!(i32)
 from_raw_from_impl!(PgInt8, i64)
@@ -295,11 +306,6 @@ from_map_impl!(PgVarchar | PgText | PgCharN, ~str, |buf| {
 })
 from_option_impl!(~str)
 
-from_map_impl!(PgByteA, ~[u8], |buf| {
-    buf.clone()
-})
-from_option_impl!(~[u8])
-
 from_map_impl!(PgJson, Json, |buf| {
     json::from_str(str::from_utf8(buf.as_slice())).unwrap()
 })
@@ -328,9 +334,9 @@ macro_rules! from_range_impl(
                             0 => Exclusive,
                             _ => Inclusive
                         };
-                        rdr.read_be_i32();
-                        Some(RangeBound::new(RawFromSql::raw_from_sql(&mut rdr),
-                                             type_))
+                        let len = rdr.read_be_i32() as uint;
+                        Some(RangeBound::new(
+                                RawFromSql::raw_from_sql(len, &mut rdr), type_))
                     }
                     _ => None
                 };
@@ -340,9 +346,9 @@ macro_rules! from_range_impl(
                             0 => Exclusive,
                             _ => Inclusive
                         };
-                        rdr.read_be_i32();
-                        Some(RangeBound::new(RawFromSql::raw_from_sql(&mut rdr),
-                                             type_))
+                        let len = rdr.read_be_i32() as uint;
+                        Some(RangeBound::new(
+                                RawFromSql::raw_from_sql(len, &mut rdr), type_))
                     }
                     _ => None
                 };
@@ -386,7 +392,8 @@ macro_rules! from_array_impl(
                 if len < 0 {
                     elements.push(None);
                 } else {
-                    elements.push(Some(RawFromSql::raw_from_sql(&mut rdr)));
+                    elements.push(Some(RawFromSql::raw_from_sql(len as uint,
+                                                                &mut rdr)));
                 }
             }
 
@@ -398,6 +405,9 @@ macro_rules! from_array_impl(
 from_array_impl!(PgBoolArray, bool)
 from_option_impl!(ArrayBase<Option<bool>>)
 
+from_array_impl!(PgByteAArray, ~[u8])
+from_option_impl!(ArrayBase<Option<~[u8]>>)
+
 from_array_impl!(PgInt4Array, i32)
 from_option_impl!(ArrayBase<Option<i32>>)
 
@@ -477,6 +487,16 @@ impl RawToSql for bool {
     }
 }
 
+impl RawToSql for ~[u8] {
+    fn raw_to_sql<W: Writer>(&self, w: &mut W) {
+        w.write(self.as_slice())
+    }
+
+    fn raw_size(&self) -> uint {
+        self.len()
+    }
+}
+
 raw_to_impl!(i32, write_be_i32)
 raw_to_impl!(i64, write_be_i64)
 raw_to_impl!(f32, write_be_f32)
@@ -554,6 +574,8 @@ macro_rules! to_conversions_impl(
 
 to_raw_to_impl!(PgBool, bool)
 to_option_impl!(PgBool, bool)
+to_raw_to_impl!(PgByteA, ~[u8])
+to_option_impl!(PgByteA, ~[u8])
 to_raw_to_impl!(PgInt4, i32)
 to_option_impl!(PgInt4, i32)
 to_raw_to_impl!(PgInt8, i64)
@@ -585,21 +607,13 @@ impl<'self> ToSql for &'self str {
 to_option_impl!(PgVarchar | PgText | PgCharN, ~str)
 to_option_impl_self!(PgVarchar | PgText | PgCharN, &'self str)
 
-impl ToSql for ~[u8] {
-    fn to_sql(&self, ty: &PostgresType) -> (Format, Option<~[u8]>) {
-        check_types!(PgByteA, ty)
-        (Binary, Some(self.to_owned()))
-    }
-}
-
 impl<'self> ToSql for &'self [u8] {
     fn to_sql(&self, ty: &PostgresType) -> (Format, Option<~[u8]>) {
         check_types!(PgByteA, ty)
         (Binary, Some(self.to_owned()))
     }
 }
 
-to_option_impl!(PgByteA, ~[u8])
 to_option_impl_self!(PgByteA, &'self [u8])
 
 impl ToSql for Json {
@@ -715,6 +729,9 @@ macro_rules! to_array_impl(
 to_array_impl!(PgBoolArray, BOOLOID, bool)
 to_option_impl!(PgBoolArray, ArrayBase<Option<bool>>)
 
+to_array_impl!(PgByteAArray, BYTEAOID, ~[u8])
+to_option_impl!(PgByteAArray, ArrayBase<Option<~[u8]>>)
+
 to_array_impl!(PgInt4Array, INT4OID, i32)
 to_option_impl!(PgInt4Array, ArrayBase<Option<i32>>)