sequel_pg 1.17.2 → 1.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 61a49fada0595f92d8452ff231ff0d44ffadf59a887671c9d86178d957f95f44
-  data.tar.gz: 8969b6f0b9492e2f9edb087b57ef7b13993d61eeaabb9a0291478c1a227448ff
+  metadata.gz: 9d497c75bd5ace025a1696d5b5df76116dd54495afee2178872f8f19f06b9257
+  data.tar.gz: 24a06481753cb39885de374dfca9e3adcc041e7b0c42550d3406513f79b41ba9
 SHA512:
-  metadata.gz: 7d5f69fd6e5f2a7dd3b067ca423c85ed2d9fc2f3af9ae191a19507ac3635e654699e5dac6c90ba1f910d5619cf8242a039e07752bfccbfed8c2a57a280fe0bb3
-  data.tar.gz: 899259457171fafd01c689f234da55255a06a4408ab7e58bcbdf8df94a409884a46ce3e613a2faabe9fbec350b65188d3d8a3e1821832b74d7ff9d145bbb16ef
+  metadata.gz: ddf3c461fd892e80c199f7f5f37cf65a46f14a6a41285e7eec0fdb6ec0da5d4cfa9c74a866f1d3f7da5d8ef1a967ca713da3b12f167b82c2ee0b53bafbcd1bf3
+  data.tar.gz: c656f25a3ab3aa13286db0586d843b690c864fc219210de328edbca195b501c874046f96e098b8e3adcc549f11c052615c62ecec03f6821e6ebeab2dff6e874a

data/CHANGELOG

