sequel_pg 1.2.2-x86-mingw32 → 1.3.0-x86-mingw32

data/CHANGELOG

@@ -1,3 +1,11 @@
+=== 1.3.0 (2012-04-02)
+
+* Build Windows version against PostgreSQL 9.1.1, ruby 1.8.7, and ruby 1.9.2 (previously 9.0.1, 1.8.6, and 1.9.1) (jeremyevans)
+
+* 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

@@ -2,12 +2,12 @@
 name: sequel_pg
 version: !ruby/object:Gem::Version 
   hash: 27
-  prerelease: false
+  prerelease: 
   segments: 
   - 1
-  - 2
-  - 2
-  version: 1.2.2
+  - 3
+  - 0
+  version: 1.3.0
 platform: x86-mingw32
 authors: 
 - Jeremy Evans
@@ -15,8 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-11-01 00:00:00 -07:00
-default_executable: 
+date: 2012-03-24 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: pg
@@ -42,12 +41,12 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 115
+        hash: 143
         segments: 
         - 3
-        - 29
+        - 34
         - 0
-        version: 3.29.0
+        version: 3.34.0
   type: :runtime
   version_requirements: *id002
 description: |
@@ -75,7 +74,6 @@ files:
 - lib/sequel_pg/sequel_pg.rb
 - lib/1.8/sequel_pg.so
 - lib/1.9/sequel_pg.so
-has_rdoc: true
 homepage: http://github.com/jeremyevans/sequel_pg
 licenses: []
 
@@ -95,12 +93,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 59
+      hash: 57
       segments: 
       - 1
       - 8
-      - 6
-      version: 1.8.6
+      - 7
+      version: 1.8.7
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
@@ -113,7 +111,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.8.21
 signing_key: 
 specification_version: 3
 summary: Faster SELECTs when using Sequel with pg