sequel_pg 1.11.0 → 1.17.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c587158ff9ea71f6a0ce019384c317b03b8c1a9c6027f363502e98f148b4a958
-  data.tar.gz: ad74cf362d21fe64409be4b29536709c5d6d6dbabe3a248a3cad5da5f282124f
+  metadata.gz: 61a49fada0595f92d8452ff231ff0d44ffadf59a887671c9d86178d957f95f44
+  data.tar.gz: 8969b6f0b9492e2f9edb087b57ef7b13993d61eeaabb9a0291478c1a227448ff
 SHA512:
-  metadata.gz: 39fb59374fe67630cea51820851b380f9537ef6769599ee43581855eb99e70c5251d03c70134a0512ad6ce36bc127704dcf152a2113de1461deb2839e19830c5
-  data.tar.gz: 470e31d71b43e3cad932cad0838805047d8d69013795a28d29b0099460a7a285ae5caae6a3e3950d61b80e30d2668cbf398fdc0dce1e16a1f970226e48c69cdb
+  metadata.gz: 7d5f69fd6e5f2a7dd3b067ca423c85ed2d9fc2f3af9ae191a19507ac3635e654699e5dac6c90ba1f910d5619cf8242a039e07752bfccbfed8c2a57a280fe0bb3
+  data.tar.gz: 899259457171fafd01c689f234da55255a06a4408ab7e58bcbdf8df94a409884a46ce3e613a2faabe9fbec350b65188d3d8a3e1821832b74d7ff9d145bbb16ef

data/CHANGELOG

