sequel_pg 1.9.0 → 1.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a7e56aa87f96c34298bba6a14bac49f79938415c9d9d8546b5621ac82c45161a
-  data.tar.gz: 85a21e58594078a962344e2308d6ae4b860de0b3af34a99be4ad93cdb39f4163
+  metadata.gz: d5e59a1152aaf6b21d44b1d57ce4653b6248a61db684a443bcdbbb86fb7c7ff8
+  data.tar.gz: 5f3392deba2a7286b6fa24a8c3b93ea8ee362f027c6df75a55574910b62a4c7c
 SHA512:
-  metadata.gz: 81ee2f7a944480110a254dbf6517e1b1d6eb64993c6e20f6425eab84e9f833213004c02857148bc36782bcef0862bacd17e8b12a7aa76e2f09b9c9aabe1c73dc
-  data.tar.gz: 5ff9e1e8750040e82c2cc9157d12f9c4fcf927f2dbb4576483b14d417bb5f65b45cacbd2c588ddc3db9ab5f0eca114f83b69455609e0bf8b6c92ec1b74b7423b
+  metadata.gz: 04d3ac1ba009d05ba2dd46d32865926a79a3cae63ef3f29a9d26d5874409fedfc54e6855a0a9ea9e7dd4dd9ef5e8603bda134368e040d9e3858f00b063ca8363
+  data.tar.gz: 0d147bca275b89d70255430fdadf4c7afc0a83a5f48414a656c1b583297ac05dea61b0d03d43a78b6bcff31f27adc8d62462e98de4228348171131f4e71144be

data/CHANGELOG

@@ -1,3 +1,23 @@
+=== 1.10.0 (2018-06-25)
+
+* Add native inet/cidr parsers (jeremyevans)
+
+* Don't leak memory if unable to create a Sequel::SQL::Blob string when parsing bytea (jeremyevans)
+
+* Improve performance of bytea parsing (jeremyevans)
+
+* Drop Sequel <4.38.0 support (jeremyevans)
+
+* Respect Sequel.application_timezone setting when parsing values for time and timetz columns (jeremyevans)
+
+* Respect Sequel::SQLTime.date setting when parsing values for time and timetz columns (jeremyevans)
+
+* Improve performance of time parsing (jeremyevans)
+
+* Improve performance of date parsing (jeremyevans)
+
+* Improve performance of timestamp parsing by borrowing and optimizing ruby-pg's parser (jeremyevans)
+
 === 1.9.0 (2018-06-06)
 
 * Return arrays of common data types as PGArray instances automatically with much improved performance (jeremyevans)

data/ext/sequel_pg/extconf.rb

@@ -6,6 +6,7 @@ dir_config('pg', ENV["POSTGRES_INCLUDE"] || (IO.popen("pg_config --includedir").
 
 if (have_library('pq') || have_library('libpq') || have_library('ms/libpq')) && have_header('libpq-fe.h')
   have_func 'PQsetSingleRowMode'
+  have_func 'timegm'
   create_makefile("sequel_pg")
 else
   puts 'Could not find PostgreSQL build environment (libraries & headers): Makefile not created'

data/ext/sequel_pg/sequel_pg.c

@@ -1,11 +1,18 @@
-#define SEQUEL_PG_VERSION_INTEGER 10900
+#define SEQUEL_PG_VERSION_INTEGER 11000
 
 #include <string.h>
 #include <stdio.h>
 #include <math.h>
 #include <libpq-fe.h>
 #include <ruby.h>
+#include <ctype.h>
+#include <sys/types.h>
+#include <time.h>
+#include <arpa/inet.h>
+#include <sys/socket.h>
+#include <string.h>
 
+#include <ruby/version.h>
 #include <ruby/encoding.h>
 
 #ifndef SPG_MAX_FIELDS
@@ -16,11 +23,36 @@
 
 #define SPG_DT_ADD_USEC if (usec != 0) { dt = rb_funcall(dt, spg_id_op_plus, 1, rb_Rational2(INT2NUM(usec), spg_usec_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
+#ifndef RARRAY_AREF
+#define RARRAY_AREF(a, i) (RARRAY_PTR(a)[i])
+#endif
+
+#define ntohll(c) ((uint64_t)( \
+    (((uint64_t)(*((unsigned char*)(c)+0)))<<56LL) | \
+    (((uint64_t)(*((unsigned char*)(c)+1)))<<48LL) | \
+    (((uint64_t)(*((unsigned char*)(c)+2)))<<40LL) | \
+    (((uint64_t)(*((unsigned char*)(c)+3)))<<32LL) | \
+    (((uint64_t)(*((unsigned char*)(c)+4)))<<24LL) | \
+    (((uint64_t)(*((unsigned char*)(c)+5)))<<16LL) | \
+    (((uint64_t)(*((unsigned char*)(c)+6)))<< 8LL) | \
+    (((uint64_t)(*((unsigned char*)(c)+7)))      ) \
+  ))
+
+#define SPG_DB_LOCAL       (1)
+#define SPG_DB_UTC         (1<<1)
+#define SPG_DB_CUSTOM      (1<<2)
+#define SPG_APP_LOCAL      (1<<3)
+#define SPG_APP_UTC        (1<<4)
+#define SPG_APP_CUSTOM     (1<<5)
+#define SPG_TZ_INITIALIZED (1<<6)
+#define SPG_USE_TIME       (1<<7)
+#define SPG_HAS_TIMEZONE   (1<<8)
+
+#define SPG_YEAR_SHIFT  16
+#define SPG_MONTH_SHIFT 8
+#define SPG_MONTH_MASK  0x0000ffff
+#define SPG_DAY_MASK    0x0000001f
+#define SPG_TIME_UTC    32
 
 #define SPG_YIELD_NORMAL 0
 #define SPG_YIELD_COLUMN 1
@@ -37,17 +69,24 @@
 #define SPG_YIELD_KMV_HASH_GROUPS 12
 #define SPG_YIELD_MKMV_HASH_GROUPS 13
 
-/* External functions defined by ruby-pg when data objects are structs */
+/* External functions defined by ruby-pg */
 PGconn* pg_get_pgconn(VALUE);
 PGresult* pgresult_get(VALUE);
 
+static int spg_use_ipaddr_alloc;
+
 static VALUE spg_Sequel;
 static VALUE spg_PGArray;
 static VALUE spg_Blob;
+static VALUE spg_Blob_instance;
 static VALUE spg_Kernel;
 static VALUE spg_Date;
+static VALUE spg_DateTime;
 static VALUE spg_SQLTime;
 static VALUE spg_PGError;
+static VALUE spg_IPAddr;
+static VALUE spg_vmasks4;
+static VALUE spg_vmasks6;
 
 static VALUE spg_sym_utc;
 static VALUE spg_sym_local;
@@ -86,6 +125,8 @@ static VALUE spg_sym_cid;
 static VALUE spg_sym_name;
 static VALUE spg_sym_tid;
 static VALUE spg_sym_int2vector;
+static VALUE spg_sym_inet;
+static VALUE spg_sym_cidr;
 
 static VALUE spg_nan;
 static VALUE spg_pos_inf;
@@ -94,6 +135,7 @@ static VALUE spg_usec_per_day;
 
 static ID spg_id_BigDecimal;
 static ID spg_id_new;
+static ID spg_id_date;
 static ID spg_id_local;
 static ID spg_id_year;
 static ID spg_id_month;
@@ -123,12 +165,23 @@ static ID spg_id_columns;
 static ID spg_id_encoding;
 static ID spg_id_values;
 
+static ID spg_id_lshift;
+static ID spg_id_mask;
+static ID spg_id_family;
+static ID spg_id_addr;
+static ID spg_id_mask_addr;
+
 #if HAVE_PQSETSINGLEROWMODE
 static ID spg_id_get_result;
 static ID spg_id_clear;
 static ID spg_id_check;
 #endif
 
+struct spg_blob_initialization {
+  char *blob_string;
+  size_t length;
+};
+
 static int enc_get_index(VALUE val) {
   int i = ENCODING_GET_INLINED(val);
   if (i == ENCODING_INLINE_MAX) {
@@ -138,68 +191,68 @@ static int enc_get_index(VALUE val) {
 }
 
 #define PG_ENCODING_SET_NOCHECK(obj,i) \
-	do { \
-		if ((i) < ENCODING_INLINE_MAX) \
-			ENCODING_SET_INLINED((obj), (i)); \
-		else \
-			rb_enc_set_index((obj), (i)); \
-	} while(0)
+  do { \
+    if ((i) < ENCODING_INLINE_MAX) \
+      ENCODING_SET_INLINED((obj), (i)); \
+    else \
+      rb_enc_set_index((obj), (i)); \
+  } while(0)
 
 static VALUE
 pg_text_dec_integer(char *val, int len)
 {
-	long i;
-	int max_len;
-
-	if( sizeof(i) >= 8 && FIXNUM_MAX >= 1000000000000000000LL ){
-		/* 64 bit system can safely handle all numbers up to 18 digits as Fixnum */
-		max_len = 18;
-	} else if( sizeof(i) >= 4 && FIXNUM_MAX >= 1000000000LL ){
-		/* 32 bit system can safely handle all numbers up to 9 digits as Fixnum */
-		max_len = 9;
-	} else {
-		/* unknown -> don't use fast path for int conversion */
-		max_len = 0;
-	}
-
-	if( len <= max_len ){
-		/* rb_cstr2inum() seems to be slow, so we do the int conversion by hand.
-		 * This proved to be 40% faster by the following benchmark:
-		 *
-		 *   conn.type_mapping_for_results = PG::BasicTypeMapForResults.new conn
-		 *   Benchmark.measure do
-		 *     conn.exec("select generate_series(1,1000000)").values }
-		 *   end
-		 */
-		char *val_pos = val;
-		char digit = *val_pos;
-		int neg;
-		int error = 0;
-
-		if( digit=='-' ){
-			neg = 1;
-			i = 0;
-		}else if( digit>='0' && digit<='9' ){
-			neg = 0;
-			i = digit - '0';
-		} else {
-			error = 1;
-		}
-
-		while (!error && (digit=*++val_pos)) {
-			if( digit>='0' && digit<='9' ){
-				i = i * 10 + (digit - '0');
-			} else {
-				error = 1;
-			}
-		}
-
-		if( !error ){
-			return LONG2FIX(neg ? -i : i);
-		}
-	}
-	/* Fallback to ruby method if number too big or unrecognized. */
-	return rb_cstr2inum(val, 10);
+  long i;
+  int max_len;
+
+  if( sizeof(i) >= 8 && FIXNUM_MAX >= 1000000000000000000LL ){
+    /* 64 bit system can safely handle all numbers up to 18 digits as Fixnum */
+    max_len = 18;
+  } else if( sizeof(i) >= 4 && FIXNUM_MAX >= 1000000000LL ){
+    /* 32 bit system can safely handle all numbers up to 9 digits as Fixnum */
+    max_len = 9;
+  } else {
+    /* unknown -> don't use fast path for int conversion */
+    max_len = 0;
+  }
+
+  if( len <= max_len ){
+    /* rb_cstr2inum() seems to be slow, so we do the int conversion by hand.
+     * This proved to be 40% faster by the following benchmark:
+     *
+     *   conn.type_mapping_for_results = PG::BasicTypeMapForResults.new conn
+     *   Benchmark.measure do
+     *     conn.exec("select generate_series(1,1000000)").values }
+     *   end
+     */
+    char *val_pos = val;
+    char digit = *val_pos;
+    int neg;
+    int error = 0;
+
+    if( digit=='-' ){
+      neg = 1;
+      i = 0;
+    }else if( digit>='0' && digit<='9' ){
+      neg = 0;
+      i = digit - '0';
+    } else {
+      error = 1;
+    }
+
+    while (!error && (digit=*++val_pos)) {
+      if( digit>='0' && digit<='9' ){
+        i = i * 10 + (digit - '0');
+      } else {
+        error = 1;
+      }
+    }
+
+    if( !error ){
+      return LONG2FIX(neg ? -i : i);
+    }
+  }
+  /* Fallback to ruby method if number too big or unrecognized. */
+  return rb_cstr2inum(val, 10);
 }
 
 static VALUE spg__array_col_value(char *v, size_t length, VALUE converter, int enc_index, int oid, VALUE db);
@@ -349,43 +402,108 @@ static VALUE parse_pg_array(VALUE self, VALUE pg_array_string, VALUE converter)
     Qnil);
 }
 
-static VALUE spg_time(const char *s) {
-  VALUE now;
-  int hour, minute, second, tokens, i;
-  char subsec[7];
+static VALUE spg_timestamp_error(const char *s, VALUE self, const char *error_msg) {
+  self = rb_funcall(self, spg_id_db, 0);
+  if(RTEST(rb_funcall(self, spg_id_convert_infinite_timestamps, 0))) {
+    if((strcmp(s, "infinity") == 0) || (strcmp(s, "-infinity") == 0)) {
+      return rb_funcall(self, spg_id_infinite_timestamp_value, 1, rb_tainted_str_new2(s));
+    }
+  }
+  rb_raise(rb_eArgError, "%s", error_msg);
+}
+
+static inline int char_to_digit(char c)
+{
+  return c - '0';
+}
+
+static int str4_to_int(const char *str)
+{
+  return char_to_digit(str[0]) * 1000
+      + char_to_digit(str[1]) * 100
+      + char_to_digit(str[2]) * 10
+      + char_to_digit(str[3]);
+}
+
+static int str2_to_int(const char *str)
+{
+  return char_to_digit(str[0]) * 10
+      + char_to_digit(str[1]);
+}
+
+static VALUE spg_time(const char *p, size_t length, int current) {
+  int hour, minute, second, i;
   int usec = 0;
+  ID meth = spg_id_local;
+
+  if (length < 8) {
+    rb_raise(rb_eArgError, "unexpected time format, too short");
+  }
+
+  if (p[2] == ':' && p[5] == ':') {
+    hour = str2_to_int(p);
+    minute = str2_to_int(p+3);
+    second = str2_to_int(p+6);
+    p += 8;
 
-  tokens = sscanf(s, "%2d:%2d:%2d.%6s", &hour, &minute, &second, subsec);
-  if(tokens == 4) {
-    for(i=0; i<6; i++) {
-      if(subsec[i] == '-') {
-        subsec[i] = '\0';
+    if (length >= 10 && p[0] == '.') {
+      static const int coef[6] = { 100000, 10000, 1000, 100, 10, 1 };
+
+      p++;
+      for (i = 0; i < 6 && isdigit(*p); i++) {
+        usec += coef[i] * char_to_digit(*p++);
       }
     }
-    usec = atoi(subsec);
-    usec *= (int) pow(10, (6 - strlen(subsec)));
-  } else if(tokens < 3) {
+  } else {
     rb_raise(rb_eArgError, "unexpected time format");
   }
 
-  now = rb_funcall(spg_SQLTime, spg_id_new, 0);
-  return rb_funcall(spg_SQLTime, spg_id_local, 7, 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));
+  if (current & SPG_TIME_UTC) {
+    meth = spg_id_utc;
+  }
+  return rb_funcall(spg_SQLTime, meth, 7,
+    INT2NUM(current >> SPG_YEAR_SHIFT),
+    INT2NUM((current & SPG_MONTH_MASK) >> SPG_MONTH_SHIFT),
+    INT2NUM(current & SPG_DAY_MASK),
+    INT2NUM(hour),
+    INT2NUM(minute),
+    INT2NUM(second),
+    INT2NUM(usec));
 }
 
-static VALUE spg_timestamp_error(const char *s, VALUE self, const char *error_msg) {
-  self = rb_funcall(self, spg_id_db, 0);
-  if(RTEST(rb_funcall(self, spg_id_convert_infinite_timestamps, 0))) {
-    if((strcmp(s, "infinity") == 0) || (strcmp(s, "-infinity") == 0)) {
-      return rb_funcall(self, spg_id_infinite_timestamp_value, 1, rb_tainted_str_new2(s));
-    }
+/* Caller should check length is at least 4 */
+static int parse_year(const char **str, size_t *length) {
+  int year, i;
+  size_t remaining = *length;
+  const char * p = *str;
+
+  year = str4_to_int(p);
+  p += 4;
+  remaining -= 4;
+
+  for(i = 0; isdigit(*p) && i < 3; i++, p++, remaining--) {
+    year = 10 * year + char_to_digit(*p);
   }
-  rb_raise(rb_eArgError, "%s", error_msg);
+
+  *str = p;
+  *length = remaining;
+  return year;
 }
 
-static VALUE spg_date(const char *s, VALUE self) {
+static VALUE spg_date(const char *s, VALUE self, size_t length) {
   int year, month, day;
+  const char *p = s;
 
-  if(3 != sscanf(s, "%d-%2d-%2d", &year, &month, &day)) {
+  if (length < 10) {
+    return spg_timestamp_error(s, self, "unexpected date format, too short");
+  }
+
+  year = parse_year(&p, &length);
+
+  if (length >= 5 && p[0] == '-' && p[3] == '-') {
+    month = str2_to_int(p+1);
+    day = str2_to_int(p+4);
+  } else {
     return spg_timestamp_error(s, self, "unexpected date format");
   }
 
@@ -397,85 +515,148 @@ static VALUE spg_date(const char *s, VALUE self) {
   return rb_funcall(spg_Date, spg_id_new, 3, INT2NUM(year), INT2NUM(month), INT2NUM(day));
 }
 
-static VALUE spg_timestamp(const char *s, VALUE self) {
-  VALUE dtc, dt, rtz, db;
-  int tz = SPG_NO_TZ;
-  int year, month, day, hour, min, sec, usec, tokens, utc_offset, len;
-  int usec_start, usec_stop;
+static VALUE spg_timestamp(const char *s, VALUE self, size_t length, int tz) {
+  VALUE dt;
+  int year, month, day, hour, min, sec, utc_offset;
   char offset_sign = 0;
-  int offset_hour = 0;
-  int offset_minute = 0;
   int offset_seconds = 0;
-  double offset_fraction = 0.0;
+  int usec = 0;
+  int i;
+  const char *p = s;
+  size_t remaining = length;
 
-  db = rb_funcall(self, spg_id_db, 0);
-  rtz = rb_funcall(db, spg_id_timezone, 0);
-  if (rtz != Qnil) {
-    if (rtz == spg_sym_local) {
-      tz += SPG_DB_LOCAL;
-    } else if (rtz == spg_sym_utc) {
-      tz += SPG_DB_UTC;
-    } else {
-      return rb_funcall(db, spg_id_to_application_timestamp, 1, rb_str_new2(s)); 
-    }
+  if (tz & SPG_DB_CUSTOM || tz & SPG_APP_CUSTOM) {
+    return rb_funcall(rb_funcall(self, spg_id_db, 0), spg_id_to_application_timestamp, 1, rb_str_new2(s)); 
   }
 
-  rtz = rb_funcall(spg_Sequel, spg_id_application_timezone, 0);
-  if (rtz != Qnil) {
-    if (rtz == spg_sym_local) {
-      tz += SPG_APP_LOCAL;
-    } else if (rtz == spg_sym_utc) {
-      tz += SPG_APP_UTC;
-    } else {
-      return rb_funcall(db, spg_id_to_application_timestamp, 1, rb_str_new2(s)); 
-    }
+  if (remaining < 19) {
+    return spg_timestamp_error(s, self, "unexpected timetamp format, too short");
   }
 
-  if (0 != strchr(s, '.')) {
-    tokens = sscanf(s, "%d-%2d-%2d %2d:%2d:%2d.%n%d%n%c%02d:%02d:%02d", 
-        &year, &month, &day, &hour, &min, &sec,
-        &usec_start, &usec, &usec_stop, 
-        &offset_sign, &offset_hour, &offset_minute, &offset_seconds);
-    if(tokens < 7) {
-      return spg_timestamp_error(s, self, "unexpected datetime format");
+  year = parse_year(&p, &remaining);
+
+  if (remaining >= 15 && p[0] == '-' && p[3] == '-' && p[6] == ' ' && p[9] == ':' && p[12] == ':') {
+    month = str2_to_int(p+1);
+    day = str2_to_int(p+4);
+    hour = str2_to_int(p+7);
+    min = str2_to_int(p+10);
+    sec = str2_to_int(p+13);
+    p += 15;
+    remaining -= 15;
+
+    if (remaining >= 2 && p[0] == '.') {
+      /* microsecond part, up to 6 digits */
+      static const int coef[6] = { 100000, 10000, 1000, 100, 10, 1 };
+
+      p++;
+      remaining--;
+      for (i = 0; i < 6 && isdigit(*p); i++)
+      {
+        usec += coef[i] * char_to_digit(*p++);
+        remaining--;
+      }
     }
-    usec *= (int) pow(10, (6 - (usec_stop - usec_start)));
-  } else {
-    tokens = sscanf(s, "%d-%2d-%2d %2d:%2d:%2d%c%02d:%02d:%02d", 
-        &year, &month, &day, &hour, &min, &sec,
-        &offset_sign, &offset_hour, &offset_minute, &offset_seconds);
-    if (tokens == 3) {
-      hour = 0;
-      min = 0;
-      sec = 0;
-    } else if (tokens < 6) {
-      return spg_timestamp_error(s, self, "unexpected datetime format");
+
+    if ((tz & SPG_HAS_TIMEZONE) && remaining >= 3 && (p[0] == '+' || p[0] == '-')) {
+      offset_sign = p[0];
+      offset_seconds += str2_to_int(p+1)*3600;
+      p += 3;
+      remaining -= 3;
+
+      if (p[0] == ':') {
+        p++;
+        remaining--;
+      }
+      if (remaining >= 2 && isdigit(p[0]) && isdigit(p[1]))
+      {
+        offset_seconds += str2_to_int(p)*60;
+        p += 2;
+        remaining -= 2;
+      }
+      if (p[0] == ':')
+      {
+        p++;
+        remaining--;
+      }
+      if (remaining >= 2 && isdigit(p[0]) && isdigit(p[1]))
+      {
+        offset_seconds += str2_to_int(p);
+        p += 2;
+        remaining -= 2;
+      }
+      if (offset_sign == '-') {
+        offset_seconds *= -1;
+      }
     }
-    usec = 0;
-  }
 
-  len = strlen(s);
-  if(s[len-3] == ' ' && s[len-2] == 'B' && s[len-1] == 'C') {
-    year = -year;
-    year++;
+    if (remaining == 3 && p[0] == ' ' && p[1] == 'B' && p[2] == 'C') {
+      year = -year;
+      year++;
+    } else if (remaining != 0) {
+      return spg_timestamp_error(s, self, "unexpected timestamp format, remaining data left");
+    }
+  } else {
+    return spg_timestamp_error(s, self, "unexpected timestamp format");
   }
+  
 
-  if (offset_sign == '-') {
-    offset_hour *= -1;
-    offset_minute *= -1;
-    offset_seconds *= -1;
-  }
+  if (tz & SPG_USE_TIME) {
+#if (RUBY_API_VERSION_MAJOR > 2 || (RUBY_API_VERSION_MAJOR == 2 && RUBY_API_VERSION_MINOR >= 3)) && defined(HAVE_TIMEGM)
+    /* Fast path for time conversion */
+    struct tm tm;
+    struct timespec ts;
+    time_t time;
 
-  dtc = rb_funcall(spg_Sequel, spg_id_datetime_class, 0);
+    tm.tm_year = year - 1900;
+    tm.tm_mon = month - 1;
+    tm.tm_mday = day;
+    tm.tm_hour = hour;
+    tm.tm_min = min;
+    tm.tm_sec = sec;
+    tm.tm_isdst = -1;
+
+    ts.tv_nsec = usec*1000;
+
+    if (offset_sign) {
+      time = timegm(&tm);
+      if (time != -1) {
+        ts.tv_sec = time - offset_seconds;
+        dt = rb_time_timespec_new(&ts, offset_seconds);
+
+        if (tz & SPG_APP_UTC) {
+          dt = rb_funcall(dt, spg_id_utc, 0);
+        } else if (tz & SPG_APP_LOCAL) {
+          dt = rb_funcall(dt, spg_id_local, 0);
+        } 
+
+        return dt;
+      }
+    } else {
+      if (tz & SPG_DB_UTC) {
+        time = timegm(&tm);
+      } else {
+        time = mktime(&tm);
+      }
+
+      if (time != -1) {
+        ts.tv_sec = time;
+        if (tz & SPG_APP_UTC) {
+          offset_seconds = INT_MAX-1;
+        } else {
+          offset_seconds = INT_MAX;
+        }
+
+        return rb_time_timespec_new(&ts, offset_seconds);
+      }
+    }
+#endif
 
-  if (dtc == rb_cTime) {
     if (offset_sign) {
       /* 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));
       }
@@ -484,7 +665,7 @@ static VALUE spg_timestamp(const char *s, VALUE self) {
         dt = rb_funcall(dt, spg_id_utc, 0);
       } 
       return dt;
-    } else if (tz == SPG_NO_TZ) {
+    } else if (!(tz & (SPG_APP_LOCAL|SPG_DB_LOCAL|SPG_APP_UTC|SPG_DB_UTC))) {
       return rb_funcall(rb_cTime, spg_id_local, 7, INT2NUM(year), INT2NUM(month), INT2NUM(day), INT2NUM(hour), INT2NUM(min), INT2NUM(sec), INT2NUM(usec));
     }
 
@@ -506,12 +687,14 @@ static VALUE spg_timestamp(const char *s, VALUE self) {
     }
   } else {
     /* datetime.class == DateTime */
+    double offset_fraction;
+
     if (offset_sign) {
       /* 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 + offset_seconds/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));
+      offset_fraction = offset_seconds/(double)SPG_SECONDS_PER_DAY;
+      dt = rb_funcall(spg_DateTime, 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) {
@@ -521,8 +704,8 @@ static VALUE spg_timestamp(const char *s, VALUE self) {
         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));
+    } else if (!(tz & (SPG_APP_LOCAL|SPG_DB_LOCAL|SPG_APP_UTC|SPG_DB_UTC))) {
+      dt = rb_funcall(spg_DateTime, spg_id_new, 6, INT2NUM(year), INT2NUM(month), INT2NUM(day), INT2NUM(hour), INT2NUM(min), INT2NUM(sec));
       SPG_DT_ADD_USEC
       return dt;
     }
@@ -530,7 +713,7 @@ static VALUE spg_timestamp(const char *s, VALUE self) {
     /* 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));
+      dt = rb_funcall(spg_DateTime, 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));
@@ -538,11 +721,12 @@ static VALUE spg_timestamp(const char *s, VALUE self) {
         return dt;
       }
     } else {
-      dt = rb_funcall(dtc, spg_id_new, 6, INT2NUM(year), INT2NUM(month), INT2NUM(day), INT2NUM(hour), INT2NUM(min), INT2NUM(sec));
+      dt = rb_funcall(spg_DateTime, 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));
+        dt = rb_funcall(dt, spg_id_new_offset, 1, rb_float_new(offset_fraction));
+        return dt;
       } else {
         return dt;
       }
@@ -550,22 +734,144 @@ static VALUE spg_timestamp(const char *s, VALUE self) {
   }
 }
 
+static VALUE spg_inet(char *val, size_t len)
+{
+  VALUE ip;
+  VALUE ip_int;
+  VALUE vmasks;
+  unsigned int dst[4];
+  char buf[64];
+  int af = strchr(val, '.') ? AF_INET : AF_INET6;
+  int mask = -1;
+
+  if (len >= 64) {
+    rb_raise(rb_eTypeError, "unable to parse IP address, too long");
+  }
+
+  if (len >= 4) {
+    if (val[len-2] == '/') {
+      mask = val[len-1] - '0';
+      memcpy(buf, val, len-2);
+      val = buf;
+      val[len-2] = '\0';
+    } else if (val[len-3] == '/') {
+      mask = (val[len-2]- '0')*10 + val[len-1] - '0';
+      memcpy(buf, val, len-3);
+      val = buf;
+      val[len-3] = '\0';
+    } else if (val[len-4] == '/') {
+      mask = (val[len-3]- '0')*100 + (val[len-2]- '0')*10 + val[len-1] - '0';
+      memcpy(buf, val, len-4);
+      val = buf;
+      val[len-4] = '\0';
+    }
+  }
+
+  if (1 != inet_pton(af, val, (char *)dst)) {
+    rb_raise(rb_eTypeError, "unable to parse IP address: %s", val);
+  }
+
+  if (af == AF_INET) {
+    unsigned int ip_int_native;
+
+    if (mask == -1) {
+      mask = 32;
+    } else if (mask < 0 || mask > 32) {
+      rb_raise(rb_eTypeError, "invalid mask for IPv4: %d", mask);
+    }
+    vmasks = spg_vmasks4;
+
+    ip_int_native = ntohl(*dst);
+
+    /* Work around broken IPAddr behavior of convering portion
+       of address after netmask to 0 */
+    switch (mask) {
+      case 0:
+        ip_int_native = 0;
+        break;
+      case 32:
+        /* nothing to do */
+        break;
+      default:
+        ip_int_native &= ~((1UL<<(32-mask))-1);
+        break;
+    }
+    ip_int = UINT2NUM(ip_int_native);
+  } else {
+    unsigned long long * dstllp = (unsigned long long *)dst;
+    unsigned long long ip_int_native1;
+    unsigned long long ip_int_native2;
+
+    if (mask == -1) {
+      mask = 128;
+    } else if (mask < 0 || mask > 128) {
+      rb_raise(rb_eTypeError, "invalid mask for IPv6: %d", mask);
+    }
+    vmasks = spg_vmasks6;
+
+    ip_int_native1 = ntohll(dstllp);
+    dstllp++;
+    ip_int_native2 = ntohll(dstllp);
+
+    if (mask == 128) {
+      /* nothing to do */
+    } else if (mask == 64) {
+      ip_int_native2 = 0;
+    } else if (mask == 0) {
+      ip_int_native1 = 0;
+      ip_int_native2 = 0;
+    } else if (mask < 64) {
+      ip_int_native1 &= ~((1ULL<<(64-mask))-1);
+      ip_int_native2 = 0;
+    } else {
+      ip_int_native2 &= ~((1ULL<<(128-mask))-1);
+    }
+
+    /* 4 Bignum allocations */
+    ip_int = ULL2NUM(ip_int_native1);
+    ip_int = rb_funcall(ip_int, spg_id_lshift, 1, INT2NUM(64));
+    ip_int = rb_funcall(ip_int, spg_id_op_plus, 1, ULL2NUM(ip_int_native2));
+  }
+
+  if (spg_use_ipaddr_alloc) {
+    ip = rb_obj_alloc(spg_IPAddr);
+    rb_ivar_set(ip, spg_id_family, INT2NUM(af));
+    rb_ivar_set(ip, spg_id_addr, ip_int);
+    rb_ivar_set(ip, spg_id_mask_addr, RARRAY_AREF(vmasks, mask));
+  } else {
+    VALUE ip_args[2];
+    ip_args[0] = ip_int;
+    ip_args[1] = INT2NUM(af);
+    ip = rb_class_new_instance(2, ip_args, spg_IPAddr);
+    ip = rb_funcall(ip, spg_id_mask, 1, INT2NUM(mask));
+  }
+
+  return ip;
+}
+
+static VALUE spg_create_Blob(VALUE v) {
+  struct spg_blob_initialization *bi = (struct spg_blob_initialization *)v;
+  if (bi->blob_string == NULL) {
+    rb_raise(rb_eNoMemError, "PQunescapeBytea failure: probably not enough memory");
+  }
+  return rb_obj_taint(rb_str_new_with_class(spg_Blob_instance, bi->blob_string, bi->length));
+}
+
 static VALUE spg_fetch_rows_set_cols(VALUE self, VALUE ignore) {
   return Qnil;
 }
 
 static VALUE spg__array_col_value(char *v, size_t length, VALUE converter, int enc_index, int oid, VALUE db) {
   VALUE rv;
-  size_t l;
+  struct spg_blob_initialization bi;
 
   switch(oid) {
     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);
+      bi.blob_string = (char *)PQunescapeBytea((unsigned char*)v, &bi.length);
+      rv = rb_ensure(spg_create_Blob, (VALUE)&bi, (VALUE(*)())PQfreemem, (VALUE)bi.blob_string);
       break;
     case 20: /* integer */
     case 21:
@@ -589,15 +895,15 @@ static VALUE spg__array_col_value(char *v, size_t length, VALUE converter, int e
       rv = rb_funcall(spg_Kernel, spg_id_BigDecimal, 1, rb_str_new(v, length));
       break;
     case 1082: /* date */
-      rv = spg_date(v, db);
+      rv = spg_date(v, db, length);
       break;
     case 1083: /* time */
     case 1266:
-      rv = spg_time(v);
+      rv = spg_time(v, length, (int)converter);
       break;
     case 1114: /* timestamp */
     case 1184:
-      rv = spg_timestamp(v, db);
+      rv = spg_timestamp(v, db, length, (int)converter);
       break;
     case 18: /* char */
     case 25: /* text */
@@ -605,6 +911,10 @@ static VALUE spg__array_col_value(char *v, size_t length, VALUE converter, int e
       rv = rb_tainted_str_new(v, length);
       PG_ENCODING_SET_NOCHECK(rv, enc_index);
       break;
+    case 869: /* inet */
+    case 650: /* cidr */
+      rv = spg_inet(v, length);
+      break;
     default:
       rv = rb_tainted_str_new(v, length);
       PG_ENCODING_SET_NOCHECK(rv, enc_index);
@@ -629,13 +939,63 @@ static VALUE spg_array_value(char *c_pg_array_string, int array_string_length, V
   return rb_class_new_instance(2, args, spg_PGArray);
 }
 
+static int spg_time_info_bitmask(void) {
+  int info = 0;
+  VALUE now = rb_funcall(spg_SQLTime, spg_id_date, 0);
+
+  info = NUM2INT(rb_funcall(now, spg_id_year, 0)) << SPG_YEAR_SHIFT;
+  info += NUM2INT(rb_funcall(now, spg_id_month, 0)) << SPG_MONTH_SHIFT;
+  info += NUM2INT(rb_funcall(now, spg_id_day, 0));
+
+  if (rb_funcall(spg_Sequel, spg_id_application_timezone, 0) == spg_sym_utc) {
+    info += SPG_TIME_UTC;
+  }
+
+  return info;
+}
+
+static int spg_timestamp_info_bitmask(VALUE self) {
+  VALUE db, rtz;
+  int tz = 0;
+
+  db = rb_funcall(self, spg_id_db, 0);
+  rtz = rb_funcall(db, spg_id_timezone, 0);
+  if (rtz != Qnil) {
+    if (rtz == spg_sym_local) {
+      tz |= SPG_DB_LOCAL;
+    } else if (rtz == spg_sym_utc) {
+      tz |= SPG_DB_UTC;
+    } else {
+      tz |= SPG_DB_CUSTOM;
+    }
+  }
+
+  rtz = rb_funcall(spg_Sequel, spg_id_application_timezone, 0);
+  if (rtz != Qnil) {
+    if (rtz == spg_sym_local) {
+      tz |= SPG_APP_LOCAL;
+    } else if (rtz == spg_sym_utc) {
+      tz |= SPG_APP_UTC;
+    } else {
+      tz |= SPG_APP_CUSTOM;
+    }
+  }
+
+  if (rb_cTime == rb_funcall(spg_Sequel, spg_id_datetime_class, 0)) {
+    tz |= SPG_USE_TIME;
+  }
+
+  tz |= SPG_TZ_INITIALIZED;
+  return tz;
+}
+
 static VALUE spg__col_value(VALUE self, PGresult *res, long i, long j, VALUE* colconvert, int enc_index) {
   char *v;
   VALUE rv;
-  size_t l;
   int ftype = PQftype(res, j);
   VALUE array_type;
   VALUE scalar_oid;
+  struct spg_blob_initialization bi;
 
   if(PQgetisnull(res, i, j)) {
     rv = Qnil;
@@ -647,9 +1007,8 @@ static VALUE spg__col_value(VALUE self, PGresult *res, long i, long j, VALUE* co
         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);
+        bi.blob_string = (char *)PQunescapeBytea((unsigned char*)v, &bi.length);
+        rv = rb_ensure(spg_create_Blob, (VALUE)&bi, (VALUE(*)())PQfreemem, (VALUE)bi.blob_string);
         break;
       case 20: /* integer */
       case 21:
@@ -673,15 +1032,15 @@ static VALUE spg__col_value(VALUE self, PGresult *res, long i, long j, VALUE* co
         rv = rb_funcall(spg_Kernel, spg_id_BigDecimal, 1, rb_str_new(v, PQgetlength(res, i, j)));
         break;
       case 1082: /* date */
-        rv = spg_date(v, self);
+        rv = spg_date(v, self, PQgetlength(res, i, j));
         break;
       case 1083: /* time */
       case 1266:
-        rv = spg_time(v);
+        rv = spg_time(v, PQgetlength(res, i, j), (int)colconvert[j]);
         break;
       case 1114: /* timestamp */
       case 1184:
-        rv = spg_timestamp(v, self);
+        rv = spg_timestamp(v, self, PQgetlength(res, i, j), (int)colconvert[j]);
         break;
       case 18: /* char */
       case 25: /* text */
@@ -689,6 +1048,10 @@ static VALUE spg__col_value(VALUE self, PGresult *res, long i, long j, VALUE* co
         rv = rb_tainted_str_new(v, PQgetlength(res, i, j));
         PG_ENCODING_SET_NOCHECK(rv, enc_index);
         break;
+      case 869: /* inet */
+      case 650: /* cidr */
+        rv = spg_inet(v, PQgetlength(res, i, j));
+        break;
       /* array types */
       case 1009:
       case 1014:
@@ -717,6 +1080,8 @@ static VALUE spg__col_value(VALUE self, PGresult *res, long i, long j, VALUE* co
       case 1003:
       case 1010:
       case 1006:
+      case 1041:
+      case 651:
         switch(ftype) {
           case 1009: 
           case 1014:
@@ -823,8 +1188,16 @@ static VALUE spg__col_value(VALUE self, PGresult *res, long i, long j, VALUE* co
             array_type = spg_sym_int2vector;
             scalar_oid = 22;
             break;
+          case 1041:
+            array_type = spg_sym_inet;
+            scalar_oid = 869;
+            break;
+          case 651:
+            array_type = spg_sym_cidr;
+            scalar_oid = 650;
+            break;
         }
-        rv = spg_array_value(v, PQgetlength(res, i, j), Qnil, enc_index, scalar_oid, self, array_type);
+        rv = spg_array_value(v, PQgetlength(res, i, j), colconvert[j], enc_index, scalar_oid, self, array_type);
         break;
       default:
         rv = rb_tainted_str_new(v, PQgetlength(res, i, j));
@@ -877,6 +1250,8 @@ static void spg_set_column_info(VALUE self, PGresult *res, VALUE *colsyms, VALUE
   long i;
   long j;
   long nfields;
+  int timestamp_info = 0;
+  int time_info = 0;
   VALUE conv_procs = 0;
 
   nfields = PQnfields(res);
@@ -885,6 +1260,7 @@ static void spg_set_column_info(VALUE self, PGresult *res, VALUE *colsyms, VALUE
     colsyms[j] = rb_funcall(self, spg_id_output_identifier, 1, rb_str_new2(PQfname(res, j)));
     i = PQftype(res, j);
     switch (i) {
+      /* scalar types */
       case 16:
       case 17:
       case 20:
@@ -896,15 +1272,57 @@ static void spg_set_column_info(VALUE self, PGresult *res, VALUE *colsyms, VALUE
       case 790:
       case 1700:
       case 1082:
-      case 1083:
-      case 1266:
-      case 1114:
-      case 1184:
       case 18:
       case 25:
       case 1043:
+      /* array types */
+      case 1009:
+      case 1014:
+      case 1015:
+      case 1007:
+      case 1016:
+      case 1231:
+      case 1022:
+      case 1000:
+      case 1001:
+      case 1182:
+      case 1005:
+      case 1028:
+      case 1021:
+      case 143:
+      case 791:
+      case 1561:
+      case 1563:
+      case 2951:
+      case 1011:
+      case 1012:
+      case 1003:
+      case 1010:
         colconvert[j] = Qnil;
         break;
+
+      /* time types */
+      case 1183:
+      case 1083:
+      case 1270:
+      case 1266:
+        if (time_info == 0) {
+          time_info = spg_time_info_bitmask();
+        }
+        colconvert[j] = time_info;
+        break;
+
+      /* timestamp types */
+      case 1115:
+      case 1185:
+      case 1114:
+      case 1184:
+        if (timestamp_info == 0) {
+          timestamp_info = spg_timestamp_info_bitmask(self);
+        }
+        colconvert[j] = (VALUE)((i == 1184 || i == 1185) ? (timestamp_info | SPG_HAS_TIMEZONE) : timestamp_info);
+        break;
+
       default:
         if (conv_procs == 0) {
           conv_procs = rb_funcall(rb_funcall(self, spg_id_db, 0), spg_id_conversion_procs, 0);
@@ -930,14 +1348,13 @@ static VALUE spg_yield_hash_rows(VALUE self, VALUE rres, VALUE ignore) {
   VALUE pg_type;
   VALUE pg_value;
   char type = SPG_YIELD_NORMAL;
+  int enc_index;
 
   if (!RTEST(rres)) {
     return self;
   }
-  Check_Type(rres, T_DATA);
   res = pgresult_get(rres);
 
-  int enc_index;
   enc_index = enc_get_index(rres);
 
   ntuples = PQntuples(res);
@@ -1174,7 +1591,6 @@ static VALUE spg_supports_streaming_p(VALUE self) {
 #if HAVE_PQSETSINGLEROWMODE
 static VALUE spg_set_single_row_mode(VALUE self) {
   PGconn *conn;
-  Check_Type(self, T_DATA);
   conn = pg_get_pgconn(self);
   if (PQsetSingleRowMode(conn) != 1) {
       rb_raise(spg_PGError, "cannot set single row mode");
@@ -1183,7 +1599,6 @@ static VALUE spg_set_single_row_mode(VALUE self) {
 }
 
 static VALUE spg__yield_each_row(VALUE self) {
-  PGconn *conn;
   PGresult *res;
   VALUE rres;
   VALUE rconn;
@@ -1196,21 +1611,18 @@ static VALUE spg__yield_each_row(VALUE self) {
   VALUE pg_type;
   VALUE pg_value = Qnil;
   char type = SPG_YIELD_NORMAL;
+  int enc_index;
 
   rconn = rb_ary_entry(self, 1);
   self = rb_ary_entry(self, 0);
-  Check_Type(rconn, T_DATA);
-  conn = pg_get_pgconn(rconn);
 
   rres = rb_funcall(rconn, spg_id_get_result, 0);
   if (rres == Qnil) {
     goto end_yield_each_row;
   }
   rb_funcall(rres, spg_id_check, 0);
-  Check_Type(rres, T_DATA);
   res = pgresult_get(rres);
 
-  int enc_index;
   enc_index = enc_get_index(rres);
 
   /* Only handle regular and model types.  All other types require compiling all
@@ -1255,7 +1667,6 @@ static VALUE spg__yield_each_row(VALUE self) {
       goto end_yield_each_row;
     }
     rb_funcall(rres, spg_id_check, 0);
-    Check_Type(rres, T_DATA);
     res = pgresult_get(rres);
   }
   rb_funcall(rres, spg_id_clear, 0);
@@ -1268,7 +1679,6 @@ static VALUE spg__flush_results(VALUE rconn) {
   PGconn *conn;
   PGresult *res;
   VALUE error = 0;
-  Check_Type(rconn, T_DATA);
   conn = pg_get_pgconn(rconn);
 
   while ((res = PQgetResult(conn)) != NULL) {
@@ -1310,6 +1720,7 @@ void Init_sequel_pg(void) {
 
   spg_Sequel = rb_funcall(rb_cObject, cg, 1, rb_str_new2("Sequel"));
   spg_Postgres = rb_funcall(spg_Sequel, cg, 1, rb_str_new2("Postgres"));
+  rb_global_variable(&spg_Sequel);
 
   if(rb_obj_respond_to(spg_Postgres, rb_intern("sequel_pg_version_supported?"), 0)) {
     if(!RTEST(rb_funcall(spg_Postgres, rb_intern("sequel_pg_version_supported?"), 1, INT2FIX(SEQUEL_PG_VERSION_INTEGER)))) {
@@ -1321,6 +1732,7 @@ void Init_sequel_pg(void) {
 
   spg_id_BigDecimal = rb_intern("BigDecimal");
   spg_id_new = rb_intern("new");
+  spg_id_date = rb_intern("date");
   spg_id_local = rb_intern("local");
   spg_id_year = rb_intern("year");
   spg_id_month = rb_intern("month");
@@ -1351,6 +1763,12 @@ void Init_sequel_pg(void) {
   spg_id_encoding = rb_intern("@encoding");
   spg_id_values = rb_intern("@values");
 
+  spg_id_family = rb_intern("@family");
+  spg_id_addr = rb_intern("@addr");
+  spg_id_mask_addr = rb_intern("@mask_addr");
+  spg_id_lshift = rb_intern("<<");
+  spg_id_mask = rb_intern("mask");
+
   spg_sym_utc = ID2SYM(rb_intern("utc"));
   spg_sym_local = ID2SYM(rb_intern("local"));
   spg_sym_map = ID2SYM(rb_intern("map"));
@@ -1388,29 +1806,42 @@ void Init_sequel_pg(void) {
   spg_sym_name = ID2SYM(rb_intern("name"));
   spg_sym_tid = ID2SYM(rb_intern("tid"));
   spg_sym_int2vector = ID2SYM(rb_intern("int2vector"));
+  spg_sym_inet = ID2SYM(rb_intern("inet"));
+  spg_sym_cidr = ID2SYM(rb_intern("cidr"));
 
   spg_Blob = rb_funcall(rb_funcall(spg_Sequel, cg, 1, rb_str_new2("SQL")), cg, 1, rb_str_new2("Blob")); 
+  rb_global_variable(&spg_Blob);
+  spg_Blob_instance = rb_obj_freeze(rb_funcall(spg_Blob, spg_id_new, 0));
+  rb_global_variable(&spg_Blob_instance);
   spg_SQLTime= rb_funcall(spg_Sequel, cg, 1, rb_str_new2("SQLTime")); 
+  rb_global_variable(&spg_SQLTime);
   spg_Kernel = rb_funcall(rb_cObject, cg, 1, rb_str_new2("Kernel")); 
+  rb_global_variable(&spg_Kernel);
   spg_Date = rb_funcall(rb_cObject, cg, 1, rb_str_new2("Date")); 
+  rb_global_variable(&spg_Date);
+  spg_DateTime = rb_funcall(rb_cObject, cg, 1, rb_str_new2("DateTime")); 
+  rb_global_variable(&spg_DateTime);
   spg_PGError = rb_funcall(rb_funcall(rb_cObject, cg, 1, rb_str_new2("PG")), cg, 1, rb_str_new2("Error"));
+  rb_global_variable(&spg_PGError);
 
   spg_nan = rb_eval_string("0.0/0.0");
-  spg_pos_inf = rb_eval_string("1.0/0.0");
-  spg_neg_inf = rb_eval_string("-1.0/0.0");
-  spg_usec_per_day = ULL2NUM(86400000000ULL);
-
-  rb_global_variable(&spg_Sequel);
-  rb_global_variable(&spg_Blob);
-  rb_global_variable(&spg_Kernel);
-  rb_global_variable(&spg_Date);
-  rb_global_variable(&spg_SQLTime);
-  rb_global_variable(&spg_PGError);
   rb_global_variable(&spg_nan);
+  spg_pos_inf = rb_eval_string("1.0/0.0");
   rb_global_variable(&spg_pos_inf);
+  spg_neg_inf = rb_eval_string("-1.0/0.0");
   rb_global_variable(&spg_neg_inf);
+  spg_usec_per_day = ULL2NUM(86400000000ULL);
   rb_global_variable(&spg_usec_per_day);
 
+  rb_require("ipaddr");
+  spg_IPAddr = rb_funcall(rb_cObject, rb_intern("const_get"), 1, rb_str_new2("IPAddr"));
+  rb_global_variable(&spg_IPAddr);
+  spg_use_ipaddr_alloc = RTEST(rb_eval_string("IPAddr.new.instance_variables.sort == [:@addr, :@family, :@mask_addr]"));
+  spg_vmasks4 = rb_eval_string("a = [0]*33; a[0] = 0; a[32] = 0xffffffff; 31.downto(1){|i| a[i] = a[i+1] - (1 << (31 - i))}; a.freeze");
+  rb_global_variable(&spg_vmasks4);
+  spg_vmasks6 = rb_eval_string("a = [0]*129; a[0] = 0; a[128] = 0xffffffffffffffffffffffffffffffff; 127.downto(1){|i| a[i] = a[i+1] - (1 << (127 - i))}; a.freeze");
+  rb_global_variable(&spg_vmasks6);
+
   c = rb_funcall(spg_Postgres, cg, 1, rb_str_new2("Dataset"));
   rb_undef_method(c, "yield_hash_rows");
   rb_define_private_method(c, "yield_hash_rows", spg_yield_hash_rows, 2);

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel_pg
 version: !ruby/object:Gem::Version
-  version: 1.9.0
+  version: 1.10.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-06 00:00:00.000000000 Z
+date: 2018-06-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.34.0
+        version: 4.38.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.34.0
+        version: 4.38.0
 description: |
   sequel_pg overwrites the inner loop of the Sequel postgres
   adapter row fetching code with a C version.  The C version
@@ -91,7 +91,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 3.0.0.beta1
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Faster SELECTs when using Sequel with pg