sequel_pg 1.12.2 → 1.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a66312d2f3a6446adc3a43ac5bf4fe9651136a89d645e02f7e0f0da8228ddb97
-  data.tar.gz: 80f9ab2109eb0571a820f4e29efb6261adcaaf6f9013005b6565e8d37ef21ef6
+  metadata.gz: 277c659f136e9d34a715ccd94bab948b776d903f72b0f679fd919bedacef9cf7
+  data.tar.gz: 031cd967776330ecc1c999c8597c49eb5a96f376dfcc88c51ab9d9bdbda52190
 SHA512:
-  metadata.gz: 073a1004d8f109314aead84089cc0a3d3810c29ece58a89eac8d9750bf64b645998a4df8fdc3c23ad8608a7aec52b46066911b366b72acd124c19baf1a328378
-  data.tar.gz: '05806296363f8df23db1c4454d1d601eb938aebbed17f5c599535374ff4cc4405e71245f8ee44242e81f850d0e86914ae5d52fe7b14cd0c0dbdd8b507f8ec4c9'
+  metadata.gz: 7b722922bf49095005ad19bc7bb1ba41d358d851f367df6f51bd5fbf0202784244cee83293919ee27fb1ff7accb3fb10ddbbc7745455cf545f2b1a7a7e301bdd
+  data.tar.gz: 2b3933ab84065cdd81b5c544523ba4c50192acbc912b449d4d4f03d5650873a5ad125fc3f339a435cbcc514d350bbf6e98d49d10f39349faa9cb8b2c7236fa61

data/CHANGELOG

@@ -1,3 +1,29 @@
+=== 1.14.0 (2020-09-22)
+
+* Reduce stack memory usage for result sets with 64 or fewer columns (jeremyevans)
+
+* Support result sets with more than 256 columns by default (jeremyevans) (#39)
+
+=== 1.13.0 (2020-04-13)
+
+* Allow overriding of inet/cidr type conversion using conversion procs (beanieboi, jeremyevans) (#36, #37)
+
+=== 1.12.5 (2020-03-23)
+
+* Fix offset calculation for timestamptz types when datetime_class is DateTime and using local application timezone (jeremyevans)
+
+* Fix wrong method call when parsing timestamptz types when datetime_class is Time and using utc database timezone and local application timezone (jeremyevans)
+
+=== 1.12.4 (2020-01-02)
+
+* Work with pg 1.2.1+ (jeremyevans)
+
+=== 1.12.3 (2020-01-02)
+
+* Warn and do not load sequel_pg if pg >1.2 is used (jeremyevans)
+
+* Avoid verbose warnings on Ruby 2.7 due to tainting (jeremyevans)
+
 === 1.12.2 (2019-06-06)
 
 * Avoid use of pkg_config as it breaks compilation in some environments (jeremyevans) (#33)

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2010-2018 Jeremy Evans
+Copyright (c) 2010-2020 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

data/README.rdoc

@@ -70,12 +70,6 @@ can do the following:
 
   gem install sequel_pg
 
-Note that by default sequel_pg only supports result sets with up to
-256 columns. If you will have a result set with more than 256 columns,
-you should modify the maximum supported number of columns via:
-
-   gem install sequel_pg -- --with-cflags=\"-DSPG_MAX_FIELDS=512\"
-
 Make sure the pg_config binary is in your PATH so the installation
 can find the PostgreSQL shared library and header files.  Alternatively,
 you can use the POSTGRES_LIB and POSTGRES_INCLUDE environment
@@ -130,6 +124,7 @@ sequel_pg has been tested on the following:
 * ruby 2.4
 * ruby 2.5
 * ruby 2.6
+* ruby 2.7
 
 == Known Issues
 

data/ext/sequel_pg/extconf.rb

@@ -1,5 +1,6 @@
 require 'mkmf'
 $CFLAGS << " -O0 -g" if ENV['DEBUG']
+$CFLAGS << " -Drb_tainted_str_new=rb_str_new -DNO_TAINT" if RUBY_VERSION >= '2.7'
 $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))

data/ext/sequel_pg/sequel_pg.c

@@ -1,4 +1,4 @@
-#define SEQUEL_PG_VERSION_INTEGER 11202
+#define SEQUEL_PG_VERSION_INTEGER 11400
 
 #include <string.h>
 #include <stdio.h>
@@ -15,9 +15,6 @@
 #include <ruby/version.h>
 #include <ruby/encoding.h>
 
-#ifndef SPG_MAX_FIELDS
-#define SPG_MAX_FIELDS 256
-#endif
 #define SPG_MINUTES_PER_DAY 1440.0
 #define SPG_SECONDS_PER_DAY 86400.0
 
@@ -72,8 +69,10 @@
 /* External functions defined by ruby-pg */
 PGconn* pg_get_pgconn(VALUE);
 PGresult* pgresult_get(VALUE);
+int pg_get_result_enc_idx(VALUE);
 
 static int spg_use_ipaddr_alloc;
+static int spg_use_pg_get_result_enc_idx;
 
 static VALUE spg_Sequel;
 static VALUE spg_PGArray;
@@ -409,7 +408,7 @@ static VALUE spg_timestamp_error(const char *s, VALUE self, const char *error_ms
   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));
+      return rb_funcall(self, spg_id_infinite_timestamp_value, 1, rb_tainted_str_new(s, strlen(s)));
     }
   }
   rb_raise(rb_eArgError, "%s", error_msg);
@@ -629,7 +628,7 @@ static VALUE spg_timestamp(const char *s, VALUE self, size_t length, int tz) {
         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);
+          dt = rb_funcall(dt, spg_id_localtime, 0);
         } 
 
         return dt;
@@ -701,8 +700,8 @@ static VALUE spg_timestamp(const char *s, VALUE self, size_t length, int tz) {
       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));
+        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(dt, spg_id_new_offset, 1, rb_float_new(offset_fraction));
       } else if (tz & SPG_APP_UTC) {
         dt = rb_funcall(dt, spg_id_new_offset, 1, INT2NUM(0));
       } 
@@ -857,7 +856,11 @@ static VALUE spg_create_Blob(VALUE 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));
+  v = rb_str_new_with_class(spg_Blob_instance, bi->blob_string, bi->length);
+#ifndef NO_TAINT
+  rb_obj_taint(v);
+#endif
+  return v;
 }
 
 static VALUE spg_fetch_rows_set_cols(VALUE self, VALUE ignore) {
@@ -925,8 +928,10 @@ static VALUE spg__array_col_value(char *v, size_t length, VALUE converter, int e
       break;
     case 869: /* inet */
     case 650: /* cidr */
-      rv = spg_inet(v, length);
-      break;
+      if (!RTEST(converter)) {
+        rv = spg_inet(v, length);
+        break;
+      }
     default:
       rv = rb_tainted_str_new(v, length);
       PG_ENCODING_SET_NOCHECK(rv, enc_index);
@@ -1073,10 +1078,6 @@ 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:
@@ -1214,17 +1215,30 @@ static VALUE spg__col_value(VALUE self, PGresult *res, long i, long j, VALUE* co
             scalar_oid = 22;
             break;
           case 1041:
+            if (RTEST(colconvert[j])) {
+              goto default_cond;
+            }
             array_type = spg_sym_inet;
             scalar_oid = 869;
             break;
           case 651:
+            if (RTEST(colconvert[j])) {
+              goto default_cond;
+            }
             array_type = spg_sym_cidr;
             scalar_oid = 650;
             break;
         }
         rv = spg_array_value(v, PQgetlength(res, i, j), colconvert[j], enc_index, scalar_oid, self, array_type);
         break;
+      case 869: /* inet */
+      case 650: /* cidr */
+        if (colconvert[j] == Qnil) {
+          rv = spg_inet(v, PQgetlength(res, i, j));
+          break;
+        }
       default:
+      default_cond:
         rv = rb_tainted_str_new(v, PQgetlength(res, i, j));
         PG_ENCODING_SET_NOCHECK(rv, enc_index);
         if (colconvert[j] != Qnil) {
@@ -1363,10 +1377,7 @@ static void spg_set_column_info(VALUE self, PGresult *res, VALUE *colsyms, VALUE
   rb_funcall(self, spg_id_columns_equal, 1, rb_ary_new4(nfields, colsyms));
 }
 
-static VALUE spg_yield_hash_rows(VALUE self, VALUE rres, VALUE ignore) {
-  PGresult *res;
-  VALUE colsyms[SPG_MAX_FIELDS];
-  VALUE colconvert[SPG_MAX_FIELDS];
+static VALUE spg_yield_hash_rows_internal(VALUE self, PGresult *res, int enc_index, VALUE* colsyms, VALUE* colconvert) {
   long ntuples;
   long nfields;
   long i;
@@ -1376,21 +1387,9 @@ 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;
-  }
-  res = pgresult_get(rres);
-
-  enc_index = enc_get_index(rres);
 
   ntuples = PQntuples(res);
   nfields = PQnfields(res);
-  if (nfields > SPG_MAX_FIELDS) {
-    rb_raise(rb_eRangeError, "more than %d columns in query (%ld columns detected)", SPG_MAX_FIELDS, nfields);
-  }
-
   spg_set_column_info(self, res, colsyms, colconvert, enc_index);
 
   opts = rb_funcall(self, spg_id_opts, 0);
@@ -1607,6 +1606,40 @@ static VALUE spg_yield_hash_rows(VALUE self, VALUE rres, VALUE ignore) {
   return self;
 }
 
+#define def_spg_yield_hash_rows(max_fields) static VALUE spg_yield_hash_rows_ ## max_fields(VALUE self, PGresult *res, int enc_index) { \
+  VALUE colsyms[max_fields]; \
+  VALUE colconvert[max_fields]; \
+  return spg_yield_hash_rows_internal(self, res, enc_index, colsyms, colconvert); \
+}
+
+def_spg_yield_hash_rows(16)
+def_spg_yield_hash_rows(64)
+def_spg_yield_hash_rows(256)
+def_spg_yield_hash_rows(1664)
+
+static VALUE spg_yield_hash_rows(VALUE self, VALUE rres, VALUE ignore) {
+  PGresult *res;
+  long nfields;
+  int enc_index;
+
+  if (!RTEST(rres)) {
+    return self;
+  }
+  res = pgresult_get(rres);
+
+  enc_index = spg_use_pg_get_result_enc_idx ? pg_get_result_enc_idx(rres) : enc_get_index(rres);
+
+  nfields = PQnfields(res);
+  if (nfields <= 16) return spg_yield_hash_rows_16(self, res, enc_index);
+  else if (nfields <= 64) return spg_yield_hash_rows_64(self, res, enc_index);
+  else if (nfields <= 256) return spg_yield_hash_rows_256(self, res, enc_index);
+  else if (nfields <= 1664) return spg_yield_hash_rows_1664(self, res, enc_index);
+  else rb_raise(rb_eRangeError, "more than 1664 columns in query (%ld columns detected)", nfields);
+
+  /* UNREACHABLE */
+  return self;
+}
+
 static VALUE spg_supports_streaming_p(VALUE self) {
   return
 #if HAVE_PQSETSINGLEROWMODE
@@ -1626,12 +1659,7 @@ static VALUE spg_set_single_row_mode(VALUE self) {
   return Qnil;
 }
 
-static VALUE spg__yield_each_row(VALUE self) {
-  PGresult *res;
-  VALUE rres;
-  VALUE rconn;
-  VALUE colsyms[SPG_MAX_FIELDS];
-  VALUE colconvert[SPG_MAX_FIELDS];
+static VALUE spg__yield_each_row_internal(VALUE self, VALUE rconn, VALUE rres, PGresult *res, int enc_index, VALUE *colsyms, VALUE *colconvert) {
   long nfields;
   long j;
   VALUE h;
@@ -1639,19 +1667,8 @@ 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);
-
-  rres = rb_funcall(rconn, spg_id_get_result, 0);
-  if (rres == Qnil) {
-    goto end_yield_each_row;
-  }
-  rb_funcall(rres, spg_id_check, 0);
-  res = pgresult_get(rres);
 
-  enc_index = enc_get_index(rres);
+  nfields = PQnfields(res);
 
   /* Only handle regular and model types.  All other types require compiling all
    * of the results at once, which is not a use case for streaming.  The streaming
@@ -1665,12 +1682,6 @@ static VALUE spg__yield_each_row(VALUE self) {
     }
   }
 
-  nfields = PQnfields(res);
-  if (nfields > SPG_MAX_FIELDS) {
-    rb_funcall(rres, spg_id_clear, 0);
-    rb_raise(rb_eRangeError, "more than %d columns in query", SPG_MAX_FIELDS);
-  }
-
   spg_set_column_info(self, res, colsyms, colconvert, enc_index);
 
   while (PQntuples(res) != 0) {
@@ -1692,14 +1703,57 @@ static VALUE spg__yield_each_row(VALUE self) {
 
     rres = rb_funcall(rconn, spg_id_get_result, 0);
     if (rres == Qnil) {
-      goto end_yield_each_row;
+      return self;
     }
     rb_funcall(rres, spg_id_check, 0);
     res = pgresult_get(rres);
   }
   rb_funcall(rres, spg_id_clear, 0);
 
-end_yield_each_row:
+  return self;
+}
+
+#define def_spg__yield_each_row(max_fields) static VALUE spg__yield_each_row_ ## max_fields(VALUE self, VALUE rconn, VALUE rres, PGresult *res, int enc_index) { \
+  VALUE colsyms[max_fields]; \
+  VALUE colconvert[max_fields]; \
+  return spg__yield_each_row_internal(self, rconn, rres, res, enc_index, colsyms, colconvert); \
+}
+
+def_spg__yield_each_row(16)
+def_spg__yield_each_row(64)
+def_spg__yield_each_row(256)
+def_spg__yield_each_row(1664)
+
+static VALUE spg__yield_each_row(VALUE self) {
+  PGresult *res;
+  VALUE rres;
+  VALUE rconn;
+  int enc_index;
+  long nfields;
+
+  rconn = rb_ary_entry(self, 1);
+  self = rb_ary_entry(self, 0);
+
+  rres = rb_funcall(rconn, spg_id_get_result, 0);
+  if (rres == Qnil) {
+    return self;
+  }
+  rb_funcall(rres, spg_id_check, 0);
+  res = pgresult_get(rres);
+
+  enc_index = spg_use_pg_get_result_enc_idx ? pg_get_result_enc_idx(rres) : enc_get_index(rres);
+
+  nfields = PQnfields(res);
+  if (nfields <= 16) return spg__yield_each_row_16(self, rconn, rres, res, enc_index);
+  else if (nfields <= 64) return spg__yield_each_row_64(self, rconn, rres, res, enc_index);
+  else if (nfields <= 256) return spg__yield_each_row_256(self, rconn, rres, res, enc_index);
+  else if (nfields <= 1664) return spg__yield_each_row_1664(self, rconn, rres, res, enc_index);
+  else {
+    rb_funcall(rres, spg_id_clear, 0);
+    rb_raise(rb_eRangeError, "more than 1664 columns in query (%ld columns detected)", nfields);
+  }
+
+  /* UNREACHABLE */
   return self;
 }
 
@@ -1754,6 +1808,10 @@ void Init_sequel_pg(void) {
       return;
     }
   }
+
+  if (RTEST(rb_eval_string("defined?(PG::VERSION) && PG::VERSION.to_f >= 1.2"))) {
+    spg_use_pg_get_result_enc_idx = 1;
+  }
   
   rb_const_set(spg_Postgres, rb_intern("SEQUEL_PG_VERSION_INTEGER"), INT2FIX(SEQUEL_PG_VERSION_INTEGER));
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel_pg
 version: !ruby/object:Gem::Version
-  version: 1.12.2
+  version: 1.14.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-06 00:00:00.000000000 Z
+date: 2020-09-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -17,6 +17,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.18.0
+    - - "!="
+      - !ruby/object:Gem::Version
+        version: 1.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -24,6 +27,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.18.0
+    - - "!="
+      - !ruby/object:Gem::Version
+        version: 1.2.0
 - !ruby/object:Gem::Dependency
   name: sequel
   requirement: !ruby/object:Gem::Requirement
@@ -95,7 +101,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Faster SELECTs when using Sequel with pg