rdo-postgres 0.0.6 → 0.0.7

data/spec/postgres/array/timestamp_tz_spec.rb

@@ -0,0 +1,80 @@
+require "spec_helper"
+
+describe RDO::Postgres::Array::TimestampTZ do
+  it "is a kind of ::Array" do
+    RDO::Postgres::Array::TimestampTZ.new.should be_a_kind_of(::Array)
+  end
+
+  describe "#to_s" do
+    context "with an empty array" do
+      let(:arr) { RDO::Postgres::Array::TimestampTZ[] }
+
+      it "returns {}" do
+        arr.to_s.should == '{}'
+      end
+    end
+
+    context "with an array of DateTimes" do
+      let(:arr) { RDO::Postgres::Array::TimestampTZ[
+        DateTime.new(2012, 9, 22, 5, 43, 2, "-07:00"),
+        DateTime.new(1983, 5, 3, 15, 0, 1, "+10:00")
+      ] }
+
+      it "formats the times in quotes" do
+        arr.to_s.should == %Q[{"#{DateTime.new(2012, 9, 22, 5, 43, 2, "-07:00")}","#{DateTime.new(1983, 5, 3, 15, 0, 1, "+10:00")}"}]
+      end
+    end
+
+    context "with an array containing nil" do
+      let(:arr) { RDO::Postgres::Array::TimestampTZ[nil, DateTime.new(1983, 5, 3, 0, 0, 1, "-07:00")] }
+
+      it "uses NULL" do
+        arr.to_s.should == %Q[{NULL,"#{DateTime.new(1983, 5, 3, 0, 0, 1, "-07:00")}"}]
+      end
+    end
+  end
+
+  describe "#to_a" do
+    let(:arr) { RDO::Postgres::Array::TimestampTZ[DateTime.new(2012, 9, 22, 0, 0, 0, "-07:00")] }
+
+    it "returns a core ruby Array" do
+      arr.to_a.class.should == ::Array
+    end
+  end
+
+  describe ".parse" do
+    let(:str) { '{}' }
+    let(:arr) { RDO::Postgres::Array::TimestampTZ.parse(str) }
+
+    it "returns a RDO::Postgres::Array::TimestampTZ" do
+      arr.should be_a_kind_of(RDO::Postgres::Array::TimestampTZ)
+    end
+
+    context "with an empty array string" do
+      let(:str) { '{}' }
+
+      it "returns an empty Array" do
+        arr.should be_empty
+      end
+    end
+
+    context "with an array of timestamps" do
+      let(:str) { '{"2012-09-22 05:34:01 -07:00","1983-05-03 13:59:09 +10:00"}' }
+
+      it "returns an Array of DateTimes" do
+        arr.to_a.should == [
+          DateTime.new(2012, 9, 22, 5, 34, 1, "-07:00"),
+          DateTime.new(1983, 5, 3, 13, 59, 9, "+10:00")
+        ]
+      end
+    end
+
+    context "with an array containing NULL" do
+      let(:str) { '{NULL,"1983-05-03 00:04:05 -07:00"}' }
+
+      it "uses nil as the value" do
+        arr.to_a.should == [nil, DateTime.new(1983, 5, 3, 0, 4, 5, "-07:00")]
+      end
+    end
+  end
+end

data/spec/postgres/array_spec.rb

