Remove Binary/Text choice from ToSql

sfackler · sfackler · commit 011d531b1d4b · 2014-09-29T23:41:13.000-07:00
Text format doesn't work with our COPY implementation, and FromSql is
already binary only.
diff --git a/src/lib.rs b/src/lib.rs
@@ -138,7 +138,7 @@ use message::{Bind,
               Sync,
               Terminate};
 use message::{WriteMessage, ReadMessage};
-use types::{Oid, PostgresType, ToSql, FromSql, PgUnknownType, Binary};
+use types::{Oid, PostgresType, ToSql, FromSql, PgUnknownType};
 
 #[macro_escape]
 mod macros;
@@ -1137,23 +1137,19 @@ impl<'conn> PostgresStatement<'conn> {
                 actual: params.len(),
             });
         }
-        let mut formats = vec![];
         let mut values = vec![];
         for (param, ty) in params.iter().zip(self.param_types.iter()) {
-            let (format, value) = try!(param.to_sql(ty));
-            formats.push(format as i16);
+            let value = try!(param.to_sql(ty));
             values.push(value);
         };
 
-        let result_formats = Vec::from_elem(self.result_desc.len(), Binary as i16);
-
         try_pg!(conn.write_messages([
             Bind {
                 portal: portal_name,
                 statement: self.name.as_slice(),
-                formats: formats.as_slice(),
+                formats: [1],
                 values: values.as_slice(),
-                result_formats: result_formats.as_slice()
+                result_formats: [1]
             },
             Execute {
                 portal: portal_name,
@@ -1623,10 +1619,10 @@ impl<'a> PostgresCopyInStatement<'a> {
                 match (row.next(), types.next()) {
                     (Some(val), Some(ty)) => {
                         match try!(val.to_sql(ty)) {
-                            (_, None) => {
+                            None => {
                                 let _ = buf.write_be_i32(-1);
                             }
-                            (_, Some(val)) => {
+                            Some(val) => {
                                 let _ = buf.write_be_i32(val.len() as i32);
                                 let _ = buf.write(val.as_slice());
                             }
diff --git a/src/types/mod.rs b/src/types/mod.rs
@@ -198,14 +198,6 @@ make_postgres_type!(
     INT8RANGEARRAYOID => PgInt8RangeArray member PgInt8Range
 )
 
-/// The wire format of a Postgres value
-pub enum Format {
-    /// A user-readable string format
-    Text = 0,
-    /// A machine-readable binary format
-    Binary = 1
-}
-
 macro_rules! check_types(
     ($($expected:pat)|+, $actual:ident) => (
         match $actual {
@@ -497,10 +489,9 @@ impl FromSql for HashMap<String, Option<String>> {
 
 /// A trait for types that can be converted into Postgres values
 pub trait ToSql {
-    /// Converts the value of `self` into a format appropriate for the Postgres
-    /// backend.
-    fn to_sql(&self, ty: &PostgresType)
-            -> PostgresResult<(Format, Option<Vec<u8>>)>;
+    /// Converts the value of `self` into the binary format appropriate for the
+    /// Postgres backend.
+    fn to_sql(&self, ty: &PostgresType) -> PostgresResult<Option<Vec<u8>>>;
 }
 
 #[doc(hidden)]
@@ -612,11 +603,11 @@ impl RawToSql for Json {
 macro_rules! to_option_impl(
     ($($oid:pat)|+, $t:ty) => (
         impl ToSql for Option<$t> {
-            fn to_sql(&self, ty: &PostgresType) -> PostgresResult<(Format, Option<Vec<u8>>)> {
+            fn to_sql(&self, ty: &PostgresType) -> PostgresResult<Option<Vec<u8>>> {
                 check_types!($($oid)|+, ty)
 
                 match *self {
-                    None => Ok((Text, None)),
+                    None => Ok(None),
                     Some(ref val) => val.to_sql(ty)
                 }
             }
@@ -627,11 +618,11 @@ macro_rules! to_option_impl(
 macro_rules! to_option_impl_lifetime(
     ($($oid:pat)|+, $t:ty) => (
         impl<'a> ToSql for Option<$t> {
-            fn to_sql(&self, ty: &PostgresType) -> PostgresResult<(Format, Option<Vec<u8>>)> {
+            fn to_sql(&self, ty: &PostgresType) -> PostgresResult<Option<Vec<u8>>> {
                 check_types!($($oid)|+, ty)
 
                 match *self {
-                    None => Ok((Text, None)),
+                    None => Ok(None),
                     Some(ref val) => val.to_sql(ty)
                 }
             }
@@ -642,12 +633,12 @@ macro_rules! to_option_impl_lifetime(
 macro_rules! to_raw_to_impl(
     ($($oid:ident)|+, $t:ty) => (
         impl ToSql for $t {
-            fn to_sql(&self, ty: &PostgresType) -> PostgresResult<(Format, Option<Vec<u8>>)> {
+            fn to_sql(&self, ty: &PostgresType) -> PostgresResult<Option<Vec<u8>>> {
                 check_types!($($oid)|+, ty)
 
                 let mut writer = MemWriter::new();
                 try!(self.raw_to_sql(&mut writer));
-                Ok((Binary, Some(writer.unwrap())))
+                Ok(Some(writer.unwrap()))
             }
         }
 
@@ -670,18 +661,18 @@ to_raw_to_impl!(PgInt8Range, Range<i64>)
 to_raw_to_impl!(PgTsRange | PgTstzRange, Range<Timespec>)
 
 impl<'a> ToSql for &'a str {
-    fn to_sql(&self, ty: &PostgresType) -> PostgresResult<(Format, Option<Vec<u8>>)> {
+    fn to_sql(&self, ty: &PostgresType) -> PostgresResult<Option<Vec<u8>>> {
         check_types!(PgVarchar | PgText | PgCharN | PgName, ty)
-        Ok((Text, Some(self.as_bytes().to_vec())))
+        Ok(Some(self.as_bytes().to_vec()))
     }
 }
 
 to_option_impl_lifetime!(PgVarchar | PgText | PgCharN | PgName, &'a str)
 
 impl<'a> ToSql for &'a [u8] {
-    fn to_sql(&self, ty: &PostgresType) -> PostgresResult<(Format, Option<Vec<u8>>)> {
+    fn to_sql(&self, ty: &PostgresType) -> PostgresResult<Option<Vec<u8>>> {
         check_types!(PgByteA, ty)
-        Ok((Binary, Some(self.to_vec())))
+        Ok(Some(self.to_vec()))
     }
 }
 
@@ -692,7 +683,7 @@ to_raw_to_impl!(PgTimestamp | PgTimestampTZ, Timespec)
 macro_rules! to_array_impl(
     ($($oid:ident)|+, $t:ty) => (
         impl ToSql for ArrayBase<Option<$t>> {
-            fn to_sql(&self, ty: &PostgresType) -> PostgresResult<(Format, Option<Vec<u8>>)> {
+            fn to_sql(&self, ty: &PostgresType) -> PostgresResult<Option<Vec<u8>>> {
                 check_types!($($oid)|+, ty)
                 let mut buf = MemWriter::new();
 
@@ -718,7 +709,7 @@ macro_rules! to_array_impl(
                     }
                 }
 
-                Ok((Binary, Some(buf.unwrap())))
+                Ok(Some(buf.unwrap()))
             }
         }
 
@@ -742,7 +733,7 @@ to_array_impl!(PgInt8RangeArray, Range<i64>)
 to_array_impl!(PgJsonArray, Json)
 
 impl ToSql for HashMap<String, Option<String>> {
-    fn to_sql(&self, ty: &PostgresType) -> PostgresResult<(Format, Option<Vec<u8>>)> {
+    fn to_sql(&self, ty: &PostgresType) -> PostgresResult<Option<Vec<u8>>> {
         match *ty {
             PgUnknownType { name: ref name, .. } if "hstore" == name.as_slice() => {}
             _ => return Err(PgWrongType(ty.clone()))
@@ -765,20 +756,20 @@ impl ToSql for HashMap<String, Option<String>> {
             }
         }
 
-        Ok((Binary, Some(buf.unwrap())))
+        Ok(Some(buf.unwrap()))
     }
 }
 
 impl ToSql for Option<HashMap<String, Option<String>>> {
-    fn to_sql(&self, ty: &PostgresType) -> PostgresResult<(Format, Option<Vec<u8>>)> {
+    fn to_sql(&self, ty: &PostgresType) -> PostgresResult<Option<Vec<u8>>> {
         match *ty {
             PgUnknownType { name: ref name, .. } if "hstore" == name.as_slice() => {}
             _ => return Err(PgWrongType(ty.clone()))
         }
 
         match *self {
             Some(ref inner) => inner.to_sql(ty),
-            None => Ok((Binary, None))
+            None => Ok(None)
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -198,14 +198,6 @@ make_postgres_type!(`
`198`	`198`	`INT8RANGEARRAYOID => PgInt8RangeArray member PgInt8Range`
`199`	`199`	`)`
`200`	`200`
`201`		`-/// The wire format of a Postgres value`
`202`		`-pub enum Format {`
`203`		`- /// A user-readable string format`
`204`		`- Text = 0,`
`205`		`- /// A machine-readable binary format`
`206`		`- Binary = 1`
`207`		`-}`
`208`		`-`
`209`	`201`	`macro_rules! check_types(`
`210`	`202`	`($($expected:pat)\|+, $actual:ident) => (`
`211`	`203`	`match $actual {`
`@@ -497,10 +489,9 @@ impl FromSql for HashMap<String, Option<String>> {`
`497`	`489`
`498`	`490`	`/// A trait for types that can be converted into Postgres values`
`499`	`491`	`pub trait ToSql {`
`500`		- /// Converts the value of `self` into a format appropriate for the Postgres
`501`		`- /// backend.`
`502`		`- fn to_sql(&self, ty: &PostgresType)`
`503`		`- -> PostgresResult<(Format, Option<Vec<u8>>)>;`
	`492`	+ /// Converts the value of `self` into the binary format appropriate for the
	`493`	`+ /// Postgres backend.`
	`494`	`+ fn to_sql(&self, ty: &PostgresType) -> PostgresResult<Option<Vec<u8>>>;`
`504`	`495`	`}`
`505`	`496`
`506`	`497`	`#[doc(hidden)]`
`@@ -612,11 +603,11 @@ impl RawToSql for Json {`
`612`	`603`	`macro_rules! to_option_impl(`
`613`	`604`	`($($oid:pat)\|+, $t:ty) => (`
`614`	`605`	`impl ToSql for Option<$t> {`
`615`		`- fn to_sql(&self, ty: &PostgresType) -> PostgresResult<(Format, Option<Vec<u8>>)> {`
	`606`	`+ fn to_sql(&self, ty: &PostgresType) -> PostgresResult<Option<Vec<u8>>> {`
`616`	`607`	`check_types!($($oid)\|+, ty)`
`617`	`608`
`618`	`609`	`match *self {`
`619`		`- None => Ok((Text, None)),`
	`610`	`+ None => Ok(None),`
`620`	`611`	`Some(ref val) => val.to_sql(ty)`
`621`	`612`	`}`
`622`	`613`	`}`
`@@ -627,11 +618,11 @@ macro_rules! to_option_impl(`
`627`	`618`	`macro_rules! to_option_impl_lifetime(`
`628`	`619`	`($($oid:pat)\|+, $t:ty) => (`
`629`	`620`	`impl<'a> ToSql for Option<$t> {`
`630`		`- fn to_sql(&self, ty: &PostgresType) -> PostgresResult<(Format, Option<Vec<u8>>)> {`
	`621`	`+ fn to_sql(&self, ty: &PostgresType) -> PostgresResult<Option<Vec<u8>>> {`
`631`	`622`	`check_types!($($oid)\|+, ty)`
`632`	`623`
`633`	`624`	`match *self {`
`634`		`- None => Ok((Text, None)),`
	`625`	`+ None => Ok(None),`
`635`	`626`	`Some(ref val) => val.to_sql(ty)`
`636`	`627`	`}`
`637`	`628`	`}`
`@@ -642,12 +633,12 @@ macro_rules! to_option_impl_lifetime(`
`642`	`633`	`macro_rules! to_raw_to_impl(`
`643`	`634`	`($($oid:ident)\|+, $t:ty) => (`
`644`	`635`	`impl ToSql for $t {`
`645`		`- fn to_sql(&self, ty: &PostgresType) -> PostgresResult<(Format, Option<Vec<u8>>)> {`
	`636`	`+ fn to_sql(&self, ty: &PostgresType) -> PostgresResult<Option<Vec<u8>>> {`
`646`	`637`	`check_types!($($oid)\|+, ty)`
`647`	`638`
`648`	`639`	`let mut writer = MemWriter::new();`
`649`	`640`	`try!(self.raw_to_sql(&mut writer));`
`650`		`- Ok((Binary, Some(writer.unwrap())))`
	`641`	`+ Ok(Some(writer.unwrap()))`
`651`	`642`	`}`
`652`	`643`	`}`
`653`	`644`
`@@ -670,18 +661,18 @@ to_raw_to_impl!(PgInt8Range, Range<i64>)`
`670`	`661`	`to_raw_to_impl!(PgTsRange \| PgTstzRange, Range<Timespec>)`
`671`	`662`
`672`	`663`	`impl<'a> ToSql for &'a str {`
`673`		`- fn to_sql(&self, ty: &PostgresType) -> PostgresResult<(Format, Option<Vec<u8>>)> {`
	`664`	`+ fn to_sql(&self, ty: &PostgresType) -> PostgresResult<Option<Vec<u8>>> {`
`674`	`665`	`check_types!(PgVarchar \| PgText \| PgCharN \| PgName, ty)`
`675`		`- Ok((Text, Some(self.as_bytes().to_vec())))`
	`666`	`+ Ok(Some(self.as_bytes().to_vec()))`
`676`	`667`	`}`
`677`	`668`	`}`
`678`	`669`
`679`	`670`	`to_option_impl_lifetime!(PgVarchar \| PgText \| PgCharN \| PgName, &'a str)`
`680`	`671`
`681`	`672`	`impl<'a> ToSql for &'a [u8] {`
`682`		`- fn to_sql(&self, ty: &PostgresType) -> PostgresResult<(Format, Option<Vec<u8>>)> {`
	`673`	`+ fn to_sql(&self, ty: &PostgresType) -> PostgresResult<Option<Vec<u8>>> {`
`683`	`674`	`check_types!(PgByteA, ty)`
`684`		`- Ok((Binary, Some(self.to_vec())))`
	`675`	`+ Ok(Some(self.to_vec()))`
`685`	`676`	`}`
`686`	`677`	`}`
`687`	`678`
`@@ -692,7 +683,7 @@ to_raw_to_impl!(PgTimestamp \| PgTimestampTZ, Timespec)`
`692`	`683`	`macro_rules! to_array_impl(`
`693`	`684`	`($($oid:ident)\|+, $t:ty) => (`
`694`	`685`	`impl ToSql for ArrayBase<Option<$t>> {`
`695`		`- fn to_sql(&self, ty: &PostgresType) -> PostgresResult<(Format, Option<Vec<u8>>)> {`
	`686`	`+ fn to_sql(&self, ty: &PostgresType) -> PostgresResult<Option<Vec<u8>>> {`
`696`	`687`	`check_types!($($oid)\|+, ty)`
`697`	`688`	`let mut buf = MemWriter::new();`
`698`	`689`
`@@ -718,7 +709,7 @@ macro_rules! to_array_impl(`
`718`	`709`	`}`
`719`	`710`	`}`
`720`	`711`
`721`		`- Ok((Binary, Some(buf.unwrap())))`
	`712`	`+ Ok(Some(buf.unwrap()))`
`722`	`713`	`}`
`723`	`714`	`}`
`724`	`715`
`@@ -742,7 +733,7 @@ to_array_impl!(PgInt8RangeArray, Range<i64>)`
`742`	`733`	`to_array_impl!(PgJsonArray, Json)`
`743`	`734`
`744`	`735`	`impl ToSql for HashMap<String, Option<String>> {`
`745`		`- fn to_sql(&self, ty: &PostgresType) -> PostgresResult<(Format, Option<Vec<u8>>)> {`
	`736`	`+ fn to_sql(&self, ty: &PostgresType) -> PostgresResult<Option<Vec<u8>>> {`
`746`	`737`	`match *ty {`
`747`	`738`	`PgUnknownType { name: ref name, .. } if "hstore" == name.as_slice() => {}`
`748`	`739`	`_ => return Err(PgWrongType(ty.clone()))`
`@@ -765,20 +756,20 @@ impl ToSql for HashMap<String, Option<String>> {`
`765`	`756`	`}`
`766`	`757`	`}`
`767`	`758`
`768`		`- Ok((Binary, Some(buf.unwrap())))`
	`759`	`+ Ok(Some(buf.unwrap()))`
`769`	`760`	`}`
`770`	`761`	`}`
`771`	`762`
`772`	`763`	`impl ToSql for Option<HashMap<String, Option<String>>> {`
`773`		`- fn to_sql(&self, ty: &PostgresType) -> PostgresResult<(Format, Option<Vec<u8>>)> {`
	`764`	`+ fn to_sql(&self, ty: &PostgresType) -> PostgresResult<Option<Vec<u8>>> {`
`774`	`765`	`match *ty {`
`775`	`766`	`PgUnknownType { name: ref name, .. } if "hstore" == name.as_slice() => {}`
`776`	`767`	`_ => return Err(PgWrongType(ty.clone()))`
`777`	`768`	`}`
`778`	`769`
`779`	`770`	`match *self {`
`780`	`771`	`Some(ref inner) => inner.to_sql(ty),`
`781`		`- None => Ok((Binary, None))`
	`772`	`+ None => Ok(None)`
`782`	`773`	`}`
`783`	`774`	`}`
`784`	`775`	`}`