rdo-postgres 0.0.7 → 0.0.8

data/README.md

@@ -73,9 +73,8 @@ currently mapped types are:
   - TIMESTAMP -> DateTime (in the system time zone)
   - TIMESTAMPTZ -> DateTime (in the specified time zone)
 
-All 1-dimensional Arrays of the above listed are also available. Support for
-multi-dimensional Arrays is planned immediately. Support for custom-typed
-Arrays is coming.
+All **n-dimensional Arrays** of the above listed **are supported**. Support
+for custom-typed Arrays is coming.
 
 ### Bind parameters support
 

data/ext/rdo_postgres/arrays.c

@@ -11,10 +11,129 @@
 #include <ruby.h>
 #include <libpq-fe.h>
 
+/** Use to represent state information during a parse */
+typedef struct {
+  int     encoding;
+  VALUE   wrapper;
+  VALUE   ary;
+  char  * ptr;
+  char  * buf;
+} RDOPostgresArrayParseContext;
+
+/** Forward-declaration of RDO::Postgres::Array.parse */
+static VALUE rdo_postgres_array_parse(VALUE self, VALUE str);
+
+/** Push a sub-array onto the stack */
+static void rdo_postgres_array_parse_subarray(VALUE self,
+    RDOPostgresArrayParseContext * ctx) {
+
+  rb_ary_push(ctx->ary,
+      rdo_postgres_array_parse(self,
+        RDO_STRING(ctx->buf, ctx->ptr - ctx->buf, ctx->encoding)));
+}
+
+/** Push a value onto the stack */
+static void rdo_postgres_array_parse_value(VALUE self,
+    RDOPostgresArrayParseContext * ctx) {
+
+  rb_ary_push(ctx->ary,
+      rb_funcall(ctx->wrapper,
+        rb_intern("parse_value_or_null"), 1,
+        RDO_STRING(ctx->buf, ctx->ptr - ctx->buf, ctx->encoding)));
+}
+
+/** Parse the given PostgreSQL formatted array String into an Array */
+static VALUE rdo_postgres_array_parse(VALUE self, VALUE str) {
+  Check_Type(str, T_STRING);
+
+  RDOPostgresArrayParseContext ctx = {
+    .encoding = rb_enc_get_index(str),
+    .wrapper  = rb_funcall(self, rb_intern("new"), 0),
+    .ary      = rb_ary_new(),
+    .buf      = malloc(sizeof(char) * RSTRING_LEN(str)),
+    .ptr      = NULL
+  };
+
+  ctx.ptr = ctx.buf;
+
+  char * cstr   = RSTRING_PTR(str);
+  char * s      = cstr;
+  int    braces = 0;
+  int    quotes = 0;
+
+  for (; *s; ++s) {
+    switch (*s) {
+      case '{':
+        if (quotes) {
+          *(ctx.ptr++) = *s;
+          break;
+        }
+
+        if (braces) // nested brace
+          *(ctx.ptr++) = *s;
+        ++braces;
+        break;
+
+      case '}':
+        if (quotes) {
+          *(ctx.ptr++) = *s;
+          break;
+        }
+
+        --braces;
+        if (braces) {
+          *(ctx.ptr++) = *s;
+          if (braces == 1) { // child
+            rdo_postgres_array_parse_subarray(self, &ctx);
+            ctx.ptr = ctx.buf;
+          }
+        } else {
+          if (ctx.ptr != ctx.buf) { // not empty braces
+            rdo_postgres_array_parse_value(self, &ctx);
+            ctx.ptr = ctx.buf;
+          }
+        }
+        break;
+
+      case '"':
+        quotes = !quotes; // jump in and out of quotes
+        *(ctx.ptr++) = *s;
+        break;
+
+      case '\\':
+        *(ctx.ptr++) = *(s++); // swallow anything after escape
+        *(ctx.ptr++) = *s;
+        break;
+
+      case ',':
+        if (quotes) {
+          *(ctx.ptr++) = *s;
+          break;
+        }
+
+        if (braces > 1) { // still in child
+          *(ctx.ptr++) = *s;
+        } else {
+          if (ctx.ptr != ctx.buf) { // not an outer array
+            rdo_postgres_array_parse_value(self, &ctx);
+            ctx.ptr = ctx.buf;
+          }
+        }
+        break;
+
+      default:
+        *(ctx.ptr++) = *s;
+    }
+  }
+
+  free(ctx.buf);
+
+  return rb_funcall(ctx.wrapper, rb_intern("replace"), 1, ctx.ary);
+}
+
 /** Parse a bytea string into a binary Ruby String */
 static VALUE rdo_postgres_array_bytea_parse_value(VALUE self, VALUE s) {
-  s = rb_call_super(1, &s);
-  Check_Type(s, T_STRING);
+  Check_Type((s = rb_call_super(1, &s)), T_STRING);
   return rdo_postgres_cast_bytea(RSTRING_PTR(s), RSTRING_LEN(s));
 }
 
