duckdb 1.5.5.0 → 1.5.6.0

data/ext/duckdb/function_executor.c

@@ -76,6 +76,52 @@ static int g_executor_started = 0;
  */
 static VALUE g_proxy_threads = Qnil;
 
+/*
+ * Replace embedded NUL bytes so the message can be handed to a C API.
+ * Returns str unchanged when there is nothing to replace.
+ */
+static VALUE message_without_nul(VALUE str) {
+    long len = RSTRING_LEN(str);
+    long i;
+    VALUE copy;
+    char *p;
+
+    if (memchr(RSTRING_PTR(str), '\0', (size_t)len) == NULL) {
+        return str;
+    }
+
+    copy = rb_str_new(RSTRING_PTR(str), len);
+    p = RSTRING_PTR(copy);
+    for (i = 0; i < len; i++) {
+        if (p[i] == '\0') {
+            p[i] = ' ';
+        }
+    }
+    return copy;
+}
+
+static VALUE pending_error_message(VALUE errinfo) {
+    return message_without_nul(rb_obj_as_string(rb_funcall(errinfo, rb_intern("message"), 0)));
+}
+
+VALUE rbduckdb_pending_error_message(void) {
+    VALUE errinfo = rb_errinfo();
+    VALUE msg;
+    int state = 0;
+
+    rb_set_errinfo(Qnil);
+    if (errinfo == Qnil) {
+        return rb_str_new_cstr("unknown error");
+    }
+
+    msg = rb_protect(pending_error_message, errinfo, &state);
+    if (state) {
+        rb_set_errinfo(Qnil);
+        return rb_str_new_cstr("an exception was raised, but its message could not be read");
+    }
+    return msg;
+}
+
 /* Data passed to the executor wait function */
 struct executor_wait_data {
     struct callback_request *request;
@@ -130,6 +176,49 @@ static void executor_stop_func(void *data) {
 #endif
 }
 
+/*
+ * Discard an exception a dispatched callback let escape, so that one bad
+ * callback cannot take a dispatcher thread down with it and strand every
+ * later callback. Interrupt, SystemExit and thread kill still get through.
+ */
+static void discard_callback_exception(int state) {
+    VALUE err = rb_errinfo();
+
+    if (err != Qnil && !rb_obj_is_kind_of(err, rb_eStandardError)) {
+        rb_jump_tag(state);
+    }
+    rb_set_errinfo(Qnil);
+}
+
+static VALUE request_run_body(VALUE varg) {
+    struct callback_request *req = (struct callback_request *)varg;
+    req->cb(req->user_data);
+    return Qnil;
+}
+
+/* Runs from rb_ensure: the worker waits on done_cond even if the callback raised. */
+static VALUE request_signal_done(VALUE varg) {
+    struct callback_request *req = (struct callback_request *)varg;
+
+#ifdef _MSC_VER
+    EnterCriticalSection(&req->done_lock);
+    req->done = 1;
+    WakeConditionVariable(&req->done_cond);
+    LeaveCriticalSection(&req->done_lock);
+#else
+    pthread_mutex_lock(&req->done_mutex);
+    req->done = 1;
+    pthread_cond_signal(&req->done_cond);
+    pthread_mutex_unlock(&req->done_mutex);
+#endif
+
+    return Qnil;
+}
+
+static VALUE request_run(VALUE varg) {
+    return rb_ensure(request_run_body, varg, request_signal_done, varg);
+}
+
 /* The executor thread main loop (Ruby thread) */
 static VALUE executor_thread_func(void *data) {
     struct executor_wait_data w;
@@ -140,23 +229,12 @@ static VALUE executor_thread_func(void *data) {
         rb_thread_call_without_gvl(executor_wait_func, &w, executor_stop_func, &w);
 
         if (w.request != NULL) {
-            struct callback_request *req = w.request;
+            int state = 0;
 
-            /* Execute the callback with the GVL held */
-            req->cb(req->user_data);
-
-            /* Signal the DuckDB worker thread that the callback is done */
-#ifdef _MSC_VER
-            EnterCriticalSection(&req->done_lock);
-            req->done = 1;
-            WakeConditionVariable(&req->done_cond);
-            LeaveCriticalSection(&req->done_lock);
-#else
-            pthread_mutex_lock(&req->done_mutex);
-            req->done = 1;
-            pthread_cond_signal(&req->done_cond);
-            pthread_mutex_unlock(&req->done_mutex);
-#endif
+            rb_protect(request_run, (VALUE)w.request, &state);
+            if (state) {
+                discard_callback_exception(state);
+            }
         }
     }
 
@@ -326,6 +404,37 @@ static void proxy_stop_func(void *data) {
 #endif
 }
 
+static VALUE proxy_run_body(VALUE data) {
+    struct worker_proxy *proxy = (struct worker_proxy *)data;
+    proxy->cb(proxy->user_data);
+    return Qnil;
+}
+
+/* Runs from rb_ensure: see request_signal_done. */
+static VALUE proxy_signal_done(VALUE data) {
+    struct worker_proxy *proxy = (struct worker_proxy *)data;
+
+#ifdef _MSC_VER
+    EnterCriticalSection(&proxy->lock);
+    proxy->has_request = 0;
+    proxy->request_done = 1;
+    WakeConditionVariable(&proxy->request_done_cond);
+    LeaveCriticalSection(&proxy->lock);
+#else
+    pthread_mutex_lock(&proxy->lock);
+    proxy->has_request = 0;
+    proxy->request_done = 1;
+    pthread_cond_signal(&proxy->request_done_cond);
+    pthread_mutex_unlock(&proxy->lock);
+#endif
+
+    return Qnil;
+}
+
+static VALUE proxy_run(VALUE data) {
+    return rb_ensure(proxy_run_body, data, proxy_signal_done, data);
+}
+
 /* The proxy thread main loop. Runs as the body of rb_ensure (see below). */
 static VALUE proxy_loop_body(VALUE data) {
     struct worker_proxy *proxy = (struct worker_proxy *)data;
@@ -337,23 +446,12 @@ static VALUE proxy_loop_body(VALUE data) {
         if (proxy->stop_requested) break;
 
         if (proxy->has_request) {
-            /* Execute the callback with the GVL held */
-            proxy->cb(proxy->user_data);
+            int state = 0;
 
-            /* Signal completion to the DuckDB worker thread */
-#ifdef _MSC_VER
-            EnterCriticalSection(&proxy->lock);
-            proxy->has_request = 0;
-            proxy->request_done = 1;
-            WakeConditionVariable(&proxy->request_done_cond);
-            LeaveCriticalSection(&proxy->lock);
-#else
-            pthread_mutex_lock(&proxy->lock);
-            proxy->has_request = 0;
-            proxy->request_done = 1;
-            pthread_cond_signal(&proxy->request_done_cond);
-            pthread_mutex_unlock(&proxy->lock);
-#endif
+            rb_protect(proxy_run, data, &state);
+            if (state) {
+                discard_callback_exception(state);
+            }
         }
     }
 
@@ -565,3 +663,39 @@ void rbduckdb_function_executor_dispatch_via_proxy(rbduckdb_function_callback_t
 void rbduckdb_function_executor_dispatch(rbduckdb_function_callback_t cb, void *user_data) {
     rbduckdb_function_executor_dispatch_via_proxy(cb, user_data, NULL);
 }
+
+static VALUE g_function_data_registry = Qnil;
+static unsigned long long g_function_data_next_id = 0;
+
+static void function_data_registry_ensure(void) {
+    if (g_function_data_registry == Qnil) {
+        g_function_data_registry = rb_hash_new();
+        rb_global_variable(&g_function_data_registry);
+    }
+}
+
+void *rbduckdb_function_data_register(VALUE value) {
+    unsigned long long id;
+
+    function_data_registry_ensure();
+    id = ++g_function_data_next_id;
+    rb_hash_aset(g_function_data_registry, ULL2NUM(id), value);
+    return (void *)(uintptr_t)id;
+}
+
+VALUE rbduckdb_function_data_lookup(void *data) {
+    if (data == NULL || g_function_data_registry == Qnil) {
+        return Qnil;
+    }
+    return rb_hash_aref(g_function_data_registry, ULL2NUM((unsigned long long)(uintptr_t)data));
+}
+
+void rbduckdb_function_data_release(void *data) {
+    if (g_function_data_registry == Qnil) return;
+    rb_hash_delete(g_function_data_registry, ULL2NUM((unsigned long long)(uintptr_t)data));
+}
+
+void rbduckdb_function_data_destroy(void *data) {
+    if (data == NULL) return;
+    rbduckdb_function_executor_dispatch(rbduckdb_function_data_release, data);
+}

data/ext/duckdb/function_executor.h

@@ -18,8 +18,9 @@
  * A generic callback to be executed with the GVL held.
  * The user_data pointer is passed through unchanged from the dispatch call.
  *
- * The callback is responsible for catching Ruby exceptions (e.g. via
- * rb_protect) if needed — this module does not perform exception handling.
+ * The callback should still catch its own Ruby exceptions (e.g. via rb_protect)
+ * to report them to DuckDB. The dispatcher only guarantees that an exception it
+ * lets escape wakes the waiting worker instead of stranding it.
  */
 typedef void (*rbduckdb_function_callback_t)(void *user_data);
 
@@ -66,10 +67,8 @@ struct worker_proxy;
  * (typically by dispatching this through the global executor from a per-worker
  * init callback, which itself runs on a non-Ruby thread).
  *
- * May raise (NoMemError, Thread.new failure). The executor runs callbacks
- * unprotected, so a wrapper dispatched to it must rb_protect this call —
- * otherwise a raise longjmps past the executor's done-signaling and the
- * waiting DuckDB worker blocks forever.
+ * May raise (NoMemError, Thread.new failure), so a wrapper dispatched to the
+ * executor should rb_protect this call and fall back to the global executor.
  */
 struct worker_proxy *rbduckdb_worker_proxy_create(void);
 
@@ -87,4 +86,17 @@ void rbduckdb_worker_proxy_destroy(void *proxy);
  */
 void rbduckdb_function_executor_dispatch_via_proxy(rbduckdb_function_callback_t cb, void *user_data, struct worker_proxy *proxy);
 
+/*
+ * Take the pending Ruby exception's message as a String safe to hand to a
+ * DuckDB set_error entry point, and clear the exception. Always returns a
+ * String with no embedded NUL, so StringValueCStr on it cannot raise; #message
+ * runs under rb_protect, so neither can a hostile exception object.
+ */
+VALUE rbduckdb_pending_error_message(void);
+
+void *rbduckdb_function_data_register(VALUE value);
+VALUE rbduckdb_function_data_lookup(void *data);
+void rbduckdb_function_data_release(void *data);
+void rbduckdb_function_data_destroy(void *data);
+
 #endif

data/ext/duckdb/instance_cache.c

@@ -3,7 +3,11 @@
 VALUE cDuckDBInstanceCache;
 
 static void deallocate(void * ctx);
+static void mark(void *ctx);
+static void compact(void *ctx);
 static VALUE allocate(VALUE klass);
+static VALUE memoizable_path(VALUE vpath);
+static VALUE find_cached_wrapper(rubyDuckDBInstanceCache *ctx, VALUE vpath);
 static size_t memsize(const void *p);
 static VALUE instance_cache_initialize(VALUE self);
 static VALUE instance_cache_get_or_create(int argc, VALUE *argv, VALUE self);
@@ -11,8 +15,8 @@ static VALUE instance_cache_destroy(VALUE self);
 
 static const rb_data_type_t instance_cache_data_type = {
     "DuckDB/InstanceCache",
-    {NULL, deallocate, memsize,},
-    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+    {mark, deallocate, memsize, compact},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
 };
 
 static void deallocate(void * ctx) {
@@ -24,15 +28,62 @@ static void deallocate(void * ctx) {
     xfree(p);
 }
 
+static void mark(void *ctx) {
+    rubyDuckDBInstanceCache *p = (rubyDuckDBInstanceCache *)ctx;
+
+    rb_gc_mark_movable(p->wrappers);
+}
+
+static void compact(void *ctx) {
+    rubyDuckDBInstanceCache *p = (rubyDuckDBInstanceCache *)ctx;
+
+    p->wrappers = rb_gc_location(p->wrappers);
+}
+
 static size_t memsize(const void *p) {
     return sizeof(rubyDuckDBInstanceCache);
 }
 
 static VALUE allocate(VALUE klass) {
     rubyDuckDBInstanceCache *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBInstanceCache));
+    ctx->wrappers = Qnil;
     return TypedData_Wrap_Struct(klass, &instance_cache_data_type, ctx);
 }
 
+/*
+ * A path is memoizable only if two get_or_create calls on it share one DuckDB
+ * instance. An absent, empty or ":memory:" path gets a fresh instance every
+ * time, so those wrappers must stay distinct. Returns the path or Qnil.
+ */
+static VALUE memoizable_path(VALUE vpath) {
+    if (NIL_P(vpath) || RSTRING_LEN(vpath) == 0) {
+        return Qnil;
+    }
+    if (rb_str_cmp(vpath, rb_str_new_cstr(":memory:")) == 0) {
+        return Qnil;
+    }
+    return vpath;
+}
+
+/*
+ * The wrapper this cache already holds for vpath, or Qnil. Entries whose
+ * wrapper has been collected are gone from the weak set already.
+ */
+static VALUE find_cached_wrapper(rubyDuckDBInstanceCache *ctx, VALUE vpath) {
+    VALUE wrappers = rb_funcall(ctx->wrappers, rb_intern("keys"), 0);
+    long i;
+
+    for (i = 0; i < RARRAY_LEN(wrappers); i++) {
+        VALUE wrapper = rb_ary_entry(wrappers, i);
+        rubyDuckDB *db_ctx = rbduckdb_get_struct_database(wrapper);
+
+        if (!NIL_P(db_ctx->cached_path) && rb_str_equal(db_ctx->cached_path, vpath) == Qtrue) {
+            return wrapper;
+        }
+    }
+    return Qnil;
+}
+
 static VALUE instance_cache_initialize(VALUE self) {
     rubyDuckDBInstanceCache *ctx;
 
@@ -43,6 +94,11 @@ static VALUE instance_cache_initialize(VALUE self) {
         rb_raise(eDuckDBError, "Failed to create instance cache");
     }
 
+    RB_OBJ_WRITE(self, &ctx->wrappers,
+                 rb_funcall(rb_const_get(rb_const_get(rb_cObject, rb_intern("ObjectSpace")),
+                                         rb_intern("WeakMap")),
+                            rb_intern("new"), 0));
+
     return self;
 }
 
@@ -50,6 +106,8 @@ static VALUE instance_cache_initialize(VALUE self) {
 static VALUE instance_cache_get_or_create(int argc, VALUE *argv, VALUE self) {
     VALUE vpath = Qnil;
     VALUE vconfig = Qnil;
+    VALUE memo_path;
+    VALUE obj;
     const char *path = NULL;
     char *error = NULL;
     duckdb_config config = NULL;
@@ -79,7 +137,31 @@ static VALUE instance_cache_get_or_create(int argc, VALUE *argv, VALUE self) {
             rb_raise(eDuckDBError, "Failed to get or create database from instance cache");
         }
     }
-    return rbduckdb_create_database_obj(db);
+    /*
+     * duckdb_get_or_create_from_cache hands back a fresh duckdb_database handle
+     * over an instance it may already have returned before. Registered functions
+     * live in that shared instance's catalog, but each wrapper retains them
+     * separately, so a second wrapper's collection frees functions the first
+     * one's connections can still resolve. One wrapper per instance is what the
+     * catalog's lifetime actually is, so reuse the wrapper we already have.
+     */
+    memo_path = memoizable_path(vpath);
+    if (!NIL_P(memo_path)) {
+        VALUE cached = find_cached_wrapper(ctx, memo_path);
+
+        if (!NIL_P(cached)) {
+            /* Our existing wrapper keeps the instance alive; this handle is spare. */
+            duckdb_close(&db);
+            return cached;
+        }
+    }
+
+    obj = rbduckdb_create_database_obj(db);
+    if (!NIL_P(memo_path)) {
+        rbduckdb_database_set_cache_entry(obj, memo_path, ctx->wrappers);
+        rb_funcall(ctx->wrappers, rb_intern("[]="), 2, obj, Qtrue);
+    }
+    return obj;
 }
 
 static VALUE instance_cache_destroy(VALUE self) {

data/ext/duckdb/instance_cache.h

@@ -3,6 +3,12 @@
 
 struct _rubyDuckDBInstanceCache {
     duckdb_instance_cache instance_cache;
+    /*
+     * ObjectSpace::WeakMap used as a weak set of the DuckDB::Database wrappers
+     * this cache has handed out for file paths. Weak so a wrapper nobody holds
+     * is still collected, and its DuckDB instance closed, as before.
+     */
+    VALUE wrappers;
 };
 
 typedef struct _rubyDuckDBInstanceCache rubyDuckDBInstanceCache;

data/ext/duckdb/logical_type.c

@@ -35,7 +35,7 @@ static VALUE logical_type_initialize(VALUE self, VALUE type_id_arg);
 static const rb_data_type_t logical_type_data_type = {
     "DuckDB/LogicalType",
     {NULL, deallocate, memsize,},
-    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
 };
 
 static void deallocate(void *ctx) {

data/ext/duckdb/pending_result.c

@@ -12,10 +12,15 @@ static VALUE pending_result_execution_finished_p(VALUE self);
 static VALUE pending_result__state(VALUE self);
 static VALUE pending_result__execute_check_state(VALUE self);
 
+/*
+ * No RUBY_TYPED_FREE_IMMEDIATELY: deallocate can block, and must not run
+ * during GC sweep: the pending result holds a ClientContext reference; dropping the last
+ * one rolls back an open transaction and may shut the database down.
+ */
 static const rb_data_type_t pending_result_data_type = {
     "DuckDB/PendingResult",
     {NULL, deallocate, memsize,},
-    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+    0, 0, RUBY_TYPED_WB_PROTECTED
 };
 
 static void deallocate(void *ctx) {

data/ext/duckdb/prepared_statement.c

@@ -47,10 +47,15 @@ static VALUE prepared_statement__bind_uuid(VALUE self, VALUE vidx, VALUE val);
 static VALUE prepared_statement__bind_decimal(VALUE self, VALUE vidx, VALUE lower, VALUE upper, VALUE width, VALUE scale);
 static VALUE prepared_statement__bind_value(VALUE self, VALUE vidx, VALUE val);
 
+/*
+ * No RUBY_TYPED_FREE_IMMEDIATELY: deallocate can block, and must not run
+ * during GC sweep: the statement holds a ClientContext reference; dropping the last one
+ * rolls back an open transaction and may shut the database down.
+ */
 static const rb_data_type_t prepared_statement_data_type = {
     "DuckDB/PreparedStatement",
     {NULL, deallocate, memsize,},
-    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+    0, 0, RUBY_TYPED_WB_PROTECTED
 };
 
 static void destroy_prepared_statement(rubyDuckDBPreparedStatement *p) {
@@ -345,10 +350,17 @@ static VALUE prepared_statement_bind_double(VALUE self, VALUE vidx, VALUE val) {
 static VALUE prepared_statement_bind_varchar(VALUE self, VALUE vidx, VALUE str) {
     rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
+    const char *pstr;
+    long len;
 
     TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
 
-    if (duckdb_bind_varchar(ctx->prepared_statement, idx, StringValuePtr(str)) == DuckDBError) {
+    /* Pass the byte length: duckdb_bind_varchar stops at the first NUL, so an
+     * embedded one stored a prefix of the String the caller had validated. */
+    pstr = StringValuePtr(str);
+    len = RSTRING_LEN(str);
+
+    if (duckdb_bind_varchar_length(ctx->prepared_statement, idx, pstr, (idx_t)len) == DuckDBError) {
         rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
     }
     return self;

data/ext/duckdb/result.c

@@ -48,10 +48,15 @@ static VALUE vector_timestamp_tz(void* vector_data, idx_t row_idx);
 static VALUE vector_uuid(void* vector_data, idx_t row_idx);
 static VALUE vector_value(duckdb_vector vector, idx_t row_idx);
 
+/*
+ * No RUBY_TYPED_FREE_IMMEDIATELY: deallocate can block, and must not run
+ * during GC sweep: a streaming result holds a ClientContext reference; dropping the last
+ * one rolls back an open transaction and may shut the database down.
+ */
 static const rb_data_type_t result_data_type = {
     "DuckDB/Result",
     {NULL, deallocate, memsize,},
-    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+    0, 0, RUBY_TYPED_WB_PROTECTED
 };
 
 static void deallocate(void *ctx) {

data/ext/duckdb/result.h

@@ -6,7 +6,7 @@
  * object holds one reference, and each exported Arrow stream holds another,
  * so the duckdb_result stays valid for consumers that outlive the Ruby
  * objects. rbduckdb_result_unref() must not call any Ruby API: it runs from
- * GC sweep (deallocate) and from Arrow stream release callbacks.
+ * GC finalization (deallocate) and from Arrow stream release callbacks.
  */
 struct _rubyDuckDBResult {
     duckdb_result result;

data/ext/duckdb/scalar_function.c

@@ -35,7 +35,6 @@ struct callback_arg {
     duckdb_logical_type output_type;
     duckdb_vector *input_vectors;
     duckdb_logical_type *input_types;
-    VALUE *args;
     idx_t row_count;
     idx_t col_count;
 };
@@ -71,25 +70,22 @@ static void execute_callback_protected(void *user_data) {
 
     rb_protect(execute_callback, (VALUE)arg, &exception_state);
     if (exception_state) {
-        VALUE errinfo = rb_errinfo();
-        if (errinfo != Qnil) {
-            VALUE msg = rb_funcall(errinfo, rb_intern("message"), 0);
-            duckdb_scalar_function_set_error(arg->info, StringValueCStr(msg));
-        }
-        rb_set_errinfo(Qnil);
+        VALUE msg = rbduckdb_pending_error_message();
+        duckdb_scalar_function_set_error(arg->info, StringValueCStr(msg));
+        RB_GC_GUARD(msg);
     }
 }
 
 static const rb_data_type_t scalar_function_data_type = {
     "DuckDB/ScalarFunction",
     {mark, deallocate, memsize, compact},
-    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
 };
 
 static void mark(void *ctx) {
     rubyDuckDBScalarFunction *p = (rubyDuckDBScalarFunction *)ctx;
-    rb_gc_mark(p->function_proc);
-    rb_gc_mark(p->bind_proc);
+    rb_gc_mark_movable(p->function_proc);
+    rb_gc_mark_movable(p->bind_proc);
 }
 
 static void deallocate(void * ctx) {
@@ -223,7 +219,6 @@ static void scalar_function_callback(duckdb_function_info info, duckdb_data_chun
     arg.output_type = duckdb_vector_get_column_type(output);
     arg.input_vectors = NULL;
     arg.input_types = NULL;
-    arg.args = NULL;
     arg.row_count = duckdb_data_chunk_get_size(input);
     arg.col_count = duckdb_data_chunk_get_column_count(input);
 
@@ -252,11 +247,13 @@ static VALUE process_rows(VALUE varg) {
     struct callback_arg *arg = (struct callback_arg *)varg;
     idx_t i, j;
     VALUE result;
+    /* A Ruby Array, not a plain buffer: converting a later column can trigger
+     * a GC, and the earlier columns' objects must stay reachable. */
+    VALUE args = rb_ary_new_capa((long)arg->col_count);
 
     /* Allocate arrays to hold input vectors and their types */
     arg->input_vectors = ALLOC_N(duckdb_vector, arg->col_count);
     arg->input_types = ALLOC_N(duckdb_logical_type, arg->col_count);
-    arg->args = ALLOC_N(VALUE, arg->col_count);
 
     /* Get all input vectors and their types */
     for (j = 0; j < arg->col_count; j++) {
@@ -268,16 +265,18 @@ static VALUE process_rows(VALUE varg) {
     for (i = 0; i < arg->row_count; i++) {
         /* Build arguments array for this row using vector_value_at */
         for (j = 0; j < arg->col_count; j++) {
-            arg->args[j] = rbduckdb_vector_value_at(arg->input_vectors[j], arg->input_types[j], i);
+            rb_ary_store(args, (long)j, rbduckdb_vector_value_at(arg->input_vectors[j], arg->input_types[j], i));
         }
 
         /* Call the Ruby block with the arguments */
-        result = rb_funcallv(arg->ctx->function_proc, rb_intern("call"), (int)arg->col_count, arg->args);
+        result = rb_apply(arg->ctx->function_proc, rb_intern("call"), args);
 
         /* Write result to output using helper function */
         rbduckdb_vector_set_value_at(arg->output, arg->output_type, i, result);
     }
 
+    RB_GC_GUARD(args);
+
     return Qnil;
 }
 
@@ -294,9 +293,6 @@ static VALUE cleanup_callback(VALUE varg) {
     duckdb_destroy_logical_type(&arg->output_type);
 
     /* Free allocated memory */
-    if (arg->args != NULL) {
-        xfree(arg->args);
-    }
     if (arg->input_types != NULL) {
         xfree(arg->input_types);
     }
@@ -375,7 +371,7 @@ static VALUE scalar_function_set_function(VALUE self) {
 
     TypedData_Get_Struct(self, rubyDuckDBScalarFunction, &scalar_function_data_type, p);
 
-    p->function_proc = rb_block_proc();
+    RB_OBJ_WRITE(self, &p->function_proc, rb_block_proc());
 
     duckdb_scalar_function_set_extra_info(p->scalar_function, p, NULL);
     duckdb_scalar_function_set_function(p->scalar_function, scalar_function_callback);
@@ -402,7 +398,7 @@ static VALUE scalar_function__set_bind(VALUE self) {
 
     TypedData_Get_Struct(self, rubyDuckDBScalarFunction, &scalar_function_data_type, p);
 
-    p->bind_proc = rb_block_proc();
+    RB_OBJ_WRITE(self, &p->bind_proc, rb_block_proc());
 
     duckdb_scalar_function_set_extra_info(p->scalar_function, p, NULL);
     duckdb_scalar_function_set_bind(p->scalar_function, scalar_function_bind_callback);
@@ -444,12 +440,9 @@ static void execute_bind_callback_protected(void *user_data) {
 
     rb_protect(call_bind_proc, (VALUE)&arg, &exception_state);
     if (exception_state) {
-        VALUE errinfo = rb_errinfo();
-        if (errinfo != Qnil) {
-            VALUE msg = rb_funcall(errinfo, rb_intern("message"), 0);
-            duckdb_scalar_function_bind_set_error(darg->info, StringValueCStr(msg));
-        }
-        rb_set_errinfo(Qnil);
+        VALUE msg = rbduckdb_pending_error_message();
+        duckdb_scalar_function_bind_set_error(darg->info, StringValueCStr(msg));
+        RB_GC_GUARD(msg);
     }
 }
 

data/ext/duckdb/scalar_function_bind_info.c

@@ -13,7 +13,7 @@ static VALUE scalar_function_bind_info_client_context(VALUE self);
 static const rb_data_type_t scalar_function_bind_info_data_type = {
     "DuckDB/ScalarFunction/BindInfo",
     {NULL, deallocate, memsize,},
-    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
 };
 
 static void deallocate(void *ctx) {

data/ext/duckdb/scalar_function_set.c

@@ -13,12 +13,12 @@ static VALUE scalar_function_set__add(VALUE self, VALUE scalar_function);
 static const rb_data_type_t scalar_function_set_data_type = {
     "DuckDB/ScalarFunctionSet",
     {mark, deallocate, memsize, compact},
-    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
 };
 
 static void mark(void *ctx) {
     rubyDuckDBScalarFunctionSet *p = (rubyDuckDBScalarFunctionSet *)ctx;
-    rb_gc_mark(p->functions);
+    rb_gc_mark_movable(p->functions);
 }
 
 static void deallocate(void *ctx) {
@@ -35,8 +35,7 @@ static void compact(void *ctx) {
 static VALUE allocate(VALUE klass) {
     rubyDuckDBScalarFunctionSet *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBScalarFunctionSet));
     VALUE obj = TypedData_Wrap_Struct(klass, &scalar_function_set_data_type, ctx);
-    ctx->functions = rb_ary_new();
-    RB_GC_GUARD(ctx->functions);
+    RB_OBJ_WRITE(obj, &ctx->functions, rb_ary_new());
     return obj;
 }