Pass Type to raw traits and add jsonb support

Author: sfackler

src/error.rs

@@ -653,7 +653,7 @@ impl fmt::String for Error {
                 write!(fmt, "A statement was executed with a connection it was not prepared with"),
             Error::WrongParamCount { expected, actual } =>
                 write!(fmt, "Expected {} parameters but got {}", expected, actual),
-            Error::WrongType(ref ty) => write!(fmt, "Unexpected type {}", ty),
+            Error::WrongType(ref ty) => write!(fmt, "Unexpected type {:?}", ty),
             Error::InvalidColumn => write!(fmt, "Invalid column"),
             Error::WasNull => write!(fmt, "The value was NULL"),
             Error::WrongTransaction =>
@@ -696,7 +696,7 @@ impl error::Error for Error {
             Error::WrongParamCount { expected, actual } => {
                 Some(format!("expected: {}, actual: {}", expected, actual))
             }
-            Error::WrongType(ref ty) => Some(format!("saw type {}", ty)),
+            Error::WrongType(ref ty) => Some(format!("saw type {:?}", ty)),
             _ => None
         }
     }

src/types/mod.rs

@@ -19,7 +19,7 @@ macro_rules! check_types {
 macro_rules! raw_from_impl {
     ($t:ty, $f:ident) => (
         impl RawFromSql for $t {
-            fn raw_from_sql<R: Reader>(raw: &mut R) -> Result<$t> {
+            fn raw_from_sql<R: Reader>(_: &Type, raw: &mut R) -> Result<$t> {
                 Ok(try!(raw.$f()))
             }
         }
@@ -51,7 +51,7 @@ macro_rules! from_map_impl {
             fn from_sql(ty: &Type, raw: Option<&[u8]>) -> Result<Option<$t>> {
                 check_types!($($expected),+; ty);
                 match raw {
-                    Some(buf) => ($blk)(buf).map(|ok| Some(ok)),
+                    Some(buf) => ($blk)(ty, buf).map(|ok| Some(ok)),
                     None => Ok(None)
                 }
             }
@@ -63,18 +63,18 @@ macro_rules! from_map_impl {
 
 macro_rules! from_raw_from_impl {
     ($($expected:pat),+; $t:ty) => (
-        from_map_impl!($($expected),+; $t, |&mut: mut buf: &[u8]| {
+        from_map_impl!($($expected),+; $t, |&mut: ty, mut buf: &[u8]| {
             use types::RawFromSql;
 
-            RawFromSql::raw_from_sql(&mut buf)
+            RawFromSql::raw_from_sql(ty, &mut buf)
         });
     )
 }
 
 macro_rules! raw_to_impl {
     ($t:ty, $f:ident) => (
         impl RawToSql for $t {
-            fn raw_to_sql<W: Writer>(&self, w: &mut W) -> Result<()> {
+            fn raw_to_sql<W: Writer>(&self, _: &Type, w: &mut W) -> Result<()> {
                 Ok(try!(w.$f(*self)))
             }
         }
@@ -118,7 +118,7 @@ macro_rules! to_raw_to_impl {
                 check_types!($($oid),+; ty);
 
                 let mut writer = vec![];
-                try!(self.raw_to_sql(&mut writer));
+                try!(self.raw_to_sql(ty, &mut writer));
                 Ok(Some(writer))
             }
         }
@@ -351,24 +351,27 @@ pub trait FromSql {
 
 /// A utility trait used by `FromSql` implementations
 pub trait RawFromSql {
-    /// Creates a new value of this type from a reader of Postgre data.
-    fn raw_from_sql<R: Reader>(raw: &mut R) -> Result<Self>;
+    /// Creates a new value of this type from a `Reader` of Postgres data.
+    ///
+    /// It is the caller's responsibility to ensure that Postgres data of this
+    /// type can be turned in to this type.
+    fn raw_from_sql<R: Reader>(ty: &Type, raw: &mut R) -> Result<Self>;
 }
 
 impl RawFromSql for bool {
-    fn raw_from_sql<R: Reader>(raw: &mut R) -> Result<bool> {
+    fn raw_from_sql<R: Reader>(_: &Type, raw: &mut R) -> Result<bool> {
         Ok((try!(raw.read_u8())) != 0)
     }
 }
 
 impl RawFromSql for Vec<u8> {
-    fn raw_from_sql<R: Reader>(raw: &mut R) -> Result<Vec<u8>> {
+    fn raw_from_sql<R: Reader>(_: &Type, raw: &mut R) -> Result<Vec<u8>> {
         Ok(try!(raw.read_to_end()))
     }
 }
 
 impl RawFromSql for String {
-    fn raw_from_sql<R: Reader>(raw: &mut R) -> Result<String> {
+    fn raw_from_sql<R: Reader>(_: &Type, raw: &mut R) -> Result<String> {
         String::from_utf8(try!(raw.read_to_end())).map_err(|_| Error::BadData)
     }
 }
@@ -382,13 +385,19 @@ raw_from_impl!(f32, read_be_f32);
 raw_from_impl!(f64, read_be_f64);
 
 impl RawFromSql for json::Json {
-    fn raw_from_sql<R: Reader>(raw: &mut R) -> Result<json::Json> {
+    fn raw_from_sql<R: Reader>(ty: &Type, raw: &mut R) -> Result<json::Json> {
+        if let Type::Jsonb = *ty {
+            // We only support version 1 of the jsonb binary format
+            if try!(raw.read_u8()) != 1 {
+                return Err(Error::BadData);
+            }
+        }
         json::Json::from_reader(raw).map_err(|_| Error::BadData)
     }
 }
 
 impl RawFromSql for IpAddr {
-    fn raw_from_sql<R: Reader>(raw: &mut R) -> Result<IpAddr> {
+    fn raw_from_sql<R: Reader>(_: &Type, raw: &mut R) -> Result<IpAddr> {
         let family = try!(raw.read_u8());
         let _bits = try!(raw.read_u8());
         let _is_cidr = try!(raw.read_u8());
@@ -424,7 +433,7 @@ from_raw_from_impl!(Type::Oid; u32);
 from_raw_from_impl!(Type::Int8; i64);
 from_raw_from_impl!(Type::Float4; f32);
 from_raw_from_impl!(Type::Float8; f64);
-from_raw_from_impl!(Type::Json; json::Json);
+from_raw_from_impl!(Type::Json, Type::Jsonb; json::Json);
 from_raw_from_impl!(Type::Inet, Type::Cidr; IpAddr);
 
 impl FromSql for Option<String> {
@@ -437,7 +446,7 @@ impl FromSql for Option<String> {
 
         match raw {
             Some(mut buf) => {
-                Ok(Some(try!(RawFromSql::raw_from_sql(&mut buf))))
+                Ok(Some(try!(RawFromSql::raw_from_sql(ty, &mut buf))))
             }
             None => Ok(None)
         }
@@ -500,25 +509,28 @@ pub trait ToSql {
 
 /// A utility trait used by `ToSql` implementations.
 pub trait RawToSql {
-    /// Converts the value of `self` into the binary format appropriate for the
-    /// Postgres backend, writing it to `w`.
-    fn raw_to_sql<W: Writer>(&self, w: &mut W) -> Result<()>;
+    /// Converts the value of `self` into the binary format of the specified
+    /// Postgres type, writing it to `w`.
+    ///
+    /// It is the caller's responsibility to make sure that this type can be
+    /// converted to the specified Postgres type.
+    fn raw_to_sql<W: Writer>(&self, ty: &Type, w: &mut W) -> Result<()>;
 }
 
 impl RawToSql for bool {
-    fn raw_to_sql<W: Writer>(&self, w: &mut W) -> Result<()> {
+    fn raw_to_sql<W: Writer>(&self, _: &Type, w: &mut W) -> Result<()> {
         Ok(try!(w.write_u8(*self as u8)))
     }
 }
 
 impl RawToSql for Vec<u8> {
-    fn raw_to_sql<W: Writer>(&self, w: &mut W) -> Result<()> {
+    fn raw_to_sql<W: Writer>(&self, _: &Type, w: &mut W) -> Result<()> {
         Ok(try!(w.write(&**self)))
     }
 }
 
 impl RawToSql for String {
-    fn raw_to_sql<W: Writer>(&self, w: &mut W) -> Result<()> {
+    fn raw_to_sql<W: Writer>(&self, _: &Type, w: &mut W) -> Result<()> {
         Ok(try!(w.write(self.as_bytes())))
     }
 }
@@ -532,13 +544,17 @@ raw_to_impl!(f32, write_be_f32);
 raw_to_impl!(f64, write_be_f64);
 
 impl RawToSql for json::Json {
-    fn raw_to_sql<W: Writer>(&self, raw: &mut W) -> Result<()> {
+    fn raw_to_sql<W: Writer>(&self, ty: &Type, raw: &mut W) -> Result<()> {
+        if let Type::Jsonb = *ty {
+            try!(raw.write_u8(1));
+        }
+
         Ok(try!(write!(raw, "{}", self)))
     }
 }
 
 impl RawToSql for IpAddr {
-    fn raw_to_sql<W: Writer>(&self, raw: &mut W) -> Result<()> {
+    fn raw_to_sql<W: Writer>(&self, _: &Type, raw: &mut W) -> Result<()> {
         match *self {
             IpAddr::Ipv4Addr(a, b, c, d) => {
                 try!(raw.write(&[2, // family
@@ -570,7 +586,7 @@ impl RawToSql for IpAddr {
 
 to_raw_to_impl!(Type::Bool; bool);
 to_raw_to_impl!(Type::ByteA; Vec<u8>);
-to_raw_to_impl!(Type::Json; json::Json);
+to_raw_to_impl!(Type::Json, Type::Jsonb; json::Json);
 to_raw_to_impl!(Type::Inet, Type::Cidr; IpAddr);
 to_raw_to_impl!(Type::Char; i8);
 to_raw_to_impl!(Type::Int2; i16);

src/types/time.rs

@@ -9,7 +9,7 @@ const NSEC_PER_USEC: i64 = 1_000;
 const TIME_SEC_CONVERSION: i64 = 946684800;
 
 impl RawFromSql for Timespec {
-    fn raw_from_sql<R: Reader>(raw: &mut R) -> Result<Timespec> {
+    fn raw_from_sql<R: Reader>(_: &Type, raw: &mut R) -> Result<Timespec> {
         let t = try!(raw.read_be_i64());
         let mut sec = t / USEC_PER_SEC + TIME_SEC_CONVERSION;
         let mut usec = t % USEC_PER_SEC;
@@ -26,7 +26,7 @@ impl RawFromSql for Timespec {
 from_raw_from_impl!(Type::Timestamp, Type::TimestampTZ; Timespec);
 
 impl RawToSql for Timespec {
-    fn raw_to_sql<W: Writer>(&self, w: &mut W) -> Result<()> {
+    fn raw_to_sql<W: Writer>(&self, _: &Type, w: &mut W) -> Result<()> {
         let t = (self.sec - TIME_SEC_CONVERSION) * USEC_PER_SEC + self.nsec as i64 / NSEC_PER_USEC;
         Ok(try!(w.write_be_i64(t)))
     }

src/types/uuid.rs

@@ -6,7 +6,7 @@ use Error;
 use Result;
 
 impl RawFromSql for Uuid {
-    fn raw_from_sql<R: Reader>(raw: &mut R) -> Result<Uuid> {
+    fn raw_from_sql<R: Reader>(_: &Type, raw: &mut R) -> Result<Uuid> {
         match Uuid::from_bytes(&*try!(raw.read_to_end())) {
             Some(u) => Ok(u),
             None => Err(Error::BadData),
@@ -17,7 +17,7 @@ impl RawFromSql for Uuid {
 from_raw_from_impl!(Type::Uuid; Uuid);
 
 impl RawToSql for Uuid {
-    fn raw_to_sql<W: Writer>(&self, w: &mut W) -> Result<()> {
+    fn raw_to_sql<W: Writer>(&self, _: &Type, w: &mut W) -> Result<()> {
         Ok(try!(w.write(self.as_bytes())))
     }
 }

tests/types/mod.rs

@@ -144,6 +144,15 @@ fn test_json_params() {
                        (None, "NULL")])
 }
 
+#[test]
+fn test_jsonb_params() {
+    test_type("JSONB", &[(Some(Json::from_str("[10, 11, 12]").unwrap()),
+                          "'[10, 11, 12]'"),
+                         (Some(Json::from_str("{\"f\": \"asd\"}").unwrap()),
+                          "'{\"f\": \"asd\"}'"),
+                         (None, "NULL")])
+}
+
 #[test]
 fn test_inet_params() {
     test_type("INET", &[(Some("127.0.0.1".parse::<IpAddr>().unwrap()),