Further optimize Dataset#map by populating array in C instead of yielding each entry to Ruby

This avoids C -> Ruby calls, which are more expensive when a JIT is
used. It's also faster by allocating an array with the necessary
capacity up front, instead of having Ruby resize it.

A similar approach is already used for as_hash and to_hash_groups.

Author: jeremyevans

CHANGELOG

@@ -1,5 +1,7 @@
 === master
 
+* Further optimize Dataset#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)

ext/sequel_pg/sequel_pg.c

@@ -65,6 +65,8 @@
 #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
 
 /* External functions defined by ruby-pg */
 PGconn* pg_get_pgconn(VALUE);
@@ -91,6 +93,7 @@ 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_first;
 static VALUE spg_sym_array;
 static VALUE spg_sym_hash;
@@ -1405,6 +1408,12 @@ 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;
+        }
       } else if (pg_type == spg_sym_first) {
         type = SPG_YIELD_FIRST;
       } else if (pg_type == spg_sym_array) {
@@ -1463,6 +1472,35 @@ 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;
     case SPG_YIELD_FIRST:
       /* First column */
       for(i=0; i<ntuples; i++) {
@@ -1918,6 +1956,7 @@ 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_first = ID2SYM(rb_intern("first"));
   spg_sym_array = ID2SYM(rb_intern("array"));
   spg_sym_hash = ID2SYM(rb_intern("hash"));

lib/sequel_pg/sequel_pg.rb

@@ -38,9 +38,7 @@ def map(sym=nil)
       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