@@ -1,3 +1,19 @@
+=== 1.18.0 (2025-12-01)
+
+* Optimize Dataset#all and #with_sql_all (jeremyevans)
+
+* Fix runtime warnings when using Dataset#as_hash and #to_hash_groups with invalid columns (jeremyevans)
+
+* Fix Dataset#map return value when the null_dataset extension is used (jeremyevans)
+
+* Further optimize Dataset#as_set and #select_set on Ruby 4+ using core Set C-API (jeremyevans)
+
+* Use rb_hash_new_capa if available to avoid unnecessary hash resizing (jeremyevans)
+
+* Further optimize Dataset#map and #select_map by populating array in C instead of yielding to Ruby (jeremyevans)
+
+* Optimize Dataset#as_set and #select_set in Sequel 5.99+ (jeremyevans)
+
 === 1.17.2 (2025-03-14)
 
 * Add explicit arguments to PQfreemem casts to avoid compilation issues when using the C23 standard (jeremyevans) (#59)

data/README.rdoc

@@ -127,13 +127,26 @@ requirements:
   PostgreSQL defaulting to ISO, Sequel also manually sets the
   date format to ISO by default, so unless you are overriding that
   setting (via DB.use_iso_date_format = false), you should be OK.
+
 * Adding your own type conversion procs only has an effect if those
   types are not handled by default.
+
 * You do not need to require the library, the sequel postgres adapter
   will require it automatically.  If you are using bundler, you
   should add it to your Gemfile like so:
 
-    gem 'sequel_pg', :require=>'sequel'
+    gem 'sequel_pg', require: 'sequel'
+
+* Using a precompiled pg gem can cause issues in certain cases,
+  since it statically links a libpq that could differ from the system
+  libpq dynamically linked to the sequel_pg gem. You can work around
+  the issue by forcing the ruby platform for the pg gem:
+
+    # Manual install
+    gem install pg --platform ruby
+
+    # Gemfile
+    gem 'pg', force_ruby_platform: true
 
 * sequel_pg currently calls functions defined in the pg gem, which
   does not work on Windows and does not work in some unix-like

data/ext/sequel_pg/extconf.rb

@@ -7,6 +7,8 @@ dir_config('pg', ENV["POSTGRES_INCLUDE"] || (IO.popen("pg_config --includedir").
                  ENV["POSTGRES_LIB"]     || (IO.popen("pg_config --libdir").readline.chomp rescue nil))
 
 if (have_library('pq') || have_library('libpq') || have_library('ms/libpq')) && have_header('libpq-fe.h')
+  have_func 'rb_hash_new_capa'
+  have_func 'rb_set_new_capa'
   have_func 'PQsetSingleRowMode'
   have_func 'timegm'
   create_makefile("sequel_pg")

data/ext/sequel_pg/sequel_pg.c

@@ -1,4 +1,4 @@
-#define SEQUEL_PG_VERSION_INTEGER 11702
+#define SEQUEL_PG_VERSION_INTEGER 11800
 
 #include <string.h>
 #include <stdio.h>
@@ -24,6 +24,10 @@
 #define RARRAY_AREF(a, i) (RARRAY_PTR(a)[i])
 #endif
 
+#if !HAVE_RB_HASH_NEW_CAPA
+#define rb_hash_new_capa(_) rb_hash_new()
+#endif
+
 #define ntohll(c) ((uint64_t)( \
     (((uint64_t)(*((unsigned char*)(c)+0)))<<56LL) | \
     (((uint64_t)(*((unsigned char*)(c)+1)))<<48LL) | \
@@ -65,6 +69,16 @@
 #define SPG_YIELD_MKV_HASH_GROUPS 11
 #define SPG_YIELD_KMV_HASH_GROUPS 12
 #define SPG_YIELD_MKMV_HASH_GROUPS 13
+#define SPG_YIELD_COLUMN_ARRAY 14
+#define SPG_YIELD_COLUMNS_ARRAY 15
+#define SPG_YIELD_FIRST_ARRAY 16
+#define SPG_YIELD_ARRAY_ARRAY 17
+#define SPG_YIELD_COLUMN_SET 18
+#define SPG_YIELD_COLUMNS_SET 19
+#define SPG_YIELD_FIRST_SET 20
+#define SPG_YIELD_ARRAY_SET 21
+#define SPG_YIELD_ALL 22
+#define SPG_YIELD_ALL_MODEL 23
 
 /* External functions defined by ruby-pg */
 PGconn* pg_get_pgconn(VALUE);
@@ -91,11 +105,19 @@ static VALUE spg_vmasks6;
 static VALUE spg_sym_utc;
 static VALUE spg_sym_local;
 static VALUE spg_sym_map;
+static VALUE spg_sym_map_array;
+static VALUE spg_sym_map_set;
 static VALUE spg_sym_first;
+static VALUE spg_sym_first_array;
+static VALUE spg_sym_first_set;
 static VALUE spg_sym_array;
+static VALUE spg_sym_array_array;
+static VALUE spg_sym_array_set;
 static VALUE spg_sym_hash;
 static VALUE spg_sym_hash_groups;
 static VALUE spg_sym_model;
+static VALUE spg_sym_all;
+static VALUE spg_sym_all_model;
 static VALUE spg_sym__sequel_pg_type;
 static VALUE spg_sym__sequel_pg_value;
 
@@ -1405,10 +1427,34 @@ static VALUE spg_yield_hash_rows_internal(VALUE self, PGresult *res, int enc_ind
         } else if (rb_type(pg_value) == T_ARRAY) {
           type = SPG_YIELD_COLUMNS;
         }
+      } else if (pg_type == spg_sym_map_array) {
+        if (SYMBOL_P(pg_value)) {
+          type = SPG_YIELD_COLUMN_ARRAY;
+        } else if (rb_type(pg_value) == T_ARRAY) {
+          type = SPG_YIELD_COLUMNS_ARRAY;
+        }
+#if HAVE_RB_SET_NEW_CAPA
+      } else if (pg_type == spg_sym_map_set) {
+        if (SYMBOL_P(pg_value)) {
+          type = SPG_YIELD_COLUMN_SET;
+        } else if (rb_type(pg_value) == T_ARRAY) {
+          type = SPG_YIELD_COLUMNS_SET;
+        }
+#endif
       } else if (pg_type == spg_sym_first) {
         type = SPG_YIELD_FIRST;
       } else if (pg_type == spg_sym_array) {
         type = SPG_YIELD_ARRAY;
+      } else if (pg_type == spg_sym_first_array) {
+        type = SPG_YIELD_FIRST_ARRAY;
+      } else if (pg_type == spg_sym_array_array) {
+        type = SPG_YIELD_ARRAY_ARRAY;
+#if HAVE_RB_SET_NEW_CAPA
+      } else if (pg_type == spg_sym_first_set) {
+        type = SPG_YIELD_FIRST_SET;
+      } else if (pg_type == spg_sym_array_set) {
+        type = SPG_YIELD_ARRAY_SET;
+#endif
       } else if ((pg_type == spg_sym_hash || pg_type == spg_sym_hash_groups) && rb_type(pg_value) == T_ARRAY) {
         VALUE pg_value_key, pg_value_value;
         pg_value_key = rb_ary_entry(pg_value, 0);
@@ -1428,6 +1474,10 @@ static VALUE spg_yield_hash_rows_internal(VALUE self, PGresult *res, int enc_ind
         }
       } else if (pg_type == spg_sym_model && rb_type(pg_value) == T_CLASS) {
         type = SPG_YIELD_MODEL;
+      } else if (pg_type == spg_sym_all_model && rb_type(pg_value) == T_CLASS) {
+        type = SPG_YIELD_ALL_MODEL;
+      } else if (pg_type == spg_sym_all) {
+        type = SPG_YIELD_ALL;
       }
     }
   }
@@ -1436,7 +1486,7 @@ static VALUE spg_yield_hash_rows_internal(VALUE self, PGresult *res, int enc_ind
     case SPG_YIELD_NORMAL:
       /* Normal, hash for entire row */
       for(i=0; i<ntuples; i++) {
-        h = rb_hash_new();
+        h = rb_hash_new_capa(nfields);
         for(j=0; j<nfields; j++) {
           rb_hash_aset(h, colsyms[j], spg__col_value(self, res, i, j, colconvert, enc_index));
         }
@@ -1463,6 +1513,63 @@ static VALUE spg_yield_hash_rows_internal(VALUE self, PGresult *res, int enc_ind
         rb_yield(spg__col_values(self, h, colsyms, nfields, res, i, colconvert, enc_index));
       } 
       break;
+    case SPG_YIELD_COLUMN_ARRAY:
+      /* Array containing single column */
+      {
+        VALUE ary = rb_ary_new2(ntuples);
+        j = spg__field_id(pg_value, colsyms, nfields);
+        if (j == -1) {
+          for(i=0; i<ntuples; i++) {
+            rb_ary_store(ary, i, Qnil);
+          } 
+        }
+        else {
+          for(i=0; i<ntuples; i++) {
+            rb_ary_store(ary, i, spg__col_value(self, res, i, j, colconvert, enc_index));
+          } 
+        }
+        rb_yield(ary);
+      }
+      break;
+    case SPG_YIELD_COLUMNS_ARRAY:
+      /* Array containing arrays of columns */
+      {
+        VALUE ary = rb_ary_new2(ntuples);
+        h = spg__field_ids(pg_value, colsyms, nfields);
+        for(i=0; i<ntuples; i++) {
+          rb_ary_store(ary, i, spg__col_values(self, h, colsyms, nfields, res, i, colconvert, enc_index));
+        } 
+        rb_yield(ary);
+      }
+      break;
+#if HAVE_RB_SET_NEW_CAPA
+    case SPG_YIELD_COLUMN_SET:
+      /* Set containing single column */
+      {
+        VALUE set = rb_set_new_capa(ntuples);
+        j = spg__field_id(pg_value, colsyms, nfields);
+        if (j == -1) {
+          rb_set_add(set, Qnil);
+        } else {
+          for(i=0; i<ntuples; i++) {
+            rb_set_add(set, spg__col_value(self, res, i, j, colconvert, enc_index));
+          } 
+        }
+        rb_yield(set);
+      }
+      break;
+    case SPG_YIELD_COLUMNS_SET:
+      /* Set containing arrays of columns */
+      {
+        VALUE set = rb_set_new_capa(ntuples);
+        h = spg__field_ids(pg_value, colsyms, nfields);
+        for(i=0; i<ntuples; i++) {
+          rb_set_add(set, spg__col_values(self, h, colsyms, nfields, res, i, colconvert, enc_index));
+        } 
+        rb_yield(set);
+      }
+      break;
+#endif
     case SPG_YIELD_FIRST:
       /* First column */
       for(i=0; i<ntuples; i++) {
@@ -1479,23 +1586,73 @@ static VALUE spg_yield_hash_rows_internal(VALUE self, PGresult *res, int enc_ind
         rb_yield(h);
       } 
       break;
+    case SPG_YIELD_FIRST_ARRAY:
+      /* Array of first column */
+      h = rb_ary_new2(ntuples);
+      for(i=0; i<ntuples; i++) {
+        rb_ary_store(h, i, spg__col_value(self, res, i, 0, colconvert, enc_index));
+      } 
+      rb_yield(h);
+      break;
+    case SPG_YIELD_ARRAY_ARRAY:
+      /* Array of arrays of all columns */
+      {
+        VALUE ary = rb_ary_new2(ntuples);
+        for(i=0; i<ntuples; i++) {
+          h = rb_ary_new2(nfields);
+          for(j=0; j<nfields; j++) {
+            rb_ary_store(h, j, spg__col_value(self, res, i, j, colconvert, enc_index));
+          }
+          rb_ary_store(ary, i, h);
+        } 
+        rb_yield(ary);
+      }
+      break;
+#if HAVE_RB_SET_NEW_CAPA
+    case SPG_YIELD_FIRST_SET:
+      /* Array of first column */
+      h = rb_set_new_capa(ntuples);
+      for(i=0; i<ntuples; i++) {
+        rb_set_add(h, spg__col_value(self, res, i, 0, colconvert, enc_index));
+      } 
+      rb_yield(h);
+      break;
+    case SPG_YIELD_ARRAY_SET:
+      /* Array of arrays of all columns */
+      {
+        VALUE set = rb_set_new_capa(ntuples);
+        for(i=0; i<ntuples; i++) {
+          h = rb_ary_new2(nfields);
+          for(j=0; j<nfields; j++) {
+            rb_ary_store(h, j, spg__col_value(self, res, i, j, colconvert, enc_index));
+          }
+          rb_set_add(set, h);
+        } 
+        rb_yield(set);
+      }
+      break;
+#endif
     case SPG_YIELD_KV_HASH:
     case SPG_YIELD_KV_HASH_GROUPS:
       /* Hash with single key and single value */
       {
         int k, v;
-        h = rb_hash_new();
+        VALUE kv, vv;
         k = spg__field_id(rb_ary_entry(pg_value, 0), colsyms, nfields);
         v = spg__field_id(rb_ary_entry(pg_value, 1), colsyms, nfields);
         if(type == SPG_YIELD_KV_HASH) {
+          h = rb_hash_new_capa(ntuples);
           for(i=0; i<ntuples; i++) {
-            rb_hash_aset(h, spg__col_value(self, res, i, k, colconvert, enc_index), spg__col_value(self, res, i, v, colconvert, enc_index));
+            kv = k == -1 ? Qnil : spg__col_value(self, res, i, k, colconvert, enc_index);
+            vv = v == -1 ? Qnil : spg__col_value(self, res, i, v, colconvert, enc_index);
+            rb_hash_aset(h, kv, vv);
           } 
         } else {
-          VALUE kv, vv, a;
+          VALUE a;
+          h = rb_hash_new();
           for(i=0; i<ntuples; i++) {
-            kv = spg__col_value(self, res, i, k, colconvert, enc_index);
-            vv = spg__col_value(self, res, i, v, colconvert, enc_index);
+            kv = k == -1 ? Qnil : spg__col_value(self, res, i, k, colconvert, enc_index);
+            vv = v == -1 ? Qnil : spg__col_value(self, res, i, v, colconvert, enc_index);
             a = rb_hash_lookup(h, kv);
             if(!RTEST(a)) {
               rb_hash_aset(h, kv, rb_ary_new3(1, vv));
@@ -1511,20 +1668,22 @@ static VALUE spg_yield_hash_rows_internal(VALUE self, PGresult *res, int enc_ind
     case SPG_YIELD_MKV_HASH_GROUPS:
       /* Hash with array of keys and single value */
       {
-        VALUE k;
+        VALUE k, vv;
         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);
         if(type == SPG_YIELD_MKV_HASH) {
+          h = rb_hash_new_capa(ntuples);
           for(i=0; i<ntuples; i++) {
-            rb_hash_aset(h, spg__col_values(self, k, colsyms, nfields, res, i, colconvert, enc_index), spg__col_value(self, res, i, v, colconvert, enc_index));
+            vv = v == -1 ? Qnil : spg__col_value(self, res, i, v, colconvert, enc_index);
+            rb_hash_aset(h, spg__col_values(self, k, colsyms, nfields, res, i, colconvert, enc_index), vv);
           } 
         } else {
-          VALUE kv, vv, a;
+          VALUE kv, a;
+          h = rb_hash_new();
           for(i=0; i<ntuples; i++) {
             kv = spg__col_values(self, k, colsyms, nfields, res, i, colconvert, enc_index);
-            vv = spg__col_value(self, res, i, v, colconvert, enc_index);
+            vv = v == -1 ? Qnil : spg__col_value(self, res, i, v, colconvert, enc_index);
             a = rb_hash_lookup(h, kv);
             if(!RTEST(a)) {
               rb_hash_aset(h, kv, rb_ary_new3(1, vv));
@@ -1540,19 +1699,21 @@ static VALUE spg_yield_hash_rows_internal(VALUE self, PGresult *res, int enc_ind
     case SPG_YIELD_KMV_HASH_GROUPS:
       /* Hash with single keys and array of values */
       {
-        VALUE v;
+        VALUE v, kv;
         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);
         if(type == SPG_YIELD_KMV_HASH) {
+          h = rb_hash_new_capa(ntuples);
           for(i=0; i<ntuples; i++) {
-            rb_hash_aset(h, spg__col_value(self, res, i, k, colconvert, enc_index), spg__col_values(self, v, colsyms, nfields, res, i, colconvert, enc_index));
+            kv = k == -1 ? Qnil : spg__col_value(self, res, i, k, colconvert, enc_index);
+            rb_hash_aset(h, kv, spg__col_values(self, v, colsyms, nfields, res, i, colconvert, enc_index));
           } 
         } else {
-          VALUE kv, vv, a;
+          VALUE vv, a;
+          h = rb_hash_new();
           for(i=0; i<ntuples; i++) {
-            kv = spg__col_value(self, res, i, k, colconvert, enc_index);
+            kv = k == -1 ? Qnil : spg__col_value(self, res, i, k, colconvert, enc_index);
             vv = spg__col_values(self, v, colsyms, nfields, res, i, colconvert, enc_index);
             a = rb_hash_lookup(h, kv);
             if(!RTEST(a)) {
@@ -1570,15 +1731,16 @@ static VALUE spg_yield_hash_rows_internal(VALUE self, PGresult *res, int enc_ind
       /* Hash with array of keys and array of values */
       {
         VALUE k, v;
-        h = rb_hash_new();
         k = spg__field_ids(rb_ary_entry(pg_value, 0), colsyms, nfields);
         v = spg__field_ids(rb_ary_entry(pg_value, 1), colsyms, nfields);
         if(type == SPG_YIELD_MKMV_HASH) {
+          h = rb_hash_new_capa(ntuples);
           for(i=0; i<ntuples; i++) {
             rb_hash_aset(h, spg__col_values(self, k, colsyms, nfields, res, i, colconvert, enc_index), spg__col_values(self, v, colsyms, nfields, res, i, colconvert, enc_index));
           } 
         } else {
           VALUE kv, vv, a;
+          h = rb_hash_new();
           for(i=0; i<ntuples; i++) {
             kv = spg__col_values(self, k, colsyms, nfields, res, i, colconvert, enc_index);
             vv = spg__col_values(self, v, colsyms, nfields, res, i, colconvert, enc_index);
@@ -1596,7 +1758,7 @@ static VALUE spg_yield_hash_rows_internal(VALUE self, PGresult *res, int enc_ind
     case SPG_YIELD_MODEL:
       /* Model object for entire row */
       for(i=0; i<ntuples; i++) {
-        h = rb_hash_new();
+        h = rb_hash_new_capa(nfields);
         for(j=0; j<nfields; j++) {
           rb_hash_aset(h, colsyms[j], spg__col_value(self, res, i, j, colconvert, enc_index));
         }
@@ -1606,6 +1768,35 @@ static VALUE spg_yield_hash_rows_internal(VALUE self, PGresult *res, int enc_ind
         rb_yield(pg_type);
       }
       break;
+    case SPG_YIELD_ALL_MODEL:
+      {
+        VALUE ary = rb_ary_new2(ntuples);
+        VALUE obj;
+        for(i=0; i<ntuples; i++) {
+          h = rb_hash_new_capa(nfields);
+          for(j=0; j<nfields; j++) {
+            rb_hash_aset(h, colsyms[j], spg__col_value(self, res, i, j, colconvert, enc_index));
+          }
+          obj = rb_obj_alloc(pg_value);
+          rb_ivar_set(obj, spg_id_values, h);
+          rb_ary_store(ary, i, obj);
+        }
+        rb_yield(ary);
+      }
+      break;
+    case SPG_YIELD_ALL:
+      {
+        VALUE ary = rb_ary_new2(ntuples);
+        for(i=0; i<ntuples; i++) {
+          h = rb_hash_new_capa(nfields);
+          for(j=0; j<nfields; j++) {
+            rb_hash_aset(h, colsyms[j], spg__col_value(self, res, i, j, colconvert, enc_index));
+          }
+          rb_ary_store(ary, i, h);
+        }
+        rb_yield(ary);
+      }
+      break;
   }
   return self;
 }
@@ -1674,7 +1865,7 @@ struct spg__yield_each_row_stream_data {
 
 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 h = rb_hash_new_capa(nfields);
   VALUE self = data->self;
   VALUE *colsyms = data->colsyms;
   VALUE *colconvert= data->colconvert;
@@ -1735,7 +1926,7 @@ static VALUE spg__yield_each_row_internal(VALUE self, VALUE rconn, VALUE rres, P
   }
 
   while (PQntuples(res) != 0) {
-    h = rb_hash_new();
+    h = rb_hash_new_capa(nfields);
     for(j=0; j<nfields; j++) {
       rb_hash_aset(h, colsyms[j], spg__col_value(self, res, 0, j, colconvert , enc_index));
     }
@@ -1918,11 +2109,19 @@ void Init_sequel_pg(void) {
   spg_sym_utc = ID2SYM(rb_intern("utc"));
   spg_sym_local = ID2SYM(rb_intern("local"));
   spg_sym_map = ID2SYM(rb_intern("map"));
+  spg_sym_map_array = ID2SYM(rb_intern("map_array"));
+  spg_sym_map_set = ID2SYM(rb_intern("map_set"));
   spg_sym_first = ID2SYM(rb_intern("first"));
   spg_sym_array = ID2SYM(rb_intern("array"));
+  spg_sym_first_array = ID2SYM(rb_intern("first_array"));
+  spg_sym_array_array = ID2SYM(rb_intern("array_array"));
+  spg_sym_first_set = ID2SYM(rb_intern("first_set"));
+  spg_sym_array_set = ID2SYM(rb_intern("array_set"));
   spg_sym_hash = ID2SYM(rb_intern("hash"));
   spg_sym_hash_groups = ID2SYM(rb_intern("hash_groups"));
   spg_sym_model = ID2SYM(rb_intern("model"));
+  spg_sym_all = ID2SYM(rb_intern("all"));
+  spg_sym_all_model = ID2SYM(rb_intern("all_model"));
   spg_sym__sequel_pg_type = ID2SYM(rb_intern("_sequel_pg_type"));
   spg_sym__sequel_pg_value = ID2SYM(rb_intern("_sequel_pg_value"));
 

data/lib/sequel_pg/model.rb

@@ -0,0 +1,48 @@
+class Sequel::Postgres::Dataset
+  # If model loads are being optimized and this is a model load, use the optimized
+  # version.
+  def each(&block)
+    rp = row_proc
+    return super unless allow_sequel_pg_optimization? && optimize_model_load?(rp)
+    clone(:_sequel_pg_type=>:model, :_sequel_pg_value=>rp).fetch_rows(sql, &block)
+  end
+
+  # Avoid duplicate method warning
+  alias with_sql_all with_sql_all
+
+  # Always use optimized version
+  def with_sql_all(sql, &block)
+    rp = row_proc
+    return super unless allow_sequel_pg_optimization?
+
+    if optimize_model_load?(rp)
+      clone(:_sequel_pg_type=>:all_model, :_sequel_pg_value=>row_proc).fetch_rows(sql) do |array|
+        post_load(array)
+        array.each(&block) if block
+        return array
+      end
+      []
+    else 
+      clone(:_sequel_pg_type=>:all).fetch_rows(sql) do |array|
+        if rp = row_proc
+          array.map!{|h| rp.call(h)}
+        end
+        post_load(array)
+        array.each(&block) if block
+        return array
+      end
+      []
+    end
+  end
+
+  private
+
+  # The model load can only be optimized if it's for a model and it's not a graphed dataset
+  # or using a cursor.
+  def optimize_model_load?(rp)
+    rp.is_a?(Class) &&
+      rp < Sequel::Model &&
+      rp.method(:call).owner == Sequel::Model::ClassMethods &&
+      opts[:optimize_model_load] != false
+  end
+end

data/lib/sequel_pg/sequel_pg.rb

@@ -21,15 +21,33 @@ class Sequel::Postgres::Dataset
     opts.has_key?(:optimize_model_load) ?  opts[:optimize_model_load] : true
   end
 
+  # :nocov:
+  if method_defined?(:as_set)
+  # :nocov:
+    if RUBY_VERSION > '4'
+      def as_set(column)
+        clone(:_sequel_pg_type=>:map_set, :_sequel_pg_value=>column).fetch_rows(sql){return it}
+        Set.new
+      end
+    # :nocov:
+    else
+      def as_set(column)
+        rows = Set.new
+        clone(:_sequel_pg_type=>:map, :_sequel_pg_value=>column).fetch_rows(sql){|s| rows.add(s)}
+        rows
+      end
+    end
+    # :nocov:
+  end
+
   # In the case where an argument is given, use an optimized version.
   def map(sym=nil)
     if sym
       if block_given?
         super
       else
-        rows = []
-        clone(:_sequel_pg_type=>:map, :_sequel_pg_value=>sym).fetch_rows(sql){|s| rows << s}
-        rows
+        clone(:_sequel_pg_type=>:map_array, :_sequel_pg_value=>sym).fetch_rows(sql){|a| return a}
+        []
       end
     else
       super
@@ -73,48 +91,86 @@ class Sequel::Postgres::Dataset
     end
   end
 
-  if defined?(Sequel::Model::ClassMethods)
-    # If model loads are being optimized and this is a model load, use the optimized
-    # version.
-    def each(&block)
-      if optimize_model_load?
-        clone(:_sequel_pg_type=>:model, :_sequel_pg_value=>row_proc).fetch_rows(sql, &block)
-      else
-        super
+  # Delegate to with_sql_all using the default SQL
+  def all(&block)
+    with_sql_all(sql, &block)
+  end
+
+  # :nocov:
+  # Generally overridden by the model support, only used if the model
+  # support is not used.
+  def with_sql_all(sql, &block)
+    return super unless allow_sequel_pg_optimization?
+
+    clone(:_sequel_pg_type=>:all).fetch_rows(sql) do |array|
+      if rp = row_proc
+        array.map!{|h| rp.call(h)}
       end
+      post_load(array)
+      array.each(&block) if block
+      return array
     end
+    []
   end
+  # :nocov:
     
   protected
 
   # Always use optimized version
   def _select_map_multiple(ret_cols)
-    rows = []
-    clone(:_sequel_pg_type=>:array).fetch_rows(sql){|s| rows << s}
-    rows
+    clone(:_sequel_pg_type=>:array_array).fetch_rows(sql){|a| return a}
+    []
   end
 
   # Always use optimized version
   def _select_map_single
-    rows = []
-    clone(:_sequel_pg_type=>:first).fetch_rows(sql){|s| rows << s}
-    rows
+    clone(:_sequel_pg_type=>:first_array).fetch_rows(sql){|a| return a}
+    []
   end
 
-  private
+  # :nocov:
+  if method_defined?(:_select_set_multiple)
+  # :nocov:
+    if RUBY_VERSION > '4'
+      # Always use optimized version
+      def _select_set_multiple(ret_cols)
+        clone(:_sequel_pg_type=>:array_set).fetch_rows(sql){return it}
+        Set.new
+      end
 
-  if defined?(Sequel::Model::ClassMethods)
-    # The model load can only be optimized if it's for a model and it's not a graphed dataset
-    # or using a cursor.
-    def optimize_model_load?
-      (rp = row_proc) &&
-        rp.is_a?(Class) &&
-        rp < Sequel::Model &&
-        rp.method(:call).owner == Sequel::Model::ClassMethods &&
-        opts[:optimize_model_load] != false &&
-        !opts[:use_cursor] &&
-        !opts[:graph]
+      # Always use optimized version
+      def _select_set_single
+        clone(:_sequel_pg_type=>:first_set).fetch_rows(sql){return it}
+        Set.new
+      end
+    # :nocov:
+    else
+      # Always use optimized version
+      def _select_set_multiple(ret_cols)
+        set = Set.new
+        clone(:_sequel_pg_type=>:array).fetch_rows(sql){|s| set.add s}
+        set
+      end
+
+      # Always use optimized version
+      def _select_set_single
+        set = Set.new
+        clone(:_sequel_pg_type=>:first).fetch_rows(sql){|s| set.add s}
+        set
+      end
     end
+    # :nocov:
+  end
+
+  if defined?(Sequel::Model::ClassMethods)
+    require_relative 'model'
+  end
+
+  private
+
+  # Whether to allow sequel_pg to optimize the each/all/with_sql_all call.
+  def allow_sequel_pg_optimization?
+    (!opts[:graph] || opts[:eager_graph]) && !opts[:cursor]
   end
 end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: sequel_pg
 version: !ruby/object:Gem::Version
-  version: 1.17.2
+  version: 1.18.0
 platform: ruby
 authors:
 - Jeremy Evans
 bindir: bin
 cert_chain: []
-date: 2025-03-14 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -57,9 +57,9 @@ executables: []
 extensions:
 - ext/sequel_pg/extconf.rb
 extra_rdoc_files:
-- README.rdoc
 - CHANGELOG
 - MIT-LICENSE
+- README.rdoc
 files:
 - CHANGELOG
 - MIT-LICENSE
@@ -68,6 +68,7 @@ files:
 - ext/sequel_pg/extconf.rb
 - ext/sequel_pg/sequel_pg.c
 - lib/sequel/extensions/pg_streaming.rb
+- lib/sequel_pg/model.rb
 - lib/sequel_pg/sequel_pg.rb
 homepage: http://github.com/jeremyevans/sequel_pg
 licenses:
@@ -99,7 +100,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Faster SELECTs when using Sequel with pg
 test_files: []