@@ -38,8 +157,11 @@ static VALUE rdo_postgres_array_bytea_format_value(VALUE self, VALUE v) {
 
 /** Initialize Array extensions */
 void Init_rdo_postgres_arrays(void) {
+  VALUE cArray      = rb_path2class("RDO::Postgres::Array");
   VALUE cByteaArray = rb_path2class("RDO::Postgres::Array::Bytea");
 
+  rb_define_singleton_method(cArray, "parse", rdo_postgres_array_parse, 1);
+
   rb_define_method(cByteaArray,
       "parse_value", rdo_postgres_array_bytea_parse_value, 1);
 

data/lib/rdo/postgres/array.rb

@@ -21,28 +21,57 @@ module RDO
     #   # => ["John Smith", "Sarah Doe"]
     class Array < ::Array
       class << self
+        # Shortcut for the constructor.
+        #
+        # @param [Object...] *args
+        #   a list of objects to put inside the Array
+        #
+        # @return [Array]
+        #   a newly initialzed Array
+        def [](*args)
+          new(args)
+        end
+
         # Read a PostgreSQL array in its string form.
         #
         # @param [String] str
-        #   an array string from postgresql
+        #   an array string from PostgreSQL
         #
         # @return [Array]
         #   a Ruby Array for this string
         def parse(str)
-          new.tap do |a|
-            a.replace(str[1...-1].split(",").map(&a.method(:parse_value_or_null)))
-          end
+          # defined in ext/rdo_postgres/arrays.c
+        end
+      end
+
+      # Initialize a new Array, coercing any sub-Arrays to the same type.
+      #
+      # @param [Array] arr
+      #   the Array to wrap
+      def initialize(arr = 0)
+        if ::Array === arr
+          super(arr.map{|v| ::Array === v ? self.class.new(v) : v})
+        else
+          super
         end
       end
 
       # Convert the Array to the format used by PostgreSQL.
       #
       # @return [String]
-      #   a postgresql array string
+      #   a PostgreSQL array string
       def to_s
         "{#{map(&method(:format_value_or_null)).join(",")}}"
       end
 
+      # Convert the Array to a standard Ruby Array.
+      #
+      # @return [::Array]
+      #   a Ruby Array
+      def to_a
+        super.map{|v| Array === v ? v.to_a : v}
+      end
+
       # Format an individual element in the Array for building into a String.
       #
       # The default implementation wraps quotes around the element.
@@ -73,7 +102,11 @@ module RDO
       private
 
       def format_value_or_null(v)
-        v.nil? ? "NULL" : format_value(v)
+        case v
+        when nil   then "NULL"
+        when Array then v.to_s
+        else format_value(v)
+        end
       end
 
       def parse_value_or_null(s)

data/lib/rdo/postgres/version.rb

@@ -7,6 +7,6 @@
 
 module RDO
   module Postgres
-    VERSION = "0.0.7"
+    VERSION = "0.0.8"
   end
 end

data/spec/postgres/array_spec.rb

@@ -53,6 +53,14 @@ describe RDO::Postgres::Array do
         arr.to_s.should == '{"42","7"}'
       end
     end
+
+    context "with a multi-dimensional Array" do
+      let(:arr) { RDO::Postgres::Array[["a", "b"], ["c", "d"]] }
+
+      it "formats the inner Arrays" do
+        arr.to_s.should == '{{"a","b"},{"c","d"}}'
+      end
+    end
   end
 
   describe "#to_a" do
@@ -61,6 +69,14 @@ describe RDO::Postgres::Array do
     it "returns a core ruby Array" do
       arr.to_a.class.should == ::Array
     end
+
+    context "with a multidimensional Array" do
+      let(:arr) { RDO::Postgres::Array[[1, 2], [3, 4]] }
+
+      it "converts the inner elements to core Ruby Arrays" do
+        arr.to_a[0].class.should == ::Array
+      end
+    end
   end
 
   describe ".parse" do
@@ -118,5 +134,29 @@ describe RDO::Postgres::Array do
         arr.to_a.should == [nil, nil, "c"]
       end
     end
+
+    context "with a multi-dimensonal array" do
+      let(:str) { '{{a,b},{c,d}}' }
+
+      it "returns an Array of Arrays of Strings" do
+        arr.to_a.should == [["a", "b"], ["c", "d"]]
+      end
+
+      context "containing commas" do
+        let(:str) { '{{"a,b","c,d"},{"e,f","g,h"}}' }
+
+        it "returns an Array of Arrays of Strings" do
+          arr.to_a.should == [["a,b", "c,d"], ["e,f", "g,h"]]
+        end
+      end
+
+      context "containing escaped quotes" do
+        let(:str) { '{{"a \\"b\\"","c \\"d\\""},{"e","f"}}' }
+
+        it "returns an Array of Arrays of Strings" do
+          arr.to_a.should == [['a "b"', 'c "d"'], ["e", "f"]]
+        end
+      end
+    end
   end
 end

data/spec/postgres/bind_params_spec.rb

@@ -738,6 +738,19 @@ describe RDO::Postgres::Driver, "bind parameter support" do
           tuple.should == {id: 1, words: ["apple\norange"]}
         end
       end
+
+      context "multidimensional" do
+        let(:tuple) do
+          connection.execute(
+            "INSERT INTO test (words) VALUES (?) RETURNING *",
+            [['a "b"', "c"], ["d \\ e", "f"]]
+          ).first
+        end
+
+        it "is inferred correctly" do
+          tuple.should == {id: 1, words: [['a "b"', "c"], ["d \\ e", "f"]]}
+        end
+      end
     end
 
     context "against an integer[] field" do
@@ -759,6 +772,19 @@ describe RDO::Postgres::Driver, "bind parameter support" do
           tuple.should == {id: 1, days: [4, nil]}
         end
       end
+
+      context "multidimensional" do
+        let(:tuple) do
+          connection.execute(
+            "INSERT INTO test (days) VALUES (?) RETURNING *",
+            [[4, 12], [9, 29]]
+          ).first
+        end
+
+        it "is inferred correctly" do
+          tuple.should == {id: 1, days: [[4, 12], [9, 29]]}
+        end
+      end
     end
 
     context "against an numeric[] field" do

data/spec/postgres/type_cast_spec.rb

@@ -301,6 +301,14 @@ describe RDO::Postgres::Driver, "type casting" do
         value.should == [nil, "b"]
       end
     end
+
+    context "multidimensional" do
+      let(:sql) { %q{SELECT ARRAY[ARRAY['a "x"', 'b'], ARRAY['c', 'd']]::text[]} }
+
+      it "returns an Array of Arrays of Strings" do
+        value.should == [['a "x"', "b"], ["c", "d"]]
+      end
+    end
   end
 
   describe "char[] cast" do
@@ -373,6 +381,14 @@ describe RDO::Postgres::Driver, "type casting" do
         value.should == [nil, 7]
       end
     end
+
+    context "multidimensional" do
+      let(:sql) { "SELECT ARRAY[ARRAY[42, 7], ARRAY[1, 9]]::integer[]" }
+
+      it "returns an Array of Arrays of Fixnums" do
+        value.should == [[42, 7], [1, 9]]
+      end
+    end
   end
 
   describe "float[] cast" do
@@ -397,6 +413,14 @@ describe RDO::Postgres::Driver, "type casting" do
         value.should == [nil, 7.2]
       end
     end
+
+    context "multidimensional" do
+      let(:sql) { %q{SELECT ARRAY[ARRAY[9.7, 10.1], ARRAY[0.4, 1.2]]::float[]} }
+
+      it "returns an Array of Arrays of Floats" do
+        value.should == [[9.7, 10.1], [0.4, 1.2]]
+      end
+    end
   end
 
   describe "numeric[] cast" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rdo-postgres
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
   prerelease: 
 platform: ruby
 authors: