sequel_pg 1.0.0

data/CHANGELOG

@@ -0,0 +1,3 @@
+=== 1.0.0 
+
+* Initial Public Release

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2010 Jeremy Evans
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/README.rdoc

@@ -0,0 +1,138 @@
+= sequel_pg
+
+sequel_pg overwrites the inner loop of the Sequel postgres adapter
+row fetching code with a C version.  The C version is significantly
+faster (2-6x) than the pure ruby version that Sequel uses by default.
+
+== Real world difference
+
+The speed up that sequel_pg gives you depends on what you are
+selecting, but it should be noticable whenever many rows are selected.
+Here's an example that shows the difference it makes on a couple of
+models:
+
+  $ irb -r model -r benchmark 
+  irb(main):001:0> Track.count
+  => 140854
+  irb(main):002:0> Album.count
+  => 5579
+  irb(main):003:0> puts Benchmark.measure{Track.each{}}
+   10.740000   0.190000  10.930000 ( 11.875343)
+  => nil
+  irb(main):004:0> puts Benchmark.measure{10.times{Album.each{}}}
+    7.920000   0.070000   7.990000 (  8.482130)
+  => nil
+  irb(main):005:0> require '/data/code/sequel_pg/ext/sequel_pg/sequel_pg'
+  => true
+  irb(main):006:0> puts Benchmark.measure{Track.each{}}
+    2.360000   0.400000   2.760000 (  3.723098)
+  => nil
+  irb(main):007:0> puts Benchmark.measure{10.times{Album.each{}}}
+    1.300000   0.190000   1.490000 (  2.001393)
+  => nil
+
+Here's an example that uses a modified version of swift's benchmarks
+(http://github.com/shanna/swift/tree/master/benchmarks/):
+  
+  benchmark         sys       user      total     real     rss
+  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
+
+== Installing the gem
+
+  gem install sequel_pg
+
+The standard gem requires compiling from source, so you need a working
+compiler toolchain.  Since few Windows users have a working compiler
+toolchain, a windows binary gem is available that works on both 1.8
+and 1.9.
+
+== Running the specs
+
+sequel_pg doesn't ship with it's own specs.  It's designed to
+replace a part of Sequel, so it just uses Sequel's specs.
+Specifically, the spec_postgres spec from Sequel.
+
+== Reporting issues/bugs
+
+sequel_pg uses GitHub Issues for tracking issues/bugs:
+
+  http://github.com/jeremyevans/sequel_pg/issues
+
+== Contributing
+
+The source code is on GitHub:
+
+  http://github.com/jeremyevans/sequel_pg
+
+To get a copy:
+
+  git clone git://github.com/jeremyevans/sequel_pg.git
+
+There are only a few requirements, which you should probably
+have before considering use of the library:
+
+* Rake
+* Sequel
+* pg
+* libpq headers and library
+
+== Building
+
+To build the library from a git checkout, after installing the
+requirements:
+
+  rake build
+
+== Platforms Supported
+
+sequel_pg has been tested on the following:
+
+=== Operating Systems/Platforms
+
+* Linux (i386)
+* OpenBSD (amd64, i386)
+* Windows XP (i386)
+
+=== Compiler Versions
+
+* gcc (3.3.5, 4.2.1, 4.4.3)
+
+=== Ruby Versions
+
+* jruby cext branch (compiles but untested and unusable, as pg itself
+  doesn't compile yet)
+* rbx head
+* ruby 1.8.6
+* ruby 1.8.7
+* ruby 1.9.1
+* ruby 1.9.2
+* ruby head
+
+If your platform, compiler version, or ruby version is not listed
+above, please test and send me a report including:
+
+  * Your operating system and platform (e.g. i386, x86_64/amd64)
+  * Your compiler
+  * Your ruby version
+
+== Known Issues
+
+* You must be using the ISO PostgreSQL date format (which is the
+  default).  Using the SQL, POSTGRESQL, or GERMAN date formats will
+  result in incorrect date/timestamp handling. In addition to
+  PostgreSQL defaulting to ISO, Sequel also manually sets the
+  date format to ISO by default, so unless you are overriding that
+  setting (via Sequel::Postgres.use_iso_date_format = false), you
+  should be OK.
+* Adding your own type conversion procs to Sequel::Postgres::PG_TYPES
+  does not have an effect with this plugin, since the type conversion
+  is done in C.
+* The named_timezones plugin does not integrate with sequel_pg, since
+  sequel_pg does it's own timestamp conversions. The :local and :utc
+  settings for database_timestamp and application_timestamp do work,
+  as does setting the datetime_class to DateTime.
+
+== Author
+
+Jeremy Evans <code@jeremyevans.net>

data/Rakefile

@@ -0,0 +1,21 @@
+require "rake"
+require "rake/clean"
+
+CLEAN.include %w'**.rbc rdoc'
+
+desc "Do a full cleaning"
+task :distclean do
+  CLEAN.include %w'tmp pkg sequel_pg*.gem lib'
+  Rake::Task[:clean].invoke
+end
+
+desc "Build the gem"
+task :gem do
+  sh %{gem build sequel_pg.gemspec}
+end
+
+begin
+  require 'rake/extensiontask'
+  Rake::ExtensionTask.new('sequel_pg')
+rescue LoadError
+end

data/ext/sequel_pg/extconf.rb

@@ -0,0 +1,16 @@
+require 'mkmf'
+$CFLAGS << " -Wall " unless RUBY_PLATFORM =~ /solaris/
+dir_config('pg', ENV["POSTGRES_INCLUDE"] || (IO.popen("pg_config --includedir").readline.chomp rescue nil),
+                 ENV["POSTGRES_LIB"]     || (IO.popen("pg_config --libdir").readline.chomp rescue nil))
+
+if enable_config("static-build")
+	# Link against all required libraries for static build, if they are available
+	have_library('gdi32', 'CreateDC') && append_library($libs, 'gdi32')
+	have_library('secur32') && append_library($libs, 'secur32')
+end
+
+if (have_library('pq') || have_library('libpq') || have_library('ms/libpq')) && have_header('libpq-fe.h')
+  create_makefile("sequel_pg")
+else
+  puts 'Could not find PostgreSQL build environment (libraries & headers): Makefile not created'
+end

data/ext/sequel_pg/sequel_pg.c

@@ -0,0 +1,357 @@
+#include <string.h>
+#include <stdio.h>
+#include <math.h>
+#include <libpq-fe.h>
+#include <ruby.h>
+
+#if defined(HAVE_RUBY_ENCODING_H) && HAVE_RUBY_ENCODING_H
+#define SPG_ENCODING 1
+#include <ruby/encoding.h>
+#endif
+
+#define SPG_MAX_FIELDS 256
+#define SPG_MILLISECONDS_PER_DAY 86400000000.0
+#define SPG_MINUTES_PER_DAY 1440.0
+#define SPG_SECONDS_PER_DAY 86400.0
+
+#define SPG_DT_ADD_USEC if (usec != 0) { dt = rb_funcall(dt, spg_id_op_plus, 1, rb_float_new(usec/SPG_MILLISECONDS_PER_DAY)); }
+
+#define SPG_NO_TZ 0
+#define SPG_DB_LOCAL 1
+#define SPG_DB_UTC 2
+#define SPG_APP_LOCAL 4
+#define SPG_APP_UTC 8
+
+static VALUE spg_Sequel;
+static VALUE spg_Blob;
+static VALUE spg_BigDecimal;
+static VALUE spg_Date;
+
+static VALUE spg_sym_utc;
+static VALUE spg_sym_local;
+
+static ID spg_id_new;
+static ID spg_id_local;
+static ID spg_id_year;
+static ID spg_id_month;
+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_op_plus;
+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_columns;
+static ID spg_id_encoding;
+
+#if SPG_ENCODING
+static int enc_get_index(VALUE val)
+{
+  int i = ENCODING_GET_INLINED(val);
+  if (i == ENCODING_INLINE_MAX) {
+    i = NUM2INT(rb_ivar_get(val, spg_id_encoding));
+  }
+  return i;
+}
+#endif
+
+static VALUE spg_time(const char *s) {
+  VALUE now;
+  int hour, minute, second, tokens;
+  char subsec[7];
+  int usec = 0;
+
+  tokens = sscanf(s, "%2d:%2d:%2d.%s", &hour, &minute, &second, subsec);
+  if(tokens == 4) {
+    usec = atoi(subsec);
+    usec *= (int) pow(10, (6 - strlen(subsec)));
+  } else if(tokens < 3) {
+    rb_raise(rb_eArgError, "unexpected time format");
+  }
+
+  now = rb_funcall(rb_cTime, spg_id_new, 0);
+  return rb_funcall(rb_cTime, spg_id_local, 6, rb_funcall(now, spg_id_year, 0), rb_funcall(now, spg_id_month, 0), rb_funcall(now, spg_id_day, 0), INT2NUM(hour), INT2NUM(minute), INT2NUM(second), INT2NUM(usec));
+}
+
+static VALUE spg_date(const char *s) {
+  int year, month, day;
+
+  if(3 != sscanf(s, "%d-%2d-%2d", &year, &month, &day)) {
+    rb_raise(rb_eArgError, "unexpected date format");
+  }
+
+  return rb_funcall(spg_Date, spg_id_new, 3, INT2NUM(year), INT2NUM(month), INT2NUM(day));
+}
+
+static VALUE spg_timestamp(const char *s) {
+  VALUE dtc, dt, rtz;
+  int tz = SPG_NO_TZ;
+  int year, month, day, hour, min, sec, usec, tokens, pos, utc_offset;
+  int check_offset = 0;
+  int offset_hour = 0;
+  int offset_minute = 0;
+  int offset_seconds = 0;
+  double offset_fraction = 0.0;
+  char subsec[7];
+
+  if (0 != strchr(s, '.')) {
+    tokens = sscanf(s, "%d-%2d-%2d %2d:%2d:%2d.%s%n", &year, &month, &day, &hour, &min, &sec, subsec, &pos);
+    if (tokens == 8) {
+      check_offset = 1;
+    }
+    if(tokens != 7) {
+      rb_raise(rb_eArgError, "unexpected datetime format");
+    }
+    usec = atoi(subsec);
+    usec *= (int) pow(10, (6 - strlen(subsec)));
+  } else {
+    tokens = sscanf(s, "%d-%2d-%2d %2d:%2d:%2d%n", &year, &month, &day, &hour, &min, &sec, &pos);
+    if (tokens == 3) {
+      hour = 0;
+      min = 0;
+      sec = 0;
+    } else if (tokens == 7) {
+      check_offset = 1;
+    } else if (tokens != 6) {
+      rb_raise(rb_eArgError, "unexpected datetime format");
+    }
+    usec = 0;
+  }
+
+  if (check_offset) {
+    if(sscanf(s + pos, "%3d:%2d", &offset_hour, &offset_minute) == 0) {
+      /* No offset found */
+      check_offset = 0;
+    }
+  }
+
+  /* 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);
+  if (rtz == spg_sym_local) {
+    tz += SPG_DB_LOCAL;
+  } else if (rtz == spg_sym_utc) {
+    tz += SPG_DB_UTC;
+  }
+  rtz = rb_funcall(spg_Sequel, spg_id_application_timezone, 0);
+  if (rtz == spg_sym_local) {
+    tz += SPG_APP_LOCAL;
+  } else if (rtz == spg_sym_utc) {
+    tz += SPG_APP_UTC;
+  }
+
+  if (dtc == rb_cTime) {
+    if (check_offset) {
+      /* Offset given, convert to local time if not already in local time.
+       * While PostgreSQL generally returns timestamps in local time, it's unwise to rely on this.
+       */
+      dt = rb_funcall(rb_cTime, spg_id_local, 7, INT2NUM(year), INT2NUM(month), INT2NUM(day), INT2NUM(hour), INT2NUM(min), INT2NUM(sec), INT2NUM(usec));
+      utc_offset = NUM2INT(rb_funcall(dt, spg_id_utc_offset, 0));
+      offset_seconds = offset_hour * 3600 + offset_minute * 60;
+      if (utc_offset != offset_seconds) {
+        dt = rb_funcall(dt, spg_id_op_plus, 1, INT2NUM(utc_offset - offset_seconds));
+      }
+
+      if (tz & SPG_APP_UTC) {
+        dt = rb_funcall(dt, spg_id_utc, 0);
+      } 
+      return dt;
+    } else if (tz == SPG_NO_TZ) {
+      return rb_funcall(rb_cTime, spg_id_local, 7, INT2NUM(year), INT2NUM(month), INT2NUM(day), INT2NUM(hour), INT2NUM(min), INT2NUM(sec), INT2NUM(usec));
+    }
+
+    /* No offset given, and some timezone combination given */
+    if (tz & SPG_DB_UTC) {
+      dt = rb_funcall(rb_cTime, spg_id_utc, 7, INT2NUM(year), INT2NUM(month), INT2NUM(day), INT2NUM(hour), INT2NUM(min), INT2NUM(sec), INT2NUM(usec));
+      if (tz & SPG_APP_LOCAL) {
+        return rb_funcall(dt, spg_id_localtime, 0);
+      } else {
+        return dt;
+      }
+    } else {
+      dt = rb_funcall(rb_cTime, spg_id_local, 7, INT2NUM(year), INT2NUM(month), INT2NUM(day), INT2NUM(hour), INT2NUM(min), INT2NUM(sec), INT2NUM(usec));
+      if (tz & SPG_APP_UTC) {
+        return rb_funcall(dt, spg_id_utc, 0);
+      } else {
+        return dt;
+      }
+    }
+  } else {
+    /* datetime.class == DateTime */
+    if (check_offset) {
+      /* Offset given, handle correct local time.
+       * While PostgreSQL generally returns timestamps in local time, it's unwise to rely on this.
+       */
+      offset_fraction = offset_hour/24.0 + offset_minute/SPG_MINUTES_PER_DAY;
+      dt = rb_funcall(dtc, spg_id_new, 7, INT2NUM(year), INT2NUM(month), INT2NUM(day), INT2NUM(hour), INT2NUM(min), INT2NUM(sec), rb_float_new(offset_fraction));
+      SPG_DT_ADD_USEC
+
+      if (tz & SPG_APP_LOCAL) {
+        utc_offset = NUM2INT(rb_funcall(rb_funcall(rb_cTime, spg_id_new, 0), spg_id_utc_offset, 0))/SPG_SECONDS_PER_DAY;
+        dt = rb_funcall(dt, spg_id_new_offset, 1, rb_float_new(utc_offset));
+      } else if (tz & SPG_APP_UTC) {
+        dt = rb_funcall(dt, spg_id_new_offset, 1, INT2NUM(0));
+      } 
+      return dt;
+    } else if (tz == SPG_NO_TZ) {
+      dt = rb_funcall(dtc, spg_id_new, 6, INT2NUM(year), INT2NUM(month), INT2NUM(day), INT2NUM(hour), INT2NUM(min), INT2NUM(sec));
+      SPG_DT_ADD_USEC
+      return dt;
+    }
+
+    /* No offset given, and some timezone combination given */
+    if (tz & SPG_DB_LOCAL) {
+      offset_fraction = NUM2INT(rb_funcall(rb_funcall(rb_cTime, spg_id_local, 6, INT2NUM(year), INT2NUM(month), INT2NUM(day), INT2NUM(hour), INT2NUM(min), INT2NUM(sec)), spg_id_utc_offset, 0))/SPG_SECONDS_PER_DAY;
+      dt = rb_funcall(dtc, spg_id_new, 7, INT2NUM(year), INT2NUM(month), INT2NUM(day), INT2NUM(hour), INT2NUM(min), INT2NUM(sec), rb_float_new(offset_fraction));
+      SPG_DT_ADD_USEC
+      if (tz & SPG_APP_UTC) {
+        return rb_funcall(dt, spg_id_new_offset, 1, INT2NUM(0));
+      } else {
+        return dt;
+      }
+    } else {
+      dt = rb_funcall(dtc, spg_id_new, 6, INT2NUM(year), INT2NUM(month), INT2NUM(day), INT2NUM(hour), INT2NUM(min), INT2NUM(sec));
+      SPG_DT_ADD_USEC
+      if (tz & SPG_APP_LOCAL) {
+        offset_fraction = NUM2INT(rb_funcall(rb_funcall(rb_cTime, spg_id_local, 6, INT2NUM(year), INT2NUM(month), INT2NUM(day), INT2NUM(hour), INT2NUM(min), INT2NUM(sec)), spg_id_utc_offset, 0))/SPG_SECONDS_PER_DAY;
+        return rb_funcall(dt, spg_id_new_offset, 1, rb_float_new(offset_fraction));
+      } else {
+        return dt;
+      }
+    }
+  }
+}
+
+static VALUE spg_fetch_rows_set_cols(VALUE self, VALUE ignore) {
+  return self;
+}
+
+static VALUE spg_yield_hash_rows(VALUE self, VALUE rres, VALUE ignore) {
+  PGresult *res;
+  VALUE colsyms[SPG_MAX_FIELDS];
+  long ntuples;
+  long nfields;
+  long i;
+  long j;
+  VALUE h, rv;
+  size_t l;
+  char * v;
+
+#ifdef SPG_ENCODING
+  int enc_index;
+  enc_index = enc_get_index(rres);
+#endif
+
+  Data_Get_Struct(rres, PGresult, res);
+  ntuples = PQntuples(res);
+  nfields = PQnfields(res);
+  if (nfields > SPG_MAX_FIELDS) {
+    rb_raise(rb_eRangeError, "more than %d columns in query", SPG_MAX_FIELDS);
+  }
+
+  for(j=0; j<nfields; j++) {
+    colsyms[j] = rb_funcall(self, spg_id_output_identifier, 1, rb_str_new2(PQfname(res, j)));
+  }
+  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;
+          default:
+            rv = rb_tainted_str_new(v, PQgetlength(res, i, j));
+#ifdef SPG_ENCODING
+            rb_enc_associate_index(rv, enc_index);
+#endif
+        }
+      }
+      rb_hash_aset(h, colsyms[j], rv);
+    }
+    rb_yield(h);
+  }
+  
+  return self;
+}
+
+void Init_sequel_pg(void) {
+  VALUE c;
+  ID cg;
+  cg = rb_intern("const_get");
+  spg_id_new = rb_intern("new");
+  spg_id_local = rb_intern("local");
+  spg_id_year = rb_intern("year");
+  spg_id_month = rb_intern("month");
+  spg_id_day = rb_intern("day");
+  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_op_plus = rb_intern("+");
+  spg_id_utc = rb_intern("utc");
+  spg_id_utc_offset = rb_intern("utc_offset");
+  spg_id_localtime = rb_intern("localtime");
+  spg_id_new_offset = rb_intern("new_offset");
+
+  spg_id_columns = rb_intern("@columns");
+  spg_id_encoding = rb_intern("@encoding");
+
+  spg_sym_utc = ID2SYM(rb_intern("utc"));
+  spg_sym_local = ID2SYM(rb_intern("local"));
+
+  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")); 
+  spg_BigDecimal = rb_funcall(rb_cObject, cg, 1, rb_str_new2("BigDecimal")); 
+  spg_Date = rb_funcall(rb_cObject, cg, 1, rb_str_new2("Date")); 
+
+  rb_global_variable(&spg_Sequel);
+  rb_global_variable(&spg_Blob);
+  rb_global_variable(&spg_BigDecimal);
+  rb_global_variable(&spg_Date);
+
+  c = rb_funcall(rb_funcall(spg_Sequel, cg, 1, rb_str_new2("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);
+}

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification 
+name: sequel_pg
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Jeremy Evans
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-31 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: pg
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 63
+        segments: 
+        - 0
+        - 8
+        - 0
+        version: 0.8.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: sequel
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 31
+        segments: 
+        - 3
+        - 6
+        - 0
+        version: 3.6.0
+  type: :runtime
+  version_requirements: *id002
+description: |
+  sequel_pg overwrites the inner loop of the Sequel postgres
+  adapter row fetching code with a C version.  The C version
+  is significantly faster (2-6x) than the pure ruby version
+  that Sequel uses by default.
+
+email: code@jeremyevans.net
+executables: []
+
+extensions: 
+- ext/sequel_pg/extconf.rb
+extra_rdoc_files: 
+- README.rdoc
+- CHANGELOG
+- LICENSE
+files: 
+- LICENSE
+- CHANGELOG
+- README.rdoc
+- Rakefile
+- ext/sequel_pg/extconf.rb
+- ext/sequel_pg/sequel_pg.c
+has_rdoc: true
+homepage: http://github.com/jeremyevans/sequel_pg
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --quiet
+- --line-numbers
+- --inline-source
+- --title
+- "sequel_pg: Faster SELECTs when using Sequel with pg"
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 59
+      segments: 
+      - 1
+      - 8
+      - 6
+      version: 1.8.6
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Faster SELECTs when using Sequel with pg
+test_files: []
+