Infrastructure for binary parameter formats

Work towards rust-postgres#7.

Author: sfackler

src/lib.rs

@@ -10,7 +10,7 @@ use std::rt::io::net::ip::SocketAddr;
 use std::rt::io::net::tcp::TcpStream;
 
 use message::*;
-use types::{ToSql, FromSql};
+use types::{Oid, ToSql, FromSql};
 
 mod message;
 mod types;
@@ -266,10 +266,10 @@ impl PostgresConnection {
             resp => fail!("Bad response: %?", resp.to_str())
         })
 
-        match_read_message!(self, {
-            ParameterDescription {_} => (),
+        let param_types = match_read_message!(self, {
+            ParameterDescription { types } => types,
             resp => fail!("Bad response: %?", resp.to_str())
-        })
+        });
 
         match_read_message!(self, {
             RowDescription {_} | NoData => (),
@@ -281,6 +281,7 @@ impl PostgresConnection {
         Ok(PostgresStatement {
             conn: self,
             name: stmt_name,
+            param_types: param_types,
             next_portal_id: Cell::new(0)
         })
     }
@@ -362,6 +363,7 @@ impl<'self> PostgresTransaction<'self> {
 pub struct PostgresStatement<'self> {
     priv conn: &'self PostgresConnection,
     priv name: ~str,
+    priv param_types: ~[Oid],
     priv next_portal_id: Cell<uint>
 }
 
@@ -387,9 +389,14 @@ impl<'self> Drop for PostgresStatement<'self> {
 impl<'self> PostgresStatement<'self> {
     fn execute(&self, portal_name: &str, params: &[&ToSql])
                -> Option<PostgresDbError> {
-        let formats = [];
-        let values: ~[Option<~[u8]>] = params.iter().map(|val| val.to_sql())
-                .collect();
+        let mut formats = ~[];
+        let mut values = ~[];
+        for (&param, &ty) in params.iter().zip(self.param_types.iter()) {
+            let (format, value) = param.to_sql(ty);
+            formats.push(format as i16);
+            values.push(value);
+        };
+
         let result_formats = [];
 
         self.conn.write_message(&Bind {

src/message.rs

@@ -6,6 +6,8 @@ use std::rt::io::mem::{MemWriter, MemReader};
 use std::sys;
 use std::vec;
 
+use types::Oid;
+
 pub static PROTOCOL_VERSION: i32 = 0x0003_0000;
 
 #[deriving(ToStr)]
@@ -36,7 +38,7 @@ pub enum BackendMessage {
         fields: ~[(u8, ~str)]
     },
     ParameterDescription {
-        types: ~[i32]
+        types: ~[Oid]
     },
     ParameterStatus {
         parameter: ~str,
@@ -54,9 +56,9 @@ pub enum BackendMessage {
 #[deriving(ToStr)]
 pub struct RowDescriptionEntry {
     name: ~str,
-    table_oid: i32,
+    table_oid: Oid,
     column_id: i16,
-    type_oid: i32,
+    type_oid: Oid,
     type_size: i16,
     type_modifier: i32,
     format: i16

src/types.rs

@@ -1,5 +1,12 @@
 use std::str;
 
+pub type Oid = i32;
+
+pub enum Format {
+    Text = 0,
+    Binary = 1
+}
+
 pub trait FromSql {
     fn from_sql(raw: &Option<~[u8]>) -> Self;
 }
@@ -69,14 +76,14 @@ impl FromSql for Option<~str> {
 from_option_impl!(~str)
 
 pub trait ToSql {
-    fn to_sql(&self) -> Option<~[u8]>;
+    fn to_sql(&self, ty: Oid) -> (Format, Option<~[u8]>);
 }
 
 macro_rules! to_str_impl(
     ($t:ty) => (
         impl ToSql for $t {
-            fn to_sql(&self) -> Option<~[u8]> {
-                Some(self.to_str().into_bytes())
+            fn to_sql(&self, _ty: Oid) -> (Format, Option<~[u8]>) {
+                (Text, Some(self.to_str().into_bytes()))
             }
         }
     )
@@ -85,9 +92,10 @@ macro_rules! to_str_impl(
 macro_rules! to_option_impl(
     ($t:ty) => (
         impl ToSql for Option<$t> {
-            fn to_sql(&self) -> Option<~[u8]> {
-                do self.chain |val| {
-                    val.to_sql()
+            fn to_sql(&self, ty: Oid) -> (Format, Option<~[u8]>) {
+                match *self {
+                    None => (Text, None),
+                    Some(val) => val.to_sql(ty)
                 }
             }
         }
@@ -122,23 +130,25 @@ to_str_impl!(f64)
 to_option_impl!(f64)
 
 impl<'self> ToSql for &'self str {
-    fn to_sql(&self) -> Option<~[u8]> {
-        Some(self.as_bytes().to_owned())
+    fn to_sql(&self, _ty: Oid) -> (Format, Option<~[u8]>) {
+        (Text, Some(self.as_bytes().to_owned()))
     }
 }
 
 impl ToSql for Option<~str> {
-    fn to_sql(&self) -> Option<~[u8]> {
-        do self.chain_ref |val| {
-            val.to_sql()
+    fn to_sql(&self, ty: Oid) -> (Format, Option<~[u8]>) {
+        match *self {
+            None => (Text, None),
+            Some(ref val) => val.to_sql(ty)
         }
     }
 }
 
 impl<'self> ToSql for Option<&'self str> {
-    fn to_sql(&self) -> Option<~[u8]> {
-        do self.chain |val| {
-            val.to_sql()
+    fn to_sql(&self, ty: Oid) -> (Format, Option<~[u8]>) {
+        match *self {
+            None => (Text, None),
+            Some(val) => val.to_sql(ty)
         }
     }
 }