sequel_pg 1.1.1 → 1.2.0

data/CHANGELOG

@@ -1,3 +1,15 @@
+=== 1.2.0 (2011-11-01)
+
+* Add optimize_model_load setting to speedup loading of model objects, off by default (jeremyevans)
+
+* Add major speedup to Dataset#map, #to_hash, #select_map, #select_order_map, and #select_hash (jeremyevans)
+
+* Work with the new Database#timezone setting in Sequel 3.29.0 (jeremyevans)
+
+=== 1.1.1 (2011-09-01)
+
+* Work with new Sequel::SQLTime for time columns in Sequel 3.27.0 (jeremyevans)
+
 === 1.1.0 (2011-06-01)
 
 * Work with new Database#conversion_procs method in Sequel 3.24.0 (jeremyevans)

data/README.rdoc

@@ -38,6 +38,31 @@ Here's an example that uses a modified version of swift's benchmarks
   sequel #select    0.090000  2.020000  2.110000  2.246688 46.54m
   sequel_pg #select 0.000000  0.250000  0.250000  0.361999  7.33m
 
+sequel_pg also has code to speed up the map, to_hash, select_hash,
+select_map, and select_order_map Dataset methods, which is on by
+default. It also has code to speed up the loading of model objects,
+which is off by default as it isn't fully compatible.  It doesn't
+handle overriding Model.call, Model#set_values, or
+Model#after_initialize, which may cause problems with the
+following plugins that ship with Sequel:
+
+* class_table_inheritance
+* force_encoding
+* serializiation
+* single_table_interitance
+* typecast_on_load
+* update_primary_key
+
+If you want to extract that last ounce of performance when loading
+model objects and you can live with the limitations, you can
+enable the model optimization via:
+
+  # All datasets
+  DB.optimize_model_load = true
+
+  # Specific dataset
+  Artist.dataset.optimize_model_load = true
+
 == Installing the gem
 
   gem install sequel_pg

data/Rakefile

@@ -5,7 +5,7 @@ CLEAN.include %w'**.rbc rdoc'
 
 desc "Do a full cleaning"
 task :distclean do
-  CLEAN.include %w'tmp pkg sequel_pg*.gem lib'
+  CLEAN.include %w'tmp pkg sequel_pg*.gem lib/*.so'
   Rake::Task[:clean].invoke
 end
 

data/ext/sequel_pg/sequel_pg.c

@@ -7,6 +7,9 @@
 #if defined(HAVE_RUBY_ENCODING_H) && HAVE_RUBY_ENCODING_H
 #define SPG_ENCODING 1
 #include <ruby/encoding.h>
+#define ENC_INDEX ,enc_index
+#else
+#define ENC_INDEX
 #endif
 
 #define SPG_MAX_FIELDS 256
@@ -22,6 +25,17 @@
 #define SPG_APP_LOCAL 4
 #define SPG_APP_UTC 8
 
+#define SPG_YIELD_NORMAL 0
+#define SPG_YIELD_COLUMN 1
+#define SPG_YIELD_COLUMNS 2
+#define SPG_YIELD_FIRST 3
+#define SPG_YIELD_ARRAY 4
+#define SPG_YIELD_KV_HASH 5
+#define SPG_YIELD_MKV_HASH 6
+#define SPG_YIELD_KMV_HASH 7
+#define SPG_YIELD_MKMV_HASH 8
+#define SPG_YIELD_MODEL 9
+
 static VALUE spg_Sequel;
 static VALUE spg_Blob;
 static VALUE spg_BigDecimal;
@@ -30,6 +44,13 @@ static VALUE spg_SQLTime;
 
 static VALUE spg_sym_utc;
 static VALUE spg_sym_local;
+static VALUE spg_sym_map;
+static VALUE spg_sym_first;
+static VALUE spg_sym_array;
+static VALUE spg_sym_hash;
+static VALUE spg_sym_model;
+static VALUE spg_sym__sequel_pg_type;
+static VALUE spg_sym__sequel_pg_value;
 
 static ID spg_id_new;
 static ID spg_id_local;