@@ -0,0 +1,122 @@
+require "spec_helper"
+
+describe RDO::Postgres::Array do
+  it "is a kind of ::Array" do
+    RDO::Postgres::Array.new.should be_a_kind_of(::Array)
+  end
+
+  describe "#to_s" do
+    context "with an empty array" do
+      let(:arr) { RDO::Postgres::Array[] }
+
+      it "returns {}" do
+        arr.to_s.should == '{}'
+      end
+    end
+
+    context "with an array of Strings" do
+      let(:arr) { RDO::Postgres::Array["a", "b", "c"] }
+
+      it "wraps double quotes around the elements" do
+        arr.to_s.should == '{"a","b","c"}'
+      end
+
+      context "containing double quotes" do
+        let(:arr) { RDO::Postgres::Array["a", "b and \"c\""] }
+
+        it "escapes the quotes" do
+          arr.to_s.should == '{"a","b and \\"c\\""}'
+        end
+      end
+
+      context "containing backslashes" do
+        let(:arr) { RDO::Postgres::Array["a", "b and \\c"] }
+
+        it "escapes the backslashes" do
+          arr.to_s.should == '{"a","b and \\\\c"}'
+        end
+      end
+    end
+
+    context "with an array containing nil" do
+      let(:arr) { RDO::Postgres::Array[nil, nil, "c"] }
+
+      it "uses NULL" do
+        arr.to_s.should == '{NULL,NULL,"c"}'
+      end
+    end
+
+    context "with an array containing non-Strings" do
+      let(:arr) { RDO::Postgres::Array[42, 7] }
+
+      it "converts the objects to Strings" do
+        arr.to_s.should == '{"42","7"}'
+      end
+    end
+  end
+
+  describe "#to_a" do
+    let(:arr) { RDO::Postgres::Array[1, 2, 3] }
+
+    it "returns a core ruby Array" do
+      arr.to_a.class.should == ::Array
+    end
+  end
+
+  describe ".parse" do
+    let(:str) { '{}' }
+    let(:arr) { RDO::Postgres::Array.parse(str) }
+
+    it "returns a RDO::Postgres::Array" do
+      arr.should be_a_kind_of(RDO::Postgres::Array)
+    end
+
+    context "with an empty array string" do
+      let(:str) { '{}' }
+
+      it "returns an empty Array" do
+        arr.should be_empty
+      end
+    end
+
+    context "with an array of unquoted strings" do
+      let(:str) { '{a,b,c}' }
+
+      it "returns an Array of Strings" do
+        arr.to_a.should == ["a", "b", "c"]
+      end
+    end
+
+    context "with an array of quoted strings" do
+      let(:str) { '{"a b","c d","e f"}' }
+
+      it "returns an Array of Strings" do
+        arr.to_a.should == ["a b", "c d", "e f"]
+      end
+
+      context "containing double quotes" do
+        let(:str) { '{"a \\"b\\"","\\"c\\" d"}' }
+
+        it "returns an Array of Strings" do
+          arr.to_a.should == ['a "b"', '"c" d']
+        end
+      end
+
+      context "containing backslashes" do
+        let(:str) { '{"a \\\\b","\\\\c d"}' }
+
+        it "returns an Array of Strings" do
+          arr.to_a.should == ["a \\b", "\\c d"]
+        end
+      end
+    end
+
+    context "with an array containing NULL" do
+      let(:str) { '{NULL,NULL,"c"}' }
+
+      it "uses nil as the value" do
+        arr.to_a.should == [nil, nil, "c"]
+      end
+    end
+  end
+end

data/spec/postgres/bind_params_spec.rb

@@ -688,6 +688,196 @@ describe RDO::Postgres::Driver, "bind parameter support" do
     end
   end
 
+  describe "Array param" do
+    context "against a text[] field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, words text[])" }
+      let(:tuple) do
+        connection.execute("INSERT INTO test (words) VALUES (?) RETURNING *", ["apple", "orange"]).first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, words: ["apple", "orange"]}
+      end
+
+      context "with embeddded quotes" do
+        let(:tuple) do
+          connection.execute("INSERT INTO test (words) VALUES (?) RETURNING *", ['"apple"']).first
+        end
+
+        it "is inferred correctly" do
+          tuple.should == {id: 1, words: ['"apple"']}
+        end
+      end
+
+      context "with embeddded backslashes" do
+        let(:tuple) do
+          connection.execute("INSERT INTO test (words) VALUES (?) RETURNING *", ['\\apple']).first
+        end
+
+        it "is inferred correctly" do
+          tuple.should == {id: 1, words: ['\\apple']}
+        end
+      end
+
+      context "with embedded nils" do
+        let(:tuple) do
+          connection.execute("INSERT INTO test (words) VALUES (?) RETURNING *", ["apple", nil]).first
+        end
+
+        it "is inferred correctly" do
+          tuple.should == {id: 1, words: ["apple", nil]}
+        end
+      end
+
+      context "with embedded new lines" do
+        let(:tuple) do
+          connection.execute("INSERT INTO test (words) VALUES (?) RETURNING *", ["apple\norange"]).first
+        end
+
+        it "is inferred correctly" do
+          tuple.should == {id: 1, words: ["apple\norange"]}
+        end
+      end
+    end
+
+    context "against an integer[] field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, days integer[])" }
+      let(:tuple) do
+        connection.execute("INSERT INTO test (days) VALUES (?) RETURNING *", [4, 11]).first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, days: [4, 11]}
+      end
+
+      context "with embedded nils" do
+        let(:tuple) do
+          connection.execute("INSERT INTO test (days) VALUES (?) RETURNING *", [4, nil]).first
+        end
+
+        it "is inferred correctly" do
+          tuple.should == {id: 1, days: [4, nil]}
+        end
+      end
+    end
+
+    context "against an numeric[] field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, prices numeric[])" }
+      let(:tuple) do
+        connection.execute(
+          "INSERT INTO test (prices) VALUES (?) RETURNING *",
+          [BigDecimal("17.45"), BigDecimal("23.72")]).first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, prices: [BigDecimal("17.45"), BigDecimal("23.72")]}
+      end
+    end
+
+    context "against an boolean[] field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, truths boolean[])" }
+      let(:tuple) do
+        connection.execute(
+          "INSERT INTO test (truths) VALUES (?) RETURNING *",
+          [false, true]
+        ).first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, truths: [false, true]}
+      end
+
+      context "with embedded nils" do
+        let(:tuple) do
+          connection.execute(
+            "INSERT INTO test (truths) VALUES (?) RETURNING *",
+            [false, nil]
+          ).first
+        end
+
+        it "is inferred correctly" do
+          tuple.should == {id: 1, truths: [false, nil]}
+        end
+      end
+    end
+
+    context "against an bytea[] field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, salts bytea[])" }
+      let(:tuple) do
+        connection.execute(
+          "INSERT INTO test (salts) VALUES (?) RETURNING *",
+          ["\x00\x11", "\x22\x33"]
+        ).first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, salts: ["\x00\x11", "\x22\x33"]}
+      end
+
+      context "with embedded nils" do
+        let(:tuple) do
+          connection.execute(
+            "INSERT INTO test (salts) VALUES (?) RETURNING *",
+            ["\x00\x11", nil]
+          ).first
+        end
+
+        it "is inferred correctly" do
+          tuple.should == {id: 1, salts: ["\x00\x11", nil]}
+        end
+      end
+    end
+
+    context "against an date[] field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, days date[])" }
+      let(:tuple) do
+        connection.execute(
+          "INSERT INTO test (days) VALUES (?) RETURNING *",
+          [Date.new(2012, 9, 22), Date.new(1983, 5, 3)]).first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, days: [Date.new(2012, 9, 22), Date.new(1983, 5, 3)]}
+      end
+    end
+
+    context "against a timestamp[] field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, times timestamp[])" }
+      let(:tuple) do
+        connection.execute(
+          "INSERT INTO test (times) VALUES (?) RETURNING *",
+          [Time.new(2012, 9, 22, 6, 15, 34), Time.new(1983, 5, 3, 14, 56, 0)]).first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, times: [
+          DateTime.new(2012, 9, 22, 6, 15, 34, DateTime.now.zone),
+          DateTime.new(1983, 5, 3, 14, 56, 0, DateTime.now.zone)
+        ]}
+      end
+    end
+
+    context "against a timestamptz[] field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, times timestamptz[])" }
+      let(:tuple) do
+        connection.execute(
+          "INSERT INTO test (times) VALUES (?) RETURNING *",
+          [
+            DateTime.new(2012, 9, 22, 6, 15, 34, "-07:00"),
+            DateTime.new(1983, 5, 3, 14, 56, 0, "+10:00")
+          ]
+        ).first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, times: [
+          DateTime.new(2012, 9, 22, 6, 15, 34, "-07:00"),
+          DateTime.new(1983, 5, 3, 14, 56, 0, "+10:00")
+        ]}
+      end
+    end
+  end
+
   describe "arbitrary Object param" do
     context "against a text field" do
       let(:value) { Object.new }
@@ -736,7 +926,7 @@ describe RDO::Postgres::Driver, "bind parameter support" do
     end
   end
 
-  describe "when a bind marker is contained in a string literal" do
+  describe "bind markers in a string literals" do
     let(:table) do
       <<-SQL
       CREATE TABLE test (

data/spec/postgres/type_cast_spec.rb

@@ -270,4 +270,227 @@ describe RDO::Postgres::Driver, "type casting" do
       end
     end
   end
+
+  describe "text[] cast" do
+    let(:sql) { "SELECT ARRAY['a', 'b']::text[]" }
+
+    it "returns an Array of Strings" do
+      value.should == ["a", "b"]
+    end
+
+    context "including quotes" do
+      let(:sql) { %q{SELECT ARRAY['a "b"', '"c" d']::text[]} }
+
+      it "returns an Array of Strings" do
+        value.should == ['a "b"', '"c" d']
+      end
+    end
+
+    context "including backslashes" do
+      let(:sql) { %q{SELECT ARRAY['a \\b', '\\c d']::text[]} }
+
+      it "returns an Array of Strings" do
+        value.should == ['a \\b', '\\c d']
+      end
+    end
+
+    context "including NULLs" do
+      let(:sql) { "SELECT ARRAY[NULL, 'b']::text[]" }
+
+      it "returns an Array including nil" do
+        value.should == [nil, "b"]
+      end
+    end
+  end
+
+  describe "char[] cast" do
+    let(:sql) { "SELECT ARRAY['a', 'b']::char(1)[]" }
+
+    it "returns an Array of Strings" do
+      value.should == ["a", "b"]
+    end
+
+    context "including NULLs" do
+      let(:sql) { "SELECT ARRAY[NULL, 'b']::char(1)[]" }
+
+      it "returns an Array including nil" do
+        value.should == [nil, "b"]
+      end
+    end
+  end
+
+  describe "varchar[] cast" do
+    let(:sql) { "SELECT ARRAY['a', 'b']::varchar(16)[]" }
+
+    it "returns an Array of Strings" do
+      value.should == ["a", "b"]
+    end
+
+    context "including NULLs" do
+      let(:sql) { "SELECT ARRAY[NULL, 'b']::varchar(16)[]" }
+
+      it "returns an Array including nil" do
+        value.should == [nil, "b"]
+      end
+    end
+  end
+
+  describe "integer[] cast" do
+    let(:sql) { "SELECT ARRAY[42, 7]::integer[]" }
+
+    it "returns an Array of Fixnums" do
+      value.should == [42, 7]
+    end
+
+    context "using int2[]" do
+      let(:sql) { "SELECT ARRAY[42, 7]::int2[]" }
+
+      it "returns an Array of Fixnums" do
+        value.should == [42, 7]
+      end
+    end
+
+    context "using int4[]" do
+      let(:sql) { "SELECT ARRAY[42, 7]::int4[]" }
+
+      it "returns an Array of Fixnums" do
+        value.should == [42, 7]
+      end
+    end
+
+    context "using int8[]" do
+      let(:sql) { "SELECT ARRAY[42, 7]::int8[]" }
+
+      it "returns an Array of Fixnums" do
+        value.should == [42, 7]
+      end
+    end
+
+    context "including NULLs" do
+      let(:sql) { "SELECT ARRAY[NULL, 7]::integer[]" }
+
+      it "returns an Array including nil" do
+        value.should == [nil, 7]
+      end
+    end
+  end
+
+  describe "float[] cast" do
+    let(:sql) { "SELECT ARRAY[42.6, 7.9]::float[]" }
+
+    it "returns an Array of Floats" do
+      value.should == [42.6, 7.9]
+    end
+
+    context "using float4[]" do
+      let(:sql) { "SELECT ARRAY[42.6, 7.9]::float4[]" }
+
+      it "returns an Array of Floats" do
+        value.should == [42.6, 7.9]
+      end
+    end
+
+    context "including NULLs" do
+      let(:sql) { "SELECT ARRAY[NULL, 7.2]::float[]" }
+
+      it "returns an Array including nil" do
+        value.should == [nil, 7.2]
+      end
+    end
+  end
+
+  describe "numeric[] cast" do
+    let(:sql) { "SELECT ARRAY['123.45', '17.63']::numeric[]" }
+
+    it "returns an Array of BigDecimals" do
+      value.should == [BigDecimal("123.45"), BigDecimal("17.63")]
+    end
+
+    context "including NaN" do
+      let(:sql) { "SELECT ARRAY['NaN', '17.63']::numeric[]" }
+
+      it "returns an Array including NaN" do
+        value[0].should be_nan
+        value[1].should == BigDecimal("17.63")
+      end
+    end
+
+    context "including NULLs" do
+      let(:sql) { "SELECT ARRAY[NULL, '17.63']::numeric[]" }
+
+      it "returns an Array including nil" do
+        value.should == [nil, BigDecimal("17.63")]
+      end
+    end
+  end
+
+  describe "boolean[] cast" do
+    let(:sql) { "SELECT ARRAY['t', 'f']::boolean[]" }
+
+    it "returns an Array of Booleans" do
+      value.should == [true, false]
+    end
+
+    context "including NULLs" do
+      let(:sql) { "SELECT ARRAY[NULL, 't']::boolean[]" }
+
+      it "returns an Array including nil" do
+        value.should == [nil, true]
+      end
+    end
+  end
+
+  describe "bytea[] cast" do
+    let(:sql) { "SELECT ARRAY[decode('001122', 'hex'), decode('445566', 'hex')]::bytea[]" }
+
+    it "returns an Array of Strings" do
+      value.should == ["\x00\x11\x22", "\x44\x55\x66"]
+    end
+
+    context "including NULLs" do
+      let(:sql) { "SELECT ARRAY[NULL, decode('001122', 'hex')]::bytea[]" }
+
+      it "returns an Array including nil" do
+        value.should == [nil, "\x00\x11\x22"]
+      end
+    end
+  end
+
+  describe "date[] cast" do
+    let(:sql) { "SELECT ARRAY['2012-09-22', '1983-05-03']::date[]" }
+
+    it "returns an Array of Dates" do
+      value.should == [Date.new(2012, 9, 22), Date.new(1983, 5, 3)]
+    end
+
+    context "including NULLs" do
+      let(:sql) { "SELECT ARRAY[NULL, '1983-05-03']::date[]" }
+
+      it "returns an Array including nil" do
+        value.should == [nil, Date.new(1983, 5, 3)]
+      end
+    end
+  end
+
+  describe "timestamp[] cast" do
+    let(:sql) { "SELECT ARRAY['2012-09-22 06:57:01', '1983-05-03 13:42:03']::timestamp[]" }
+
+    it "returns an Array of DateTimes" do
+      value.should == [
+        DateTime.new(2012, 9, 22, 6, 57, 1, DateTime.now.zone),
+        DateTime.new(1983, 5, 3, 13, 42, 3, DateTime.now.zone)
+      ]
+    end
+  end
+
+  describe "timestamptz[] cast" do
+    let(:sql) { "SELECT ARRAY['2012-09-22 06:57:01 -07:00', '1983-05-03 13:42:03 +10:00']::timestamptz[]" }
+
+    it "returns an Array of DateTimes" do
+      value.should == [
+        DateTime.new(2012, 9, 22, 6, 57, 1, "-07:00"),
+        DateTime.new(1983, 5, 3, 13, 42, 3, "+10:00")
+      ]
+    end
+  end
 end