sequel_pg 1.2.2 → 1.3.0

data/CHANGELOG

@@ -1,3 +1,9 @@
+=== 1.3.0 (2012-04-02)
+
+* Add major speedup for new Sequel 3.34.0 methods Dataset#to_hash_groups and #select_hash_groups (jeremyevans)
+
+* Handle infinite timestamp values using Database#convert_infinite_timestamps in Sequel 3.34.0 (jeremyevans)
+
 === 1.2.2 (2012-03-09)
 
 * Get microsecond accuracy when using datetime_class = DateTime with 1.8-1.9.2 stdlib date library via Rational (jeremyevans)

data/ext/sequel_pg/sequel_pg.c

@@ -36,6 +36,10 @@
 #define SPG_YIELD_KMV_HASH 7
 #define SPG_YIELD_MKMV_HASH 8
 #define SPG_YIELD_MODEL 9
+#define SPG_YIELD_KV_HASH_GROUPS 10
+#define SPG_YIELD_MKV_HASH_GROUPS 11
+#define SPG_YIELD_KMV_HASH_GROUPS 12
+#define SPG_YIELD_MKMV_HASH_GROUPS 13
 
 static VALUE spg_Sequel;
 static VALUE spg_Blob;
@@ -49,6 +53,7 @@ static VALUE spg_sym_map;
 static VALUE spg_sym_first;
 static VALUE spg_sym_array;
 static VALUE spg_sym_hash;
+static VALUE spg_sym_hash_groups;
 static VALUE spg_sym_model;
 static VALUE spg_sym__sequel_pg_type;
 static VALUE spg_sym__sequel_pg_value;
@@ -72,6 +77,8 @@ static ID spg_id_utc;
 static ID spg_id_utc_offset;
 static ID spg_id_localtime;
 static ID spg_id_new_offset;
+static ID spg_id_convert_infinite_timestamps;
+static ID spg_id_infinite_timestamp_value;
 
 static ID spg_id_call;
 static ID spg_id_get;
@@ -123,6 +130,17 @@ static VALUE spg_date(const char *s) {
   return rb_funcall(spg_Date, spg_id_new, 3, INT2NUM(year), INT2NUM(month), INT2NUM(day));
 }
 
+static VALUE spg_timestamp_error(const char *s, VALUE self) {
+  VALUE db;
+  db = rb_funcall(self, spg_id_db, 0);
+  if(RTEST(rb_funcall(db, spg_id_convert_infinite_timestamps, 0))) {
+    if((strcmp(s, "infinity") == 0) || (strcmp(s, "-infinity") == 0)) {
+      return rb_funcall(db, spg_id_infinite_timestamp_value, 1, rb_tainted_str_new2(s));
+    }
+  }
+  rb_raise(rb_eArgError, "unexpected datetime format");
+}
+
 static VALUE spg_timestamp(const char *s, VALUE self) {
   VALUE dtc, dt, rtz;
   int tz = SPG_NO_TZ;
@@ -140,7 +158,7 @@ static VALUE spg_timestamp(const char *s, VALUE self) {
        	&usec_start, &usec, &usec_stop, 
 	&offset_sign, &offset_hour, &offset_minute);
     if(tokens < 7) {
-      rb_raise(rb_eArgError, "unexpected datetime format");
+      return spg_timestamp_error(s, self);
     }
     usec *= (int) pow(10, (6 - (usec_stop - usec_start)));
   } else {
@@ -152,7 +170,7 @@ static VALUE spg_timestamp(const char *s, VALUE self) {
       min = 0;
       sec = 0;
     } else if (tokens < 6) {
-      rb_raise(rb_eArgError, "unexpected datetime format");
+      return spg_timestamp_error(s, self);
     }
     usec = 0;
   }
@@ -458,21 +476,21 @@ static VALUE spg_yield_hash_rows(VALUE self, VALUE rres, VALUE ignore) {
         type = SPG_YIELD_FIRST;
       } else if (pg_type == spg_sym_array) {
         type = SPG_YIELD_ARRAY;
-      } else if (pg_type == spg_sym_hash && rb_type(pg_value) == T_ARRAY) {
+      } else if ((pg_type == spg_sym_hash || pg_type == spg_sym_hash_groups) && rb_type(pg_value) == T_ARRAY) {
         VALUE pg_value_key, pg_value_value;
         pg_value_key = rb_ary_entry(pg_value, 0);
         pg_value_value = rb_ary_entry(pg_value, 1);
         if (SYMBOL_P(pg_value_key)) {
           if (SYMBOL_P(pg_value_value)) {
-            type = SPG_YIELD_KV_HASH;
+            type = pg_type == spg_sym_hash_groups ? SPG_YIELD_KV_HASH_GROUPS : SPG_YIELD_KV_HASH;
           } else if (rb_type(pg_value_value) == T_ARRAY) {
-            type = SPG_YIELD_KMV_HASH;
+            type = pg_type == spg_sym_hash_groups ? SPG_YIELD_KMV_HASH_GROUPS : SPG_YIELD_KMV_HASH;
           }
         } else if (rb_type(pg_value_key) == T_ARRAY) {
           if (SYMBOL_P(pg_value_value)) {
-            type = SPG_YIELD_MKV_HASH;
+            type = pg_type == spg_sym_hash_groups ? SPG_YIELD_MKV_HASH_GROUPS : SPG_YIELD_MKV_HASH;
           } else if (rb_type(pg_value_value) == T_ARRAY) {
-            type = SPG_YIELD_MKMV_HASH;
+            type = pg_type == spg_sym_hash_groups ? SPG_YIELD_MKMV_HASH_GROUPS : SPG_YIELD_MKMV_HASH;
           }
         }
       } else if (pg_type == spg_sym_model && rb_type(pg_value) == T_CLASS) {
@@ -529,54 +547,114 @@ static VALUE spg_yield_hash_rows(VALUE self, VALUE rres, VALUE ignore) {
       } 
       break;
     case SPG_YIELD_KV_HASH:
+    case SPG_YIELD_KV_HASH_GROUPS:
       /* Hash with single key and single value */
       {
         VALUE k, v;
         h = rb_hash_new();
         k = spg__field_id(rb_ary_entry(pg_value, 0), colsyms, nfields);
         v = spg__field_id(rb_ary_entry(pg_value, 1), colsyms, nfields);
-        for(i=0; i<ntuples; i++) {
-          rb_hash_aset(h, spg__col_value(self, res, i, k, colconvert ENC_INDEX), spg__col_value(self, res, i, v, colconvert ENC_INDEX));
-        } 
+        if(type == SPG_YIELD_KV_HASH) {
+          for(i=0; i<ntuples; i++) {
+            rb_hash_aset(h, spg__col_value(self, res, i, k, colconvert ENC_INDEX), spg__col_value(self, res, i, v, colconvert ENC_INDEX));
+          } 
+        } else {
+          VALUE kv, vv, a;
+          for(i=0; i<ntuples; i++) {
+            kv = spg__col_value(self, res, i, k, colconvert ENC_INDEX);
+            vv = spg__col_value(self, res, i, v, colconvert ENC_INDEX);
+            a = rb_hash_lookup(h, kv);
+            if(!RTEST(a)) {
+              rb_hash_aset(h, kv, rb_ary_new3(1, vv));
+            } else {
+              rb_ary_push(a, vv);
+            }
+          } 
+        }
         rb_yield(h);
       }
       break;
     case SPG_YIELD_MKV_HASH:
+    case SPG_YIELD_MKV_HASH_GROUPS:
       /* Hash with array of keys and single value */
       {
         VALUE k, v;
         h = rb_hash_new();
         k = spg__field_ids(rb_ary_entry(pg_value, 0), colsyms, nfields);
         v = spg__field_id(rb_ary_entry(pg_value, 1), colsyms, nfields);
-        for(i=0; i<ntuples; i++) {
-          rb_hash_aset(h, spg__col_values(self, k, colsyms, nfields, res, i, colconvert ENC_INDEX), spg__col_value(self, res, i, v, colconvert ENC_INDEX));
-        } 
+        if(type == SPG_YIELD_MKV_HASH) {
+          for(i=0; i<ntuples; i++) {
+            rb_hash_aset(h, spg__col_values(self, k, colsyms, nfields, res, i, colconvert ENC_INDEX), spg__col_value(self, res, i, v, colconvert ENC_INDEX));
+          } 
+        } else {
+          VALUE kv, vv, a;
+          for(i=0; i<ntuples; i++) {
+            kv = spg__col_values(self, k, colsyms, nfields, res, i, colconvert ENC_INDEX);
+            vv = spg__col_value(self, res, i, v, colconvert ENC_INDEX);
+            a = rb_hash_lookup(h, kv);
+            if(!RTEST(a)) {
+              rb_hash_aset(h, kv, rb_ary_new3(1, vv));
+            } else {
+              rb_ary_push(a, vv);
+            }
+          } 
+        }
         rb_yield(h);
       }
       break;
     case SPG_YIELD_KMV_HASH:
+    case SPG_YIELD_KMV_HASH_GROUPS:
       /* Hash with single keys and array of values */
       {
         VALUE k, v;
         h = rb_hash_new();
         k = spg__field_id(rb_ary_entry(pg_value, 0), colsyms, nfields);
         v = spg__field_ids(rb_ary_entry(pg_value, 1), colsyms, nfields);
-        for(i=0; i<ntuples; i++) {
-          rb_hash_aset(h, spg__col_value(self, res, i, k, colconvert ENC_INDEX), spg__col_values(self, v, colsyms, nfields, res, i, colconvert ENC_INDEX));
-        } 
+        if(type == SPG_YIELD_KMV_HASH) {
+          for(i=0; i<ntuples; i++) {
+            rb_hash_aset(h, spg__col_value(self, res, i, k, colconvert ENC_INDEX), spg__col_values(self, v, colsyms, nfields, res, i, colconvert ENC_INDEX));
+          } 
+        } else {
+          VALUE kv, vv, a;
+          for(i=0; i<ntuples; i++) {
+            kv = spg__col_value(self, res, i, k, colconvert ENC_INDEX);
+            vv = spg__col_values(self, v, colsyms, nfields, res, i, colconvert ENC_INDEX);
+            a = rb_hash_lookup(h, kv);
+            if(!RTEST(a)) {
+              rb_hash_aset(h, kv, rb_ary_new3(1, vv));
+            } else {
+              rb_ary_push(a, vv);
+            }
+          } 
+        }
         rb_yield(h);
       }
       break;
     case SPG_YIELD_MKMV_HASH:
+    case SPG_YIELD_MKMV_HASH_GROUPS:
       /* Hash with array of keys and array of values */
       {
         VALUE k, v;
         h = rb_hash_new();
         k = spg__field_ids(rb_ary_entry(pg_value, 0), colsyms, nfields);
         v = spg__field_ids(rb_ary_entry(pg_value, 1), colsyms, nfields);
-        for(i=0; i<ntuples; i++) {
-          rb_hash_aset(h, spg__col_values(self, k, colsyms, nfields, res, i, colconvert ENC_INDEX), spg__col_values(self, v, colsyms, nfields, res, i, colconvert ENC_INDEX));
-        } 
+        if(type == SPG_YIELD_MKMV_HASH) {
+          for(i=0; i<ntuples; i++) {
+            rb_hash_aset(h, spg__col_values(self, k, colsyms, nfields, res, i, colconvert ENC_INDEX), spg__col_values(self, v, colsyms, nfields, res, i, colconvert ENC_INDEX));
+          } 
+        } else {
+          VALUE kv, vv, a;
+          for(i=0; i<ntuples; i++) {
+            kv = spg__col_values(self, k, colsyms, nfields, res, i, colconvert ENC_INDEX);
+            vv = spg__col_values(self, v, colsyms, nfields, res, i, colconvert ENC_INDEX);
+            a = rb_hash_lookup(h, kv);
+            if(!RTEST(a)) {
+              rb_hash_aset(h, kv, rb_ary_new3(1, vv));
+            } else {
+              rb_ary_push(a, vv);
+            }
+          } 
+        }
         rb_yield(h);
       }
       break;
@@ -615,6 +693,8 @@ void Init_sequel_pg(void) {
   spg_id_utc_offset = rb_intern("utc_offset");
   spg_id_localtime = rb_intern("localtime");
   spg_id_new_offset = rb_intern("new_offset");
+  spg_id_convert_infinite_timestamps = rb_intern("convert_infinite_timestamps");
+  spg_id_infinite_timestamp_value = rb_intern("infinite_timestamp_value");
 
   spg_id_call = rb_intern("call");
   spg_id_get = rb_intern("[]");
@@ -634,6 +714,7 @@ void Init_sequel_pg(void) {
   spg_sym_first = ID2SYM(rb_intern("first"));
   spg_sym_array = ID2SYM(rb_intern("array"));
   spg_sym_hash = ID2SYM(rb_intern("hash"));
+  spg_sym_hash_groups = ID2SYM(rb_intern("hash_groups"));
   spg_sym_model = ID2SYM(rb_intern("model"));
   spg_sym__sequel_pg_type = ID2SYM(rb_intern("_sequel_pg_type"));
   spg_sym__sequel_pg_value = ID2SYM(rb_intern("_sequel_pg_value"));

data/lib/sequel_pg/sequel_pg.rb

@@ -40,6 +40,15 @@ class Sequel::Postgres::Dataset
     end
   end
 
+  # In the case where both arguments given, use an optimized version.
+  def to_hash_groups(key_column, value_column = nil)
+    if value_column
+      clone(:_sequel_pg_type=>:hash_groups, :_sequel_pg_value=>[key_column, value_column]).fetch_rows(sql){|s| return s}
+    else
+      super
+    end
+  end
+
   # If model loads are being optimized and this is a model load, use the optimized
   # version.
   def each

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sequel_pg
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 1.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-09 00:00:00.000000000 Z
+date: 2012-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
-  requirement: &4298956700 !ruby/object:Gem::Requirement
+  requirement: &4390944760 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: 0.8.0
   type: :runtime
   prerelease: false
-  version_requirements: *4298956700
+  version_requirements: *4390944760
 - !ruby/object:Gem::Dependency
   name: sequel
-  requirement: &4298956220 !ruby/object:Gem::Requirement
+  requirement: &4414168760 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,7 +32,7 @@ dependencies:
         version: 3.29.0
   type: :runtime
   prerelease: false
-  version_requirements: *4298956220
+  version_requirements: *4414168760
 description: ! 'sequel_pg overwrites the inner loop of the Sequel postgres
 
   adapter row fetching code with a C version.  The C version