@@ -39,7 +60,7 @@ static ID spg_id_day;
 static ID spg_id_output_identifier;
 static ID spg_id_datetime_class;
 static ID spg_id_application_timezone;
-static ID spg_id_database_timezone;
+static ID spg_id_timezone;
 static ID spg_id_op_plus;
 static ID spg_id_utc;
 static ID spg_id_utc_offset;
@@ -48,12 +69,14 @@ static ID spg_id_new_offset;
 
 static ID spg_id_call;
 static ID spg_id_get;
+static ID spg_id_opts;
 
 static ID spg_id_db;
 static ID spg_id_conversion_procs;
 
 static ID spg_id_columns;
 static ID spg_id_encoding;
+static ID spg_id_values;
 
 #if SPG_ENCODING
 static int enc_get_index(VALUE val)
@@ -94,7 +117,7 @@ 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(const char *s) {
+static VALUE spg_timestamp(const char *s, VALUE self) {
   VALUE dtc, dt, rtz;
   int tz = SPG_NO_TZ;
   int year, month, day, hour, min, sec, usec, tokens, utc_offset;
@@ -135,7 +158,7 @@ static VALUE spg_timestamp(const char *s) {
 
   /* Get values of datetime_class, database_timezone, and application_timezone */
   dtc = rb_funcall(spg_Sequel, spg_id_datetime_class, 0);
-  rtz = rb_funcall(spg_Sequel, spg_id_database_timezone, 0);
+  rtz = rb_funcall(rb_funcall(self, spg_id_db, 0), spg_id_timezone, 0);
   if (rtz == spg_sym_local) {
     tz += SPG_DB_LOCAL;
   } else if (rtz == spg_sym_utc) {
@@ -234,6 +257,116 @@ static VALUE spg_fetch_rows_set_cols(VALUE self, VALUE ignore) {
   return self;
 }
 
+static VALUE spg__col_value(VALUE self, PGresult *res, long i, long j, VALUE* colconvert
+#ifdef SPG_ENCODING
+, int enc_index
+#endif
+) {
+  char *v;
+  VALUE rv;
+  size_t l;
+
+  if(PQgetisnull(res, i, j)) {
+    rv = Qnil;
+  } else {
+    v = PQgetvalue(res, i, j);
+
+    switch(PQftype(res, j)) {
+      case 16: /* boolean */
+        rv = *v == 't' ? Qtrue : Qfalse;
+        break;
+      case 17: /* bytea */
+        v = (char *)PQunescapeBytea((unsigned char*)v, &l);
+        rv = rb_funcall(spg_Blob, spg_id_new, 1, rb_str_new(v, l));
+        PQfreemem(v);
+        break;
+      case 20: /* integer */
+      case 21:
+      case 22:
+      case 23:
+      case 26:
+        rv = rb_cstr2inum(v, 10);
+        break;
+      case 700: /* float */
+      case 701:
+        rv = rb_float_new(rb_cstr_to_dbl(v, Qfalse));
+        break;
+      case 790: /* numeric */
+      case 1700:
+        rv = rb_funcall(spg_BigDecimal, spg_id_new, 1, rb_str_new(v, PQgetlength(res, i, j)));
+        break;
+      case 1082: /* date */
+        rv = spg_date(v);
+        break;
+      case 1083: /* time */
+      case 1266:
+        rv = spg_time(v);
+        break;
+      case 1114: /* timestamp */
+      case 1184:
+        rv = spg_timestamp(v, self);
+        break;
+      case 18: /* char */
+      case 25: /* text */
+      case 1043: /* varchar*/
+        rv = rb_tainted_str_new(v, PQgetlength(res, i, j));
+#ifdef SPG_ENCODING
+        rb_enc_associate_index(rv, enc_index);
+#endif
+        break;
+      default:
+        rv = rb_tainted_str_new(v, PQgetlength(res, i, j));
+#ifdef SPG_ENCODING
+        rb_enc_associate_index(rv, enc_index);
+#endif
+        if (colconvert[j] != Qnil) {
+          rv = rb_funcall(colconvert[j], spg_id_call, 1, rv); 
+        }
+    }
+  }
+  return rv;
+}
+
+static VALUE spg__col_values(VALUE self, VALUE v, VALUE *colsyms, long nfields, PGresult *res, long i, VALUE *colconvert
+#ifdef SPG_ENCODING
+, int enc_index
+#endif
+) {
+  long j;
+  VALUE cur;
+  long len = RARRAY_LEN(v);
+  VALUE a = rb_ary_new2(len);
+  for (j=0; j<len; j++) {
+    cur = rb_ary_entry(v, j);
+    rb_ary_store(a, j, cur == Qnil ? Qnil : spg__col_value(self, res, i, NUM2LONG(cur), colconvert ENC_INDEX));
+  }
+  return a;
+}
+
+static long spg__field_id(VALUE v, VALUE *colsyms, long nfields) {
+  long j;
+  for (j=0; j<nfields; j++) {
+    if (colsyms[j] == v) {
+      return j;
+    }
+  }
+  return -1;
+}
+
+static VALUE spg__field_ids(VALUE v, VALUE *colsyms, long nfields) {
+  long i;
+  long j;
+  VALUE cur;
+  long len = RARRAY_LEN(v);
+  VALUE pg_columns = rb_ary_new2(len);
+  for (i=0; i<len; i++) {
+    cur = rb_ary_entry(v, i);
+    j = spg__field_id(cur, colsyms, nfields);
+    rb_ary_store(pg_columns, i, j == -1 ? Qnil : LONG2NUM(j));
+  }
+  return pg_columns;
+}
+
 static VALUE spg_yield_hash_rows(VALUE self, VALUE rres, VALUE ignore) {
   PGresult *res;
   VALUE colsyms[SPG_MAX_FIELDS];
@@ -242,10 +375,12 @@ static VALUE spg_yield_hash_rows(VALUE self, VALUE rres, VALUE ignore) {
   long nfields;
   long i;
   long j;
-  VALUE h, rv;
-  size_t l;
-  char * v;
-  VALUE conv_procs = NULL;
+  VALUE h;
+  VALUE conv_procs = 0;
+  VALUE opts;
+  VALUE pg_type;
+  VALUE pg_value;
+  char type = SPG_YIELD_NORMAL;
 
 #ifdef SPG_ENCODING
   int enc_index;
@@ -285,7 +420,7 @@ static VALUE spg_yield_hash_rows(VALUE self, VALUE rres, VALUE ignore) {
         colconvert[j] = Qnil;
         break;
       default:
-        if (conv_procs == NULL) {
+        if (conv_procs == 0) {
           conv_procs = rb_funcall(rb_funcall(self, spg_id_db, 0), spg_id_conversion_procs, 0);
         }
         colconvert[j] = rb_funcall(conv_procs, spg_id_get, 1, INT2NUM(i));
@@ -294,72 +429,157 @@ static VALUE spg_yield_hash_rows(VALUE self, VALUE rres, VALUE ignore) {
   }
   rb_ivar_set(self, spg_id_columns, rb_ary_new4(nfields, colsyms));
 
-  for(i=0; i<ntuples; i++) {
-    h = rb_hash_new();
-    for(j=0; j<nfields; j++) {
-      if(PQgetisnull(res, i, j)) {
-        rv = Qnil;
-      } else {
-        v = PQgetvalue(res, i, j);
-
-        switch(PQftype(res, j)) {
-          case 16: /* boolean */
-            rv = *v == 't' ? Qtrue : Qfalse;
-            break;
-          case 17: /* bytea */
-            v = (char *)PQunescapeBytea((unsigned char*)v, &l);
-            rv = rb_funcall(spg_Blob, spg_id_new, 1, rb_str_new(v, l));
-            PQfreemem(v);
-            break;
-          case 20: /* integer */
-          case 21:
-          case 22:
-          case 23:
-          case 26:
-            rv = rb_cstr2inum(v, 10);
-            break;
-          case 700: /* float */
-          case 701:
-            rv = rb_float_new(rb_cstr_to_dbl(v, Qfalse));
-            break;
-          case 790: /* numeric */
-          case 1700:
-            rv = rb_funcall(spg_BigDecimal, spg_id_new, 1, rb_str_new(v, PQgetlength(res, i, j)));
-            break;
-          case 1082: /* date */
-            rv = spg_date(v);
-            break;
-          case 1083: /* time */
-          case 1266:
-            rv = spg_time(v);
-            break;
-          case 1114: /* timestamp */
-          case 1184:
-            rv = spg_timestamp(v);
-            break;
-          case 18: /* char */
-          case 25: /* text */
-          case 1043: /* varchar*/
-            rv = rb_tainted_str_new(v, PQgetlength(res, i, j));
-#ifdef SPG_ENCODING
-            rb_enc_associate_index(rv, enc_index);
-#endif
-            break;
-          default:
-            rv = rb_tainted_str_new(v, PQgetlength(res, i, j));
-#ifdef SPG_ENCODING
-            rb_enc_associate_index(rv, enc_index);
-#endif
-            if (colconvert[j] != Qnil) {
-              rv = rb_funcall(colconvert[j], spg_id_call, 1, rv); 
-            }
+  opts = rb_funcall(self, spg_id_opts, 0);
+  if (rb_type(opts) == T_HASH) {
+    pg_type = rb_hash_aref(opts, spg_sym__sequel_pg_type);
+    pg_value = rb_hash_aref(opts, spg_sym__sequel_pg_value);
+    if (SYMBOL_P(pg_type)) {
+      if (pg_type == spg_sym_map) {
+        if (SYMBOL_P(pg_value)) {
+          type = SPG_YIELD_COLUMN;
+        } else if (rb_type(pg_value) == T_ARRAY) {
+          type = SPG_YIELD_COLUMNS;
+        }
+      } else if (pg_type == spg_sym_first) {
+        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) {
+        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;
+          } else if (rb_type(pg_value_value) == T_ARRAY) {
+            type = SPG_YIELD_KMV_HASH;
+          }
+        } else if (rb_type(pg_value_key) == T_ARRAY) {
+          if (SYMBOL_P(pg_value_value)) {
+            type = SPG_YIELD_MKV_HASH;
+          } else if (rb_type(pg_value_value) == T_ARRAY) {
+            type = SPG_YIELD_MKMV_HASH;
+          }
         }
+      } else if (pg_type == spg_sym_model && rb_type(pg_value) == T_CLASS) {
+        type = SPG_YIELD_MODEL;
       }
-      rb_hash_aset(h, colsyms[j], rv);
     }
-    rb_yield(h);
   }
-  
+
+  switch(type) {
+    case SPG_YIELD_NORMAL:
+      /* Normal, hash for entire row */
+      for(i=0; i<ntuples; i++) {
+        h = rb_hash_new();
+        for(j=0; j<nfields; j++) {
+          rb_hash_aset(h, colsyms[j], spg__col_value(self, res, i, j, colconvert ENC_INDEX));
+        }
+        rb_yield(h);
+      }
+      break;
+    case SPG_YIELD_COLUMN:
+      /* Single column */
+      j = spg__field_id(pg_value, colsyms, nfields);
+      if (j == -1) {
+        for(i=0; i<ntuples; i++) {
+          rb_yield(Qnil);
+        } 
+      } else {
+        for(i=0; i<ntuples; i++) {
+          rb_yield(spg__col_value(self, res, i, j, colconvert ENC_INDEX));
+        } 
+      }
+      break;
+    case SPG_YIELD_COLUMNS:
+      /* Multiple columns as an array */
+      h = spg__field_ids(pg_value, colsyms, nfields);
+      for(i=0; i<ntuples; i++) {
+        rb_yield(spg__col_values(self, h, colsyms, nfields, res, i, colconvert ENC_INDEX));
+      } 
+      break;
+    case SPG_YIELD_FIRST:
+      /* First column */
+      for(i=0; i<ntuples; i++) {
+        rb_yield(spg__col_value(self, res, i, 0, colconvert ENC_INDEX));
+      } 
+      break;
+    case SPG_YIELD_ARRAY:
+      /* Array of all columns */
+      for(i=0; i<ntuples; i++) {
+        h = rb_ary_new2(nfields);
+        for(j=0; j<nfields; j++) {
+          rb_ary_store(h, j, spg__col_value(self, res, i, j, colconvert ENC_INDEX));
+        }
+        rb_yield(h);
+      } 
+      break;
+    case SPG_YIELD_KV_HASH:
+      /* 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));
+        } 
+        rb_yield(h);
+      }
+      break;
+    case SPG_YIELD_MKV_HASH:
+      /* 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));
+        } 
+        rb_yield(h);
+      }
+      break;
+    case SPG_YIELD_KMV_HASH:
+      /* 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));
+        } 
+        rb_yield(h);
+      }
+      break;
+    case SPG_YIELD_MKMV_HASH:
+      /* 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));
+        } 
+        rb_yield(h);
+      }
+      break;
+    case SPG_YIELD_MODEL:
+      /* Model object for entire row */
+      for(i=0; i<ntuples; i++) {
+        h = rb_hash_new();
+        for(j=0; j<nfields; j++) {
+          rb_hash_aset(h, colsyms[j], spg__col_value(self, res, i, j, colconvert ENC_INDEX));
+        }
+        /* Abuse local variable */
+        pg_type = rb_obj_alloc(pg_value);
+        rb_ivar_set(pg_type, spg_id_values, h);
+        rb_yield(pg_type);
+      }
+      break;
+  }
   return self;
 }
 
@@ -375,7 +595,7 @@ void Init_sequel_pg(void) {
   spg_id_output_identifier = rb_intern("output_identifier");
   spg_id_datetime_class = rb_intern("datetime_class");
   spg_id_application_timezone = rb_intern("application_timezone");
-  spg_id_database_timezone = rb_intern("database_timezone");
+  spg_id_timezone = rb_intern("timezone");
   spg_id_op_plus = rb_intern("+");
   spg_id_utc = rb_intern("utc");
   spg_id_utc_offset = rb_intern("utc_offset");
@@ -385,14 +605,24 @@ void Init_sequel_pg(void) {
   spg_id_call = rb_intern("call");
   spg_id_get = rb_intern("[]");
 
+  spg_id_opts = rb_intern("opts");
+
   spg_id_db = rb_intern("db");
   spg_id_conversion_procs = rb_intern("conversion_procs");
 
   spg_id_columns = rb_intern("@columns");
   spg_id_encoding = rb_intern("@encoding");
+  spg_id_values = rb_intern("@values");
 
   spg_sym_utc = ID2SYM(rb_intern("utc"));
   spg_sym_local = ID2SYM(rb_intern("local"));
+  spg_sym_map = ID2SYM(rb_intern("map"));
+  spg_sym_first = ID2SYM(rb_intern("first"));
+  spg_sym_array = ID2SYM(rb_intern("array"));
+  spg_sym_hash = ID2SYM(rb_intern("hash"));
+  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"));
 
   spg_Sequel = rb_funcall(rb_cObject, cg, 1, rb_str_new2("Sequel"));
   spg_Blob = rb_funcall(rb_funcall(spg_Sequel, cg, 1, rb_str_new2("SQL")), cg, 1, rb_str_new2("Blob")); 
@@ -409,4 +639,6 @@ void Init_sequel_pg(void) {
   c = rb_funcall(spg_Postgres, cg, 1, rb_str_new2("Dataset"));
   rb_define_private_method(c, "yield_hash_rows", spg_yield_hash_rows, 2);
   rb_define_private_method(c, "fetch_rows_set_cols", spg_fetch_rows_set_cols, 1);
+
+  rb_require("sequel_pg/sequel_pg");
 }

data/lib/sequel_pg/sequel_pg.rb

@@ -0,0 +1,76 @@
+# Add speedup for model class creation from dataset
+class Sequel::Postgres::Database
+  # Whether to optimize loads for all model datasets created from this dataset.
+  # Has certain limitations, see the README for details.
+  attr_accessor :optimize_model_load
+end
+
+# Add faster versions of Dataset#map, #to_hash, #select_map, #select_order_map, and #select_hash
+class Sequel::Postgres::Dataset
+  # Set whether to enable optimized model loading for this dataset.
+  attr_writer :optimize_model_load
+
+  # In the case where an argument is given, use an optimized version.
+  def map(sym=nil)
+    if sym
+      if block_given?
+        super
+      else
+        rows = []
+        clone(:_sequel_pg_type=>:map, :_sequel_pg_value=>sym).fetch_rows(sql){|s| rows << s}
+        rows
+      end
+    else
+      super
+    end
+  end
+
+  # If this dataset has turned model loading on or off, use the default value from
+  # the Database object.
+  def optimize_model_load
+    defined?(@optimize_model_load) ? @optimize_model_load : db.optimize_model_load
+  end
+
+  # In the case where both arguments given, use an optimized version.
+  def to_hash(key_column, value_column = nil)
+    if value_column
+      clone(:_sequel_pg_type=>:hash, :_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
+    if (rp = row_proc) && optimize_model_load?
+      clone(:_sequel_pg_type=>:model, :_sequel_pg_value=>rp).fetch_rows(sql, &Proc.new)
+    else
+      super
+    end
+  end
+    
+  protected
+
+  # Always use optimized version
+  def _select_map_multiple(ret_cols)
+    rows = []
+    clone(:_sequel_pg_type=>:array).fetch_rows(sql){|s| rows << s}
+    rows
+  end
+
+  # Always use optimized version
+  def _select_map_single
+    rows = []
+    clone(:_sequel_pg_type=>:first).fetch_rows(sql){|s| rows << s}
+    rows
+  end
+
+  private
+
+  # The model load can only be optimized if it's for a model and it's not a graphed dataset
+  # or using a cursor.
+  def optimize_model_load?
+    (rp = row_proc).is_a?(Class) && (rp < Sequel::Model) && optimize_model_load && !opts[:use_cursor] && !opts[:graph]
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: sequel_pg
 version: !ruby/object:Gem::Version 
-  hash: 17
-  prerelease: false
+  hash: 31
+  prerelease: 
   segments: 
   - 1
-  - 1
-  - 1
-  version: 1.1.1
+  - 2
+  - 0
+  version: 1.2.0
 platform: ruby
 authors: 
 - Jeremy Evans
@@ -15,8 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-01 00:00:00 -07:00
-default_executable: 
+date: 2011-11-01 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: pg
@@ -42,12 +41,12 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 107
+        hash: 115
         segments: 
         - 3
-        - 27
+        - 29
         - 0
-        version: 3.27.0
+        version: 3.29.0
   type: :runtime
   version_requirements: *id002
 description: |
@@ -72,7 +71,7 @@ files:
 - Rakefile
 - ext/sequel_pg/extconf.rb
 - ext/sequel_pg/sequel_pg.c
-has_rdoc: true
+- lib/sequel_pg/sequel_pg.rb
 homepage: http://github.com/jeremyevans/sequel_pg
 licenses: []
 
@@ -110,7 +109,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Faster SELECTs when using Sequel with pg