Support FLOAT4[]

Author: sfackler

README.md

@@ -266,6 +266,10 @@ types. The driver currently supports the following conversions:
             <td>types::array::ArrayBase&lt;Option&lt;i64&gt;&gt;</td>
             <td>INT8[], INT8[][], ...</td>
         </tr>
+        <tr>
+            <td>types::array::ArrayBase&lt;Option&lt;f32&gt;&gt;</td>
+            <td>FLOAT4[], FLOAT4[][], ...</td>
+        </tr>
         <tr>
             <td>std::hashmap::HashMap&lt;~str, Option&lt;~str&gt;&gt;</td>
             <td>HSTORE</td>

test.rs

@@ -223,10 +223,10 @@ fn test_result_descriptions() {
                 ResultDescription { name: ~"b", ty: PgVarchar}]);
 }
 
-fn test_type<T: Eq+FromSql+ToSql>(sql_type: &str, checks: &[(T, &str)]) {
+fn test_type<T: Eq+FromSql+ToSql, S: Str>(sql_type: &str, checks: &[(T, S)]) {
     let conn = PostgresConnection::connect("postgres://postgres@localhost", &NoSsl);
     for &(ref val, ref repr) in checks.iter() {
-        let stmt = conn.prepare("SELECT " + *repr + "::" + sql_type);
+        let stmt = conn.prepare(format!("SELECT {:s}::{}", *repr, sql_type));
         let result = stmt.query([]).next().unwrap()[1];
         assert_eq!(val, &result);
 
@@ -381,10 +381,7 @@ macro_rules! test_range(
                       "'(" + $low_str + "," + $high_str + ")'"),
                      (Some(Range::empty()), ~"'empty'"),
                      (None, ~"NULL")];
-        let test_refs: ~[(Option<Range<$t>>, &str)] = tests.iter()
-                .map(|&(ref val, ref s)| { (val.clone(), s.as_slice()) })
-                .collect();
-        test_type($name, test_refs);
+        test_type($name, tests);
     })
 )
 
@@ -421,30 +418,33 @@ fn test_tstzrange_params() {
     test_timespec_range_params("TSTZRANGE");
 }
 
+macro_rules! test_array_params(
+    ($name:expr, $v1:expr, $s1:expr, $v2:expr, $s2:expr, $v3:expr, $s3:expr) => ({
+        let tests = [(Some(ArrayBase::from_vec(~[Some($v1), Some($v2), None], 1)),
+                      "'{" + $s1 + "," + $s2 + ",NULL}'"),
+                     (None, ~"NULL")];
+        test_type($name + "[]", tests);
+        let mut a = ArrayBase::from_vec(~[Some($v1), Some($v2)], 0);
+        a.wrap(-1);
+        a.push_move(ArrayBase::from_vec(~[None, Some($v3)], 0));
+        let tests = [(Some(a), "'[-1:0][0:1]={{" + $s1 + "," + $s2 + "},{NULL," + $s3 + "}}'")];
+        test_type($name + "[][]", tests);
+    })
+)
+
 #[test]
 fn test_int4array_params() {
-    test_type("INT4[]",
-              [(Some(ArrayBase::from_vec(~[Some(0i32), Some(1), None], 1)),
-                "'{0,1,NULL}'"),
-               (None, "NULL")]);
-    let mut a = ArrayBase::from_vec(~[Some(0i32), Some(1)], 0);
-    a.wrap(-1);
-    a.push_move(ArrayBase::from_vec(~[None, Some(3)], 0));
-    test_type("INT4[][]",
-              [(Some(a), "'[-1:0][0:1]={{0,1},{NULL,3}}'")]);
+    test_array_params!("INT4", 0i32, "0", 1i32, "1", 2i32, "2");
 }
 
 #[test]
 fn test_int8array_params() {
-    test_type("INT8[]",
-              [(Some(ArrayBase::from_vec(~[Some(0i64), Some(1), None], 1)),
-                "'{0,1,NULL}'"),
-               (None, "NULL")]);
-    let mut a = ArrayBase::from_vec(~[Some(0i64), Some(1)], 0);
-    a.wrap(-1);
-    a.push_move(ArrayBase::from_vec(~[None, Some(3)], 0));
-    test_type("INT8[][]",
-              [(Some(a), "'[-1:0][0:1]={{0,1},{NULL,3}}'")]);
+    test_array_params!("INT8", 0i64, "0", 1i64, "1", 2i64, "2");
+}
+
+#[test]
+fn test_float4array_params() {
+    test_array_params!("FLOAT4", 0f32, "0", 1.5f32, "1.5", 0.009f32, ".009");
 }
 
 #[test]
@@ -518,7 +518,7 @@ fn test_get_named() {
     let stmt = conn.prepare("SELECT 10::INT as val");
     let result = stmt.query([]);
 
-    assert_eq!(~[10i32], result.map(|row| { row["val"] }).collect());
+    assert_eq!(~[10i32], result.map(|row| row["val"]).collect());
 }
 
 #[test]
@@ -610,7 +610,7 @@ fn test_cancel_query() {
     do spawn {
         timer::sleep(500);
         assert!(lib::cancel_query("postgres://postgres@localhost", &NoSsl,
-                                    cancel_data).is_none());
+                                  cancel_data).is_none());
     }
 
     match conn.try_update("SELECT pg_sleep(10)", []) {

types/mod.rs

@@ -35,6 +35,7 @@ static FLOAT4OID: Oid = 700;
 static FLOAT8OID: Oid = 701;
 static INT4ARRAYOID: Oid = 1007;
 static INT8ARRAYOID: Oid = 1016;
+static FLOAT4ARRAYOID: Oid = 1021;
 static BPCHAROID: Oid = 1042;
 static VARCHAROID: Oid = 1043;
 static TIMESTAMPOID: Oid = 1114;
@@ -84,6 +85,8 @@ pub enum PostgresType {
     PgInt4Array,
     /// INT8[]
     PgInt8Array,
+    /// FLOAT4[]
+    PgFloat4Array,
     /// TIMESTAMP
     PgTimestamp,
     /// TIMESTAMP WITH TIME ZONE
@@ -127,6 +130,7 @@ impl PostgresType {
             FLOAT8OID => PgFloat8,
             INT4ARRAYOID => PgInt4Array,
             INT8ARRAYOID => PgInt8Array,
+            FLOAT4ARRAYOID => PgFloat4Array,
             TIMESTAMPOID => PgTimestamp,
             TIMESTAMPZOID => PgTimestampZ,
             BPCHAROID => PgCharN,
@@ -196,6 +200,7 @@ macro_rules! raw_from_impl(
 
 raw_from_impl!(i32, read_be_i32)
 raw_from_impl!(i64, read_be_i64)
+raw_from_impl!(f32, read_be_f32)
 
 impl RawFromSql for Timespec {
     fn raw_from_sql<R: Reader>(raw: &mut R) -> Timespec {
@@ -260,13 +265,13 @@ from_raw_from_impl!(PgInt4, i32)
 from_option_impl!(i32)
 from_raw_from_impl!(PgInt8, i64)
 from_option_impl!(i64)
+from_raw_from_impl!(PgFloat4, f32)
+from_option_impl!(f32)
 
 from_conversions_impl!(PgChar, i8, read_i8)
 from_option_impl!(i8)
 from_conversions_impl!(PgInt2, i16, read_be_i16)
 from_option_impl!(i16)
-from_conversions_impl!(PgFloat4, f32, read_be_f32)
-from_option_impl!(f32)
 from_conversions_impl!(PgFloat8, f64, read_be_f64)
 from_option_impl!(f64)
 
@@ -381,6 +386,9 @@ from_option_impl!(ArrayBase<Option<i32>>)
 from_array_impl!(PgInt8Array, i64)
 from_option_impl!(ArrayBase<Option<i64>>)
 
+from_array_impl!(PgFloat4Array, f32)
+from_option_impl!(ArrayBase<Option<f32>>)
+
 from_map_impl!(PgUnknownType { name: ~"hstore", .. },
                HashMap<~str, Option<~str>>, |buf| {
     let mut rdr = BufReader::new(buf.as_slice());
@@ -440,6 +448,7 @@ macro_rules! raw_to_impl(
 
 raw_to_impl!(i32, write_be_i32)
 raw_to_impl!(i64, write_be_i64)
+raw_to_impl!(f32, write_be_f32)
 
 impl RawToSql for Timespec {
     fn raw_to_sql<W: Writer>(&self, w: &mut W) {
@@ -523,13 +532,13 @@ to_raw_to_impl!(PgInt4, i32)
 to_option_impl!(PgInt4, i32)
 to_raw_to_impl!(PgInt8, i64)
 to_option_impl!(PgInt8, i64)
+to_raw_to_impl!(PgFloat4, f32)
+to_option_impl!(PgFloat4, f32)
 
 to_conversions_impl!(PgChar, i8, write_i8)
 to_option_impl!(PgChar, i8)
 to_conversions_impl!(PgInt2, i16, write_be_i16)
 to_option_impl!(PgInt2, i16)
-to_conversions_impl!(PgFloat4, f32, write_be_f32)
-to_option_impl!(PgFloat4, f32)
 to_conversions_impl!(PgFloat8, f64, write_be_f64)
 to_option_impl!(PgFloat8, f64)
 
@@ -683,6 +692,9 @@ to_option_impl!(PgInt4Array, ArrayBase<Option<i32>>)
 to_array_impl!(PgInt8Array, INT8OID, i64)
 to_option_impl!(PgInt8Array, ArrayBase<Option<i64>>)
 
+to_array_impl!(PgFloat4Array, FLOAT4OID, f32)
+to_option_impl!(PgFloat4Array, ArrayBase<Option<f32>>)
+
 impl<'self> ToSql for HashMap<~str, Option<~str>> {
     fn to_sql(&self, ty: &PostgresType) -> (Format, Option<~[u8]>) {
         check_types!(PgUnknownType { name: ~"hstore", .. }, ty)