@@ -1,3 +1,79 @@
+=== 1.17.2 (2025-03-14)
+
+* Add explicit arguments to PQfreemem casts to avoid compilation issues when using the C23 standard (jeremyevans) (#59)
+
+=== 1.17.1 (2023-01-05)
+
+* Modify LDFLAGS when building on MacOS to allow undefined functions (delphaber) (#53)
+
+=== 1.17.0 (2022-10-05)
+
+* Do not use pgresult_stream_any when using pg <1.4.4, to avoid double free in certain cases (larskanis) (#50)
+
+* Support new pgresult_stream_any API in pg 1.4.4 (larskanis) (#50)
+
+=== 1.16.0 (2022-08-16)
+
+* Fix memory leak when using streaming with pg 1.3.4+ (jeremyevans) (#48)
+
+* Modify LDFLAGS when building on MacOS arm64 to allow undefined functions (maxsz) (#46)
+
+* Adjust many internal C types to fix compilation warnings (jeremyevans)
+
+=== 1.15.0 (2022-03-16)
+
+* Avoid deprecation warning in the pg_streaming extension on pg 1.3+ when streaming a query with bound parameters (jeremyevans)
+
+* Use pgresult_stream_any when using pg 1.3.4+ for faster streaming (jeremyevans)
+
+* Do not use streaming by default for Dataset#paged_each in the pg_streaming extension (jeremyevans)
+
+* Avoid verbose warning if loading sequel_pg after Sequel pg_array extension (jeremyevans)
+
+=== 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)
+
+=== 1.12.1 (2019-05-31)
+
+* Avoid using Proc.new without block, fixing deprecation warning on ruby 2.7+ (jeremyevans)
+
+* Use rb_gc_register_mark_object instead of rb_global_variable (jeremyevans)
+
+* Use pkg_config instead of pg_config for configuration (jeremyevans) (#31)
+
+=== 1.12.0 (2019-03-01)
+
+* Allow Dataset#paged_each to be called without a block when using streaming (jeremyevans)
+
+* Freeze ruby strings used as temporary buffers for parsing arrays (jeremyevans)
+
 === 1.11.0 (2018-07-09)
 
 * Set encoding correctly for hash symbol keys (jeremyevans)

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
@@ -83,9 +77,16 @@ variables to specify the shared library and header directories.
 
 == 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 rake task from Sequel.
+sequel_pg is designed to replace a part of Sequel, so it should be tested
+using Sequel's specs (the spec_postgres rake task).  There is a spec_cov
+task that assumes you have Sequel checked out at ../sequel, and uses a
+small spec suite for parts of sequel_pg not covered by Sequel's specs.
+It sets the SEQUEL_PG_STREAM environment variable when running Sequel's
+specs, make sure that spec/spec_config.rb in Sequel is set to connect
+to PostgreSQL and use the following additional settings:
+
+  DB.extension(:pg_streaming)
+  DB.stream_all_queries = true
 
 == Reporting issues/bugs
 
@@ -118,19 +119,6 @@ requirements:
 
   rake build
 
-== Platforms Supported
-
-sequel_pg has been tested on the following:
-
-* ruby 1.9.3
-* ruby 2.0
-* ruby 2.1
-* ruby 2.2
-* ruby 2.3
-* ruby 2.4
-* ruby 2.5
-* ruby 2.6
-
 == Known Issues
 
 * You must be using the ISO PostgreSQL date format (which is the

data/Rakefile

@@ -1,7 +1,6 @@
-require "rake"
 require "rake/clean"
 
-CLEAN.include %w'**.rbc rdoc'
+CLEAN.include %w'**.rbc rdoc coverage'
 
 desc "Do a full cleaning"
 task :distclean do
@@ -19,3 +18,25 @@ begin
   Rake::ExtensionTask.new('sequel_pg')
 rescue LoadError
 end
+
+# This assumes you have sequel checked out in ../sequel, and that
+# spec_postgres is setup to run Sequel's PostgreSQL specs.
+desc "Run tests with coverage"
+task :spec_cov=>:compile do
+  ENV['RUBYLIB'] = "#{__dir__}/lib:#{ENV['RUBYLIB']}"
+  ENV['RUBYOPT'] = "-r #{__dir__}/spec/coverage_helper.rb #{ENV['RUBYOPT']}"
+  ENV['SIMPLECOV_COMMAND_NAME'] = "sequel_pg"
+  sh %'#{FileUtils::RUBY} -I ../sequel/lib spec/sequel_pg_spec.rb'
+
+  ENV['RUBYOPT'] = "-I lib -r sequel -r sequel/extensions/pg_array #{ENV['RUBYOPT']}"
+  ENV['SEQUEL_PG_STREAM'] = "1"
+  ENV['SIMPLECOV_COMMAND_NAME'] = "sequel"
+  sh %'cd ../sequel && #{FileUtils::RUBY} spec/adapter_spec.rb postgres'
+end
+
+desc "Run CI tests"
+task :spec_ci=>:compile do
+  ENV['SEQUEL_PG_SPEC_URL'] = ENV['SEQUEL_POSTGRES_URL'] = "postgres://localhost/?user=postgres&password=postgres"
+  sh %'#{FileUtils::RUBY} -I lib -I sequel/lib spec/sequel_pg_spec.rb'
+  sh %'cd sequel && #{FileUtils::RUBY} -I lib -I ../lib spec/adapter_spec.rb postgres'
+end

data/ext/sequel_pg/extconf.rb

@@ -1,6 +1,8 @@
 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/
+$LDFLAGS += " -Wl,-U,_pg_get_pgconn -Wl,-U,_pg_get_result_enc_idx -Wl,-U,_pgresult_get -Wl,-U,_pgresult_stream_any " if RUBY_PLATFORM =~ /darwin/
 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 11100
+#define SEQUEL_PG_VERSION_INTEGER 11702
 
 #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,12 @@
 /* External functions defined by ruby-pg */
 PGconn* pg_get_pgconn(VALUE);
 PGresult* pgresult_get(VALUE);
+int pg_get_result_enc_idx(VALUE);
+VALUE pgresult_stream_any(VALUE self, int (*yielder)(VALUE, int, int, void*), void* data);
 
 static int spg_use_ipaddr_alloc;
+static int spg_use_pg_get_result_enc_idx;
+static int spg_use_pg_stream_any;
 
 static VALUE spg_Sequel;
 static VALUE spg_PGArray;
@@ -198,10 +199,10 @@ static int enc_get_index(VALUE val) {
   } while(0)
 
 static VALUE
-pg_text_dec_integer(char *val, int len)
+pg_text_dec_integer(char *val, size_t len)
 {
   long i;
-  int max_len;
+  size_t max_len;
 
   if( sizeof(i) >= 8 && FIXNUM_MAX >= 1000000000000000000LL ){
     /* 64 bit system can safely handle all numbers up to 18 digits as Fixnum */
@@ -256,7 +257,7 @@ pg_text_dec_integer(char *val, int len)
 
 static VALUE spg__array_col_value(char *v, size_t length, VALUE converter, int enc_index, int oid, VALUE db);
 
-static VALUE read_array(int *index, char *c_pg_array_string, int array_string_length, VALUE buf, VALUE converter, int enc_index, int oid, VALUE db) {
+static VALUE read_array(int *index, char *c_pg_array_string, long array_string_length, VALUE buf, VALUE converter, int enc_index, int oid, VALUE db) {
   int word_index = 0;
   char *word = RSTRING_PTR(buf);
 
@@ -352,7 +353,7 @@ static VALUE read_array(int *index, char *c_pg_array_string, int array_string_le
   return array;
 }
 
-static VALUE check_pg_array(int* index, char *c_pg_array_string, int array_string_length) {
+static VALUE check_pg_array(int* index, char *c_pg_array_string, long array_string_length) {
   if (array_string_length == 0) {
     rb_raise(rb_eArgError, "unexpected PostgreSQL array format, empty");
   } else if (array_string_length == 2 && c_pg_array_string[0] == '{' && c_pg_array_string[0] == '}') {
@@ -383,7 +384,7 @@ static VALUE parse_pg_array(VALUE self, VALUE pg_array_string, VALUE converter)
   /* convert to c-string, create additional ruby string buffer of
    * the same length, as that will be the worst case. */
   char *c_pg_array_string = StringValueCStr(pg_array_string);
-  int array_string_length = RSTRING_LEN(pg_array_string);
+  long array_string_length = RSTRING_LEN(pg_array_string);
   int index = 1;
   VALUE ary;
 
@@ -391,10 +392,14 @@ static VALUE parse_pg_array(VALUE self, VALUE pg_array_string, VALUE converter)
     return ary;
   }
 
+  ary = rb_str_buf_new(array_string_length);
+  rb_str_set_len(ary, array_string_length);
+  rb_obj_freeze(ary);
+
   return read_array(&index,
     c_pg_array_string,
     array_string_length,
-    rb_str_buf_new(array_string_length),
+    ary,
     converter,
     enc_get_index(pg_array_string),
     0,
@@ -405,7 +410,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);
@@ -529,7 +534,7 @@ static VALUE spg_timestamp(const char *s, VALUE self, size_t length, int tz) {
   }
 
   if (remaining < 19) {
-    return spg_timestamp_error(s, self, "unexpected timetamp format, too short");
+    return spg_timestamp_error(s, self, "unexpected timestamp format, too short");
   }
 
   year = parse_year(&p, &remaining);
@@ -625,7 +630,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;
@@ -697,8 +702,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));
       } 
@@ -853,7 +858,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) {
@@ -870,7 +879,7 @@ static VALUE spg__array_col_value(char *v, size_t length, VALUE converter, int e
       break;
     case 17: /* bytea */
       bi.blob_string = (char *)PQunescapeBytea((unsigned char*)v, &bi.length);
-      rv = rb_ensure(spg_create_Blob, (VALUE)&bi, (VALUE(*)())PQfreemem, (VALUE)bi.blob_string);
+      rv = rb_ensure(spg_create_Blob, (VALUE)&bi, (VALUE(*)(VALUE))PQfreemem, (VALUE)bi.blob_string);
       break;
     case 20: /* integer */
     case 21:
@@ -921,8 +930,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);
@@ -936,6 +947,7 @@ static VALUE spg__array_col_value(char *v, size_t length, VALUE converter, int e
 
 static VALUE spg_array_value(char *c_pg_array_string, int array_string_length, VALUE converter, int enc_index, int oid, VALUE self, VALUE array_type) {
   int index = 1;
+  VALUE buf;
   VALUE args[2];
   args[1] = array_type;
 
@@ -943,7 +955,10 @@ static VALUE spg_array_value(char *c_pg_array_string, int array_string_length, V
     return rb_class_new_instance(2, args, spg_PGArray);
   }
 
-  args[0] = read_array(&index, c_pg_array_string, array_string_length, rb_str_buf_new(array_string_length), converter, enc_index, oid, self);
+  buf = rb_str_buf_new(array_string_length);
+  rb_str_set_len(buf, array_string_length);
+  rb_obj_freeze(buf);
+  args[0] = read_array(&index, c_pg_array_string, array_string_length, buf, converter, enc_index, oid, self);
   return rb_class_new_instance(2, args, spg_PGArray);
 }
 
@@ -997,12 +1012,12 @@ static int spg_timestamp_info_bitmask(VALUE self) {
   return tz;
 }
 
-static VALUE spg__col_value(VALUE self, PGresult *res, long i, long j, VALUE* colconvert, int enc_index) {
+static VALUE spg__col_value(VALUE self, PGresult *res, int i, int j, VALUE* colconvert, int enc_index) {
   char *v;
   VALUE rv;
   int ftype = PQftype(res, j);
   VALUE array_type;
-  VALUE scalar_oid;
+  int scalar_oid;
   struct spg_blob_initialization bi;
 
   if(PQgetisnull(res, i, j)) {
@@ -1016,7 +1031,7 @@ static VALUE spg__col_value(VALUE self, PGresult *res, long i, long j, VALUE* co
         break;
       case 17: /* bytea */
         bi.blob_string = (char *)PQunescapeBytea((unsigned char*)v, &bi.length);
-        rv = rb_ensure(spg_create_Blob, (VALUE)&bi, (VALUE(*)())PQfreemem, (VALUE)bi.blob_string);
+        rv = rb_ensure(spg_create_Blob, (VALUE)&bi, (VALUE(*)(VALUE))PQfreemem, (VALUE)bi.blob_string);
         break;
       case 20: /* integer */
       case 21:
@@ -1065,10 +1080,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:
@@ -1206,17 +1217,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) {
@@ -1227,20 +1251,20 @@ static VALUE spg__col_value(VALUE self, PGresult *res, long i, long j, VALUE* co
   return rv;
 }
 
-static VALUE spg__col_values(VALUE self, VALUE v, VALUE *colsyms, long nfields, PGresult *res, long i, VALUE *colconvert, int enc_index) {
+static VALUE spg__col_values(VALUE self, VALUE v, VALUE *colsyms, long nfields, PGresult *res, int i, VALUE *colconvert, int enc_index) {
   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));
+    rb_ary_store(a, j, cur == Qnil ? Qnil : spg__col_value(self, res, i, NUM2INT(cur), colconvert, enc_index));
   }
   return a;
 }
 
-static long spg__field_id(VALUE v, VALUE *colsyms, long nfields) {
-  long j;
+static int spg__field_id(VALUE v, VALUE *colsyms, long nfields) {
+  int j;
   for (j=0; j<nfields; j++) {
     if (colsyms[j] == v) {
       return j;
@@ -1251,7 +1275,7 @@ static long spg__field_id(VALUE v, VALUE *colsyms, long nfields) {
 
 static VALUE spg__field_ids(VALUE v, VALUE *colsyms, long nfields) {
   long i;
-  long j;
+  int j;
   VALUE cur;
   long len = RARRAY_LEN(v);
   VALUE pg_columns = rb_ary_new2(len);
@@ -1264,9 +1288,9 @@ static VALUE spg__field_ids(VALUE v, VALUE *colsyms, long nfields) {
 }
 
 static void spg_set_column_info(VALUE self, PGresult *res, VALUE *colsyms, VALUE *colconvert, int enc_index) {
-  long i;
-  long j;
-  long nfields;
+  int i;
+  int j;
+  int nfields;
   int timestamp_info = 0;
   int time_info = 0;
   VALUE conv_procs = 0;
@@ -1355,34 +1379,19 @@ 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];
-  long ntuples;
-  long nfields;
-  long i;
-  long j;
+static VALUE spg_yield_hash_rows_internal(VALUE self, PGresult *res, int enc_index, VALUE* colsyms, VALUE* colconvert) {
+  int ntuples;
+  int nfields;
+  int i;
+  int j;
   VALUE h;
   VALUE opts;
   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);
@@ -1474,7 +1483,7 @@ static VALUE spg_yield_hash_rows(VALUE self, VALUE rres, VALUE ignore) {
     case SPG_YIELD_KV_HASH_GROUPS:
       /* Hash with single key and single value */
       {
-        VALUE k, v;
+        int 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);
@@ -1502,7 +1511,8 @@ static VALUE spg_yield_hash_rows(VALUE self, VALUE rres, VALUE ignore) {
     case SPG_YIELD_MKV_HASH_GROUPS:
       /* Hash with array of keys and single value */
       {
-        VALUE k, v;
+        VALUE k;
+        int 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);
@@ -1530,7 +1540,8 @@ static VALUE spg_yield_hash_rows(VALUE self, VALUE rres, VALUE ignore) {
     case SPG_YIELD_KMV_HASH_GROUPS:
       /* Hash with single keys and array of values */
       {
-        VALUE k, v;
+        VALUE v;
+        int k;
         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);
@@ -1599,6 +1610,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;
+  int 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 (%d columns detected)", nfields);
+
+  /* UNREACHABLE */
+  return self;
+}
+
 static VALUE spg_supports_streaming_p(VALUE self) {
   return
 #if HAVE_PQSETSINGLEROWMODE
@@ -1618,32 +1663,50 @@ 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];
-  long nfields;
-  long j;
+struct spg__yield_each_row_stream_data {
+  VALUE self;
+  VALUE *colsyms;
+  VALUE *colconvert;
+  VALUE pg_value;
+  int enc_index;
+  char type;
+};
+
+static int spg__yield_each_row_stream(VALUE rres, int ntuples, int nfields, void *rdata) {
+  struct spg__yield_each_row_stream_data* data = (struct spg__yield_each_row_stream_data *)rdata;
+  VALUE h = rb_hash_new();
+  VALUE self = data->self;
+  VALUE *colsyms = data->colsyms;
+  VALUE *colconvert= data->colconvert;
+  PGresult *res = pgresult_get(rres);
+  int enc_index = data->enc_index;
+  int j;
+
+  for(j=0; j<nfields; j++) {
+    rb_hash_aset(h, colsyms[j], spg__col_value(self, res, 0, j, colconvert , enc_index));
+  }
+
+  if(data->type == SPG_YIELD_MODEL) {
+    VALUE model = rb_obj_alloc(data->pg_value);
+    rb_ivar_set(model, spg_id_values, h);
+    rb_yield(model);
+  } else {
+    rb_yield(h);
+  }
+  return 1; /* clear the result */
+}
+
+static VALUE spg__yield_each_row_internal(VALUE self, VALUE rconn, VALUE rres, PGresult *res, int enc_index, VALUE *colsyms, VALUE *colconvert) {
+  int nfields;
+  int j;
   VALUE h;
   VALUE opts;
   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);
+  struct spg__yield_each_row_stream_data data;
 
-  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
@@ -1657,14 +1720,20 @@ 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);
 
+  if (spg_use_pg_stream_any) {
+    data.self = self;
+    data.colsyms = colsyms;
+    data.colconvert = colconvert;
+    data.pg_value = pg_value;
+    data.enc_index = enc_index;
+    data.type = type;
+    
+    pgresult_stream_any(rres, spg__yield_each_row_stream, &data);
+    return self;
+  }
+
   while (PQntuples(res) != 0) {
     h = rb_hash_new();
     for(j=0; j<nfields; j++) {
@@ -1684,14 +1753,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;
+  int 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 (%d columns detected)", nfields);
+  }
+
+  /* UNREACHABLE */
   return self;
 }
 
@@ -1737,7 +1849,7 @@ void Init_sequel_pg(void) {
   VALUE c, spg_Postgres;
 
   spg_Sequel = rb_const_get(rb_cObject, rb_intern("Sequel"));
-  rb_global_variable(&spg_Sequel);
+  rb_gc_register_mark_object(spg_Sequel);
   spg_Postgres = rb_const_get(spg_Sequel, rb_intern("Postgres"));
 
   if(rb_obj_respond_to(spg_Postgres, rb_intern("sequel_pg_version_supported?"), 0)) {
@@ -1746,7 +1858,22 @@ void Init_sequel_pg(void) {
       return;
     }
   }
-  
+
+  c = rb_eval_string("defined?(PG::VERSION) && PG::VERSION.split('.').map(&:to_i)");
+  if (RB_TYPE_P(c, T_ARRAY) && RARRAY_LEN(c) >= 3) {
+    if (FIX2INT(RARRAY_AREF(c, 0)) > 1) {
+      spg_use_pg_get_result_enc_idx = 1;
+      spg_use_pg_stream_any = 1;
+    } else if (FIX2INT(RARRAY_AREF(c, 0)) == 1) {
+      if (FIX2INT(RARRAY_AREF(c, 1)) >= 2) {
+        spg_use_pg_get_result_enc_idx = 1;
+      }
+      if (FIX2INT(RARRAY_AREF(c, 1)) > 4 || (FIX2INT(RARRAY_AREF(c, 1)) == 4 && FIX2INT(RARRAY_AREF(c, 2)) >= 4)) {
+        spg_use_pg_stream_any = 1;
+      }
+    }
+  }
+
   rb_const_set(spg_Postgres, rb_intern("SEQUEL_PG_VERSION_INTEGER"), INT2FIX(SEQUEL_PG_VERSION_INTEGER));
 
   spg_id_BigDecimal = rb_intern("BigDecimal");
@@ -1829,35 +1956,35 @@ void Init_sequel_pg(void) {
   spg_sym_cidr = ID2SYM(rb_intern("cidr"));
 
   spg_Blob = rb_const_get(rb_const_get(spg_Sequel, rb_intern("SQL")), rb_intern("Blob")); 
-  rb_global_variable(&spg_Blob);
+  rb_gc_register_mark_object(spg_Blob);
   spg_Blob_instance = rb_obj_freeze(rb_funcall(spg_Blob, spg_id_new, 0));
-  rb_global_variable(&spg_Blob_instance);
+  rb_gc_register_mark_object(spg_Blob_instance);
   spg_SQLTime = rb_const_get(spg_Sequel, rb_intern("SQLTime")); 
-  rb_global_variable(&spg_SQLTime);
+  rb_gc_register_mark_object(spg_SQLTime);
   spg_Date = rb_const_get(rb_cObject, rb_intern("Date")); 
-  rb_global_variable(&spg_Date);
+  rb_gc_register_mark_object(spg_Date);
   spg_DateTime = rb_const_get(rb_cObject, rb_intern("DateTime")); 
-  rb_global_variable(&spg_DateTime);
+  rb_gc_register_mark_object(spg_DateTime);
   spg_PGError = rb_const_get(rb_const_get(rb_cObject, rb_intern("PG")), rb_intern("Error"));
-  rb_global_variable(&spg_PGError);
+  rb_gc_register_mark_object(spg_PGError);
 
   spg_nan = rb_eval_string("0.0/0.0");
-  rb_global_variable(&spg_nan);
+  rb_gc_register_mark_object(spg_nan);
   spg_pos_inf = rb_eval_string("1.0/0.0");
-  rb_global_variable(&spg_pos_inf);
+  rb_gc_register_mark_object(spg_pos_inf);
   spg_neg_inf = rb_eval_string("-1.0/0.0");
-  rb_global_variable(&spg_neg_inf);
+  rb_gc_register_mark_object(spg_neg_inf);
   spg_usec_per_day = ULL2NUM(86400000000ULL);
-  rb_global_variable(&spg_usec_per_day);
+  rb_gc_register_mark_object(spg_usec_per_day);
 
   rb_require("ipaddr");
   spg_IPAddr = rb_const_get(rb_cObject, rb_intern("IPAddr"));
-  rb_global_variable(&spg_IPAddr);
+  rb_gc_register_mark_object(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);
+  rb_gc_register_mark_object(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);
+  rb_gc_register_mark_object(spg_vmasks6);
 
   c = rb_const_get(spg_Postgres, rb_intern("Dataset"));
   rb_undef_method(c, "yield_hash_rows");
@@ -1883,5 +2010,5 @@ void Init_sequel_pg(void) {
 
   rb_require("sequel/extensions/pg_array");
   spg_PGArray = rb_const_get(spg_Postgres, rb_intern("PGArray"));
-  rb_global_variable(&spg_PGArray);
+  rb_gc_register_mark_object(spg_PGArray);
 }

data/lib/sequel/extensions/pg_streaming.rb

@@ -1,9 +1,11 @@
+# :nocov:
 unless Sequel::Postgres.respond_to?(:supports_streaming?)
   raise LoadError, "either sequel_pg not loaded, or an old version of sequel_pg loaded"
 end
 unless Sequel::Postgres.supports_streaming?
   raise LoadError, "streaming is not supported by the version of libpq in use"
 end
+# :nocov:
 
 # Database methods necessary to support streaming.  You should load this extension
 # into your database object:
@@ -73,12 +75,20 @@ module Sequel::Postgres::Streaming
 
     private
 
+    # :nocov:
+    unless Sequel::Postgres::Adapter.method_defined?(:send_query_params)
+      def send_query_params(*args)
+        send_query(*args)
+      end
+    end
+    # :nocov:
+
     if Sequel::Database.instance_methods.map(&:to_s).include?('log_connection_yield')
       # If using single row mode, send the query instead of executing it.
       def execute_query(sql, args)
         if @single_row_mode
           @single_row_mode = false
-          @db.log_connection_yield(sql, self, args){args ? send_query(sql, args) : send_query(sql)}
+          @db.log_connection_yield(sql, self, args){args ? send_query_params(sql, args) : send_query(sql)}
           set_single_row_mode
           block
           self
@@ -87,6 +97,7 @@ module Sequel::Postgres::Streaming
         end
       end
     else
+      # :nocov:
       def execute_query(sql, args)
         if @single_row_mode
           @single_row_mode = false
@@ -98,6 +109,7 @@ module Sequel::Postgres::Streaming
           super
         end
       end
+      # :nocov:
     end
   end
 
@@ -119,7 +131,15 @@ module Sequel::Postgres::Streaming
 
     # Use streaming to implement paging.
     def paged_each(opts=Sequel::OPTS, &block)
-      stream.each(&block)
+      unless block_given?
+        return enum_for(:paged_each, opts)
+      end
+
+      if stream_results?
+        each(&block)
+      else
+        super
+      end
     end
 
     # Return a clone of the dataset that will use streaming to load

data/lib/sequel_pg/sequel_pg.rb

@@ -53,11 +53,13 @@ class Sequel::Postgres::Dataset
     end
   end
 
+  # :nocov:
   unless Sequel::Dataset.method_defined?(:as_hash)
     # Handle previous versions of Sequel that use to_hash instead of as_hash
     alias to_hash as_hash
     remove_method :as_hash
   end
+  # :nocov:
 
   # In the case where both arguments given, use an optimized version.
   def to_hash_groups(key_column, value_column = nil, opts = Sequel::OPTS)
@@ -74,9 +76,9 @@ class Sequel::Postgres::Dataset
   if defined?(Sequel::Model::ClassMethods)
     # If model loads are being optimized and this is a model load, use the optimized
     # version.
-    def each
+    def each(&block)
       if optimize_model_load?
-        clone(:_sequel_pg_type=>:model, :_sequel_pg_value=>row_proc).fetch_rows(sql, &Proc.new)
+        clone(:_sequel_pg_type=>:model, :_sequel_pg_value=>row_proc).fetch_rows(sql, &block)
       else
         super
       end
@@ -120,6 +122,11 @@ if defined?(Sequel::Postgres::PGArray)
   # pg_array extension previously loaded
 
   class Sequel::Postgres::PGArray::Creator
+    # :nocov:
+    # Avoid method redefined verbose warning
+    alias call call if method_defined?(:call)
+    # :nocov:
+
     # Override Creator to use sequel_pg's C-based parser instead of the pure ruby parser.
     def call(string)
       Sequel::Postgres::PGArray.new(Sequel::Postgres.parse_pg_array(string, @converter), @type)

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: sequel_pg
 version: !ruby/object:Gem::Version
-  version: 1.11.0
+  version: 1.17.2
 platform: ruby
 authors:
 - Jeremy Evans
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-09 00:00:00.000000000 Z
+date: 2025-03-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -17,6 +16,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 +26,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
@@ -67,8 +72,12 @@ files:
 homepage: http://github.com/jeremyevans/sequel_pg
 licenses:
 - MIT
-metadata: {}
-post_install_message: 
+metadata:
+  bug_tracker_uri: https://github.com/jeremyevans/sequel_pg/issues
+  changelog_uri: https://github.com/jeremyevans/sequel_pg/blob/master/CHANGELOG
+  documentation_uri: https://github.com/jeremyevans/sequel_pg/blob/master/README.rdoc
+  mailing_list_uri: https://github.com/jeremyevans/sequel_pg/discussions
+  source_code_uri: https://github.com/jeremyevans/sequel_pg
 rdoc_options:
 - "--quiet"
 - "--line-numbers"
@@ -90,9 +99,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
-signing_key: 
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Faster SELECTs when using Sequel with pg
 test_files: []