duckdb 1.5.3.0 → 1.5.5.0

data/ext/duckdb/config.c

@@ -79,7 +79,7 @@ static VALUE config_set_config(VALUE self, VALUE key, VALUE value) {
     return self;
 }
 
-void rbduckdb_init_duckdb_config(void) {
+void rbduckdb_init_config(void) {
 #if 0
     VALUE mDuckDB = rb_define_module("DuckDB");
 #endif

data/ext/duckdb/config.h

@@ -9,6 +9,6 @@ typedef struct _rubyDuckDBConfig rubyDuckDBConfig;
 
 rubyDuckDBConfig *get_struct_config(VALUE obj);
 
-void rbduckdb_init_duckdb_config(void);
+void rbduckdb_init_config(void);
 
 #endif

data/ext/duckdb/connection.c

@@ -17,6 +17,7 @@ static VALUE connection__register_scalar_function_set(VALUE self, VALUE scalar_f
 static VALUE connection__register_aggregate_function(VALUE self, VALUE aggregate_function);
 static VALUE connection__register_aggregate_function_set(VALUE self, VALUE aggregate_function_set);
 static VALUE connection__register_table_function(VALUE self, VALUE table_function);
+static VALUE connection__get_table_names(VALUE self, VALUE query, VALUE qualified);
 
 static const rb_data_type_t connection_data_type = {
     "DuckDB/Connection",
@@ -198,11 +199,31 @@ static VALUE connection__query_sql(VALUE self, VALUE str) {
     RB_GC_GUARD(str);
 
     if (args.retval == DuckDBError) {
-        rb_raise(eDuckDBError, "%s", duckdb_result_error(&(ctxr->result)));
+        rbduckdb_raise_result_error(&(ctxr->result));
     }
     return result;
 }
 
+/* :nodoc: */
+static VALUE connection__get_table_names(VALUE self, VALUE query, VALUE qualified) {
+    rubyDuckDBConnection *ctx;
+    duckdb_value table_names;
+
+    ctx = rbduckdb_get_struct_connection(self);
+
+    if (!(ctx->con)) {
+        rb_raise(eDuckDBError, "Database connection closed");
+    }
+
+    table_names = duckdb_get_table_names(ctx->con, StringValueCStr(query), RTEST(qualified));
+
+    if (!table_names) {
+        rb_raise(eDuckDBError, "Failed to get table names from query");
+    }
+
+    return rbduckdb_value_new(table_names);
+}
+
 /* :nodoc: */
 static VALUE connection__register_logical_type(VALUE self, VALUE logical_type) {
     rubyDuckDBConnection *ctxcon;
@@ -231,7 +252,7 @@ static VALUE connection__register_scalar_function(VALUE self, VALUE scalar_funct
     duckdb_state state;
 
     ctxcon = rbduckdb_get_struct_connection(self);
-    ctxsf = get_struct_scalar_function(scalar_function);
+    ctxsf = rbduckdb_get_struct_scalar_function(scalar_function);
 
     state = duckdb_register_scalar_function(ctxcon->con, ctxsf->scalar_function);
 
@@ -252,7 +273,7 @@ static VALUE connection__register_scalar_function_set(VALUE self, VALUE scalar_f
     duckdb_state state;
 
     ctxcon = rbduckdb_get_struct_connection(self);
-    ctxsfs = get_struct_scalar_function_set(scalar_function_set);
+    ctxsfs = rbduckdb_get_struct_scalar_function_set(scalar_function_set);
 
     state = duckdb_register_scalar_function_set(ctxcon->con, ctxsfs->scalar_function_set);
 
@@ -314,7 +335,7 @@ static VALUE connection__register_table_function(VALUE self, VALUE table_functio
     duckdb_state state;
 
     ctxcon = rbduckdb_get_struct_connection(self);
-    ctxtf = get_struct_table_function(table_function);
+    ctxtf = rbduckdb_get_struct_table_function(table_function);
 
     state = duckdb_register_table_function(ctxcon->con, ctxtf->table_function);
 
@@ -346,4 +367,5 @@ void rbduckdb_init_connection(void) {
     rb_define_private_method(cDuckDBConnection, "_register_table_function", connection__register_table_function, 1);
     rb_define_private_method(cDuckDBConnection, "_connect", connection__connect, 1);
     rb_define_private_method(cDuckDBConnection, "_query_sql", connection__query_sql, 1);
+    rb_define_private_method(cDuckDBConnection, "_get_table_names", connection__get_table_names, 2);
 }

data/ext/duckdb/converter.h

@@ -19,6 +19,7 @@ extern ID id__decimal_to_unscaled;
 VALUE rbduckdb_uuid_to_ruby(duckdb_hugeint h);
 VALUE rbduckdb_uuid_uhugeint_to_ruby(duckdb_uhugeint h);
 void rbduckdb_uuid_str_to_hugeint(VALUE uuid_str, duckdb_hugeint *out);
+void rbduckdb_uuid_str_to_uhugeint(VALUE uuid_str, duckdb_uhugeint *out);
 VALUE rbduckdb_interval_to_ruby(duckdb_interval i);
 VALUE rbduckdb_hugeint_to_ruby(duckdb_hugeint h);
 VALUE rbduckdb_uhugeint_to_ruby(duckdb_uhugeint h);

data/ext/duckdb/conveter.c

@@ -153,22 +153,21 @@ static int hex_nibble(unsigned char c)
 
 /*
  * Parse a canonical UUID string ("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx") into
- * a duckdb_hugeint. Returns true on success, false on invalid input.
+ * two uint64_t halves. Returns true on success, false on invalid input.
  *
  * Iterates the 36-character string, skipping the four dash positions. The 32
- * hex nibbles are accumulated directly into two uint64_t halves (hi, lo) with
- * no bignum arithmetic or intermediate allocation. The sign-bit flip is applied
- * to hi before storing in upper, matching DuckDB's internal UUID representation.
+ * hex nibbles are accumulated directly into hi (upper 64 bits) and lo (lower
+ * 64 bits) with no bignum arithmetic or intermediate allocation.
  */
-static bool uuid_str_to_hugeint(const char *str, long len, duckdb_hugeint *out)
+static bool parse_uuid_string(const char *str, long len, uint64_t *hi, uint64_t *lo)
 {
-    // Expected format: 8-4-4-4-12 = 36 characters with dashes at fixed positions
     if (len != 36 ||
         str[8] != '-' || str[13] != '-' || str[18] != '-' || str[23] != '-') {
         return false;
     }
 
-    uint64_t hi = 0, lo = 0;
+    *hi = 0;
+    *lo = 0;
     int nibble_idx = 0;
 
     for (int string_idx = 0; string_idx < 36; string_idx++) {
@@ -176,13 +175,27 @@ static bool uuid_str_to_hugeint(const char *str, long len, duckdb_hugeint *out)
         int nib = hex_nibble((unsigned char)str[string_idx]);
         if (nib < 0) return false;
         if (nibble_idx < 16) {
-            hi = (hi << 4) | (uint64_t)nib;
+            *hi = (*hi << 4) | (uint64_t)nib;
         } else {
-            lo = (lo << 4) | (uint64_t)nib;
+            *lo = (*lo << 4) | (uint64_t)nib;
         }
         nibble_idx++;
     }
 
+    return true;
+}
+
+/*
+ * Parse a canonical UUID string ("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx") into
+ * a duckdb_hugeint. Returns true on success, false on invalid input.
+ *
+ * The sign-bit flip is applied to hi before storing in upper, matching
+ * DuckDB's internal UUID representation.
+ */
+static bool uuid_str_to_hugeint(const char *str, long len, duckdb_hugeint *out)
+{
+    uint64_t hi, lo;
+    if (!parse_uuid_string(str, len, &hi, &lo)) return false;
     // Apply the sign-bit flip to match DuckDB's internal UUID representation
     out->upper = (int64_t)(hi ^ DUCKDB_UUID_SIGN_BIT);
     out->lower = lo;
@@ -203,6 +216,23 @@ void rbduckdb_uuid_str_to_hugeint(VALUE uuid_str, duckdb_hugeint *out)
     }
 }
 
+/*
+ * Ruby-callable wrapper: parse a UUID string VALUE into a duckdb_uhugeint
+ * (no sign-bit flip), raising ArgumentError on invalid input.
+ */
+void rbduckdb_uuid_str_to_uhugeint(VALUE uuid_str, duckdb_uhugeint *out)
+{
+    StringValue(uuid_str);
+    const char *str = RSTRING_PTR(uuid_str);
+    long len = RSTRING_LEN(uuid_str);
+    uint64_t hi, lo;
+    if (!parse_uuid_string(str, len, &hi, &lo)) {
+        rb_raise(rb_eArgError, "Invalid UUID format: %"PRIsVALUE, uuid_str);
+    }
+    out->upper = hi;
+    out->lower = lo;
+}
+
 VALUE rbduckdb_interval_to_ruby(duckdb_interval i) {
     return rb_funcall(mDuckDBConverter, id__to_interval_from_vector, 3,
                       INT2NUM(i.months),

data/ext/duckdb/data_chunk.c

@@ -44,6 +44,16 @@ rubyDuckDBDataChunk *rbduckdb_get_struct_data_chunk(VALUE obj) {
     return ctx;
 }
 
+VALUE rbduckdb_create_data_chunk(duckdb_data_chunk chunk, bool owned) {
+    VALUE obj = allocate(cDuckDBDataChunk);
+    rubyDuckDBDataChunk *ctx;
+
+    TypedData_Get_Struct(obj, rubyDuckDBDataChunk, &data_chunk_data_type, ctx);
+    ctx->data_chunk = chunk;
+    ctx->owned = owned;
+    return obj;
+}
+
 static VALUE data_chunk_initialize(int argc, VALUE *argv, VALUE self) {
     rubyDuckDBDataChunk *ctx;
     VALUE logical_types;

data/ext/duckdb/data_chunk.h

@@ -9,6 +9,7 @@ struct _rubyDuckDBDataChunk {
 typedef struct _rubyDuckDBDataChunk rubyDuckDBDataChunk;
 
 rubyDuckDBDataChunk *rbduckdb_get_struct_data_chunk(VALUE obj);
+VALUE rbduckdb_create_data_chunk(duckdb_data_chunk chunk, bool owned);
 void rbduckdb_init_data_chunk(void);
 
 #endif

data/ext/duckdb/duckdb.c

@@ -41,7 +41,7 @@ Init_duckdb_native(void) {
     rb_define_singleton_method(mDuckDB, "library_version", duckdb_s_library_version, 0);
     rb_define_singleton_method(mDuckDB, "vector_size", duckdb_s_vector_size, 0);
 
-    rbduckdb_init_duckdb_error();
+    rbduckdb_init_error();
     rbduckdb_init_database();
     rbduckdb_init_connection();
     rbduckdb_init_result();
@@ -49,28 +49,30 @@ Init_duckdb_native(void) {
     rbduckdb_init_logical_type();
     rbduckdb_init_prepared_statement();
     rbduckdb_init_pending_result();
-    rbduckdb_init_duckdb_blob();
+    rbduckdb_init_blob();
     rbduckdb_init_appender();
-    rbduckdb_init_duckdb_config();
+    rbduckdb_init_config();
     rbduckdb_init_converter();
     rbduckdb_init_extracted_statements();
     rbduckdb_init_instance_cache();
     rbduckdb_init_value();
-    rbduckdb_init_duckdb_scalar_function();
-    rbduckdb_init_duckdb_scalar_function_set();
+    rbduckdb_init_scalar_function();
+    rbduckdb_init_scalar_function_set();
     rbduckdb_init_aggregate_function();
     rbduckdb_init_aggregate_function_set();
     rbduckdb_init_expression();
     rbduckdb_init_client_context();
-    rbduckdb_init_duckdb_scalar_function_bind_info();
+    rbduckdb_init_scalar_function_bind_info();
     rbduckdb_init_vector();
     rbduckdb_init_data_chunk();
     rbduckdb_init_memory_helper();
-    rbduckdb_init_duckdb_table_function();
-    rbduckdb_init_duckdb_table_function_bind_info();
-    rbduckdb_init_duckdb_table_function_init_info();
-    rbduckdb_init_duckdb_table_function_function_info();
+    rbduckdb_init_table_function();
+    rbduckdb_init_table_function_bind_info();
+    rbduckdb_init_table_function_init_info();
+    rbduckdb_init_table_function_function_info();
 #ifdef HAVE_DUCKDB_H_GE_V1_5_0
-    rbduckdb_init_duckdb_table_description();
+    rbduckdb_init_table_description();
 #endif
+    rbduckdb_init_arrow_array_stream();
+    rbduckdb_init_arrow_import();
 }

data/ext/duckdb/error.c

@@ -2,7 +2,19 @@
 
 VALUE eDuckDBError;
 
-void rbduckdb_init_duckdb_error(void) {
+/* Raises DuckDB::Error from a failed result. C only reads the message and error
+ * type id off the result (the result is destroyed before Ruby sees it) and passes
+ * them to DuckDB::Error.new(message, error_type_id). */
+void rbduckdb_raise_result_error(duckdb_result *result) {
+    const char *msg = duckdb_result_error(result);
+    if (!msg) {
+        msg = "DuckDB error";
+    }
+    VALUE exc = rb_funcall(eDuckDBError, rb_intern("new"), 2, rb_str_new_cstr(msg), INT2FIX(duckdb_result_error_type(result)));
+    rb_exc_raise(exc);
+}
+
+void rbduckdb_init_error(void) {
 #if 0
     VALUE mDuckDB = rb_define_module("DuckDB");
 #endif

data/ext/duckdb/error.h

@@ -1,8 +1,7 @@
 #ifndef RUBY_DUCKDB_ERROR_H
 #define RUBY_DUCKDB_ERROR_H
 
-void rbduckdb_init_duckdb_error(void);
+void rbduckdb_init_error(void);
+NORETURN(void rbduckdb_raise_result_error(duckdb_result *result));
 
 #endif
-
-

data/ext/duckdb/function_executor.c

@@ -68,6 +68,14 @@ static struct callback_request *g_request_list = NULL;
 static VALUE g_executor_thread = Qnil;
 static int g_executor_started = 0;
 
+/*
+ * GC-protection array holding every live per-worker proxy Ruby thread.
+ * Proxies are created from non-Ruby init hooks (via the global executor) and
+ * are not reachable from any marked object, so without this array the GC could
+ * collect a proxy thread while DuckDB still dispatches callbacks to it.
+ */
+static VALUE g_proxy_threads = Qnil;
+
 /* Data passed to the executor wait function */
 struct executor_wait_data {
     struct callback_request *request;
@@ -166,6 +174,11 @@ void rbduckdb_function_executor_ensure_started(void) {
     }
 #endif
 
+    if (g_proxy_threads == Qnil) {
+        g_proxy_threads = rb_ary_new();
+        rb_global_variable(&g_proxy_threads);
+    }
+
     g_executor_thread = rb_thread_create(executor_thread_func, NULL);
     rb_global_variable(&g_executor_thread);
     g_executor_started = 1;
@@ -242,7 +255,293 @@ static void *callback_with_gvl(void *data) {
     return NULL;
 }
 
-void rbduckdb_function_executor_dispatch(rbduckdb_function_callback_t cb, void *user_data) {
+/*
+ * ============================================================================
+ * Per-worker proxy thread
+ * ============================================================================
+ *
+ * One dedicated Ruby thread per DuckDB worker thread. Same hand-off protocol as
+ * the global executor (mutex + condvars), but private to a single worker so
+ * that callbacks from different workers no longer serialize through one queue.
+ *
+ * Pattern follows the FFI gem's async callback dispatcher:
+ *   https://github.com/ffi/ffi/blob/master/ext/ffi_c/Function.c
+ */
+struct worker_proxy {
+    VALUE ruby_thread;
+    volatile int stop_requested;
+    rbduckdb_function_callback_t cb;
+    void *user_data;
+    volatile int has_request;
+    volatile int request_done;
+    volatile int thread_exited;
+#ifdef _MSC_VER
+    CRITICAL_SECTION lock;
+    CONDITION_VARIABLE request_cond;
+    CONDITION_VARIABLE request_done_cond;
+    CONDITION_VARIABLE thread_exit_cond;
+#else
+    pthread_mutex_t lock;
+    pthread_cond_t request_cond;
+    pthread_cond_t request_done_cond;
+    pthread_cond_t thread_exit_cond;
+#endif
+};
+
+/* Runs without GVL: the proxy waits for a callback request */
+static void *proxy_wait_func(void *data) {
+    struct worker_proxy *proxy = (struct worker_proxy *)data;
+
+#ifdef _MSC_VER
+    EnterCriticalSection(&proxy->lock);
+    while (!proxy->stop_requested && !proxy->has_request) {
+        SleepConditionVariableCS(&proxy->request_cond, &proxy->lock, INFINITE);
+    }
+    LeaveCriticalSection(&proxy->lock);
+#else
+    pthread_mutex_lock(&proxy->lock);
+    while (!proxy->stop_requested && !proxy->has_request) {
+        pthread_cond_wait(&proxy->request_cond, &proxy->lock);
+    }
+    pthread_mutex_unlock(&proxy->lock);
+#endif
+
+    return NULL;
+}
+
+/* Unblock function for the proxy thread (VM shutdown or Thread#kill) */
+static void proxy_stop_func(void *data) {
+    struct worker_proxy *proxy = (struct worker_proxy *)data;
+
+#ifdef _MSC_VER
+    EnterCriticalSection(&proxy->lock);
+    proxy->stop_requested = 1;
+    WakeConditionVariable(&proxy->request_cond);
+    LeaveCriticalSection(&proxy->lock);
+#else
+    pthread_mutex_lock(&proxy->lock);
+    proxy->stop_requested = 1;
+    pthread_cond_signal(&proxy->request_cond);
+    pthread_mutex_unlock(&proxy->lock);
+#endif
+}
+
+/* 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;
+
+    while (!proxy->stop_requested) {
+        /* Release the GVL and wait for a request */
+        rb_thread_call_without_gvl(proxy_wait_func, proxy, proxy_stop_func, proxy);
+
+        if (proxy->stop_requested) break;
+
+        if (proxy->has_request) {
+            /* Execute the callback with the GVL held */
+            proxy->cb(proxy->user_data);
+
+            /* 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
+        }
+    }
+
+    return Qnil;
+}
+
+/*
+ * Teardown for the proxy thread. Run via rb_ensure so it executes even if an
+ * async exception (Thread#kill, VM shutdown via rb_thread_terminate_all)
+ * unwinds proxy_loop_body. If it were skipped, thread_exited would stay 0
+ * forever and rbduckdb_worker_proxy_destroy's join would deadlock.
+ */
+static VALUE proxy_cleanup(VALUE data) {
+    struct worker_proxy *proxy = (struct worker_proxy *)data;
+
+    /* Stop being GC-protected now that we are about to exit */
+    if (g_proxy_threads != Qnil) {
+        rb_ary_delete(g_proxy_threads, proxy->ruby_thread);
+    }
+
+    /*
+     * Signal that this thread has finished and no longer touches the proxy
+     * struct. Only after this may rbduckdb_worker_proxy_destroy free it.
+     */
+#ifdef _MSC_VER
+    EnterCriticalSection(&proxy->lock);
+    proxy->thread_exited = 1;
+    WakeConditionVariable(&proxy->thread_exit_cond);
+    LeaveCriticalSection(&proxy->lock);
+#else
+    pthread_mutex_lock(&proxy->lock);
+    proxy->thread_exited = 1;
+    pthread_cond_signal(&proxy->thread_exit_cond);
+    pthread_mutex_unlock(&proxy->lock);
+#endif
+
+    return Qnil;
+}
+
+/* The proxy thread entry point (Ruby thread). */
+static VALUE proxy_thread_func(void *data) {
+    return rb_ensure(proxy_loop_body, (VALUE)data, proxy_cleanup, (VALUE)data);
+}
+
+struct worker_proxy *rbduckdb_worker_proxy_create(void) {
+    /*
+     * Use calloc (not xcalloc): rbduckdb_worker_proxy_destroy frees the struct
+     * from a non-Ruby thread where xfree is unsafe.
+     */
+    struct worker_proxy *proxy = calloc(1, sizeof(struct worker_proxy));
+    if (proxy == NULL) {
+        rb_raise(rb_eNoMemError, "failed to allocate worker_proxy");
+    }
+
+    proxy->stop_requested = 0;
+    proxy->has_request = 0;
+    proxy->request_done = 0;
+    proxy->thread_exited = 0;
+
+#ifdef _MSC_VER
+    InitializeCriticalSection(&proxy->lock);
+    InitializeConditionVariable(&proxy->request_cond);
+    InitializeConditionVariable(&proxy->request_done_cond);
+    InitializeConditionVariable(&proxy->thread_exit_cond);
+#else
+    pthread_mutex_init(&proxy->lock, NULL);
+    pthread_cond_init(&proxy->request_cond, NULL);
+    pthread_cond_init(&proxy->request_done_cond, NULL);
+    pthread_cond_init(&proxy->thread_exit_cond, NULL);
+#endif
+
+    /*
+     * Lazy-init the GC-protection array so create never silently skips it (see
+     * the g_proxy_threads comment above); create runs with the GVL, so safe.
+     */
+    if (g_proxy_threads == Qnil) {
+        g_proxy_threads = rb_ary_new();
+        rb_global_variable(&g_proxy_threads);
+    }
+
+    proxy->ruby_thread = rb_thread_create(proxy_thread_func, proxy);
+    rb_ary_push(g_proxy_threads, proxy->ruby_thread);
+
+    return proxy;
+}
+
+/*
+ * Hand a callback to a proxy and block until it completes.
+ * Called from the DuckDB worker thread (non-Ruby thread) that owns this proxy.
+ */
+static void dispatch_callback_to_proxy(struct worker_proxy *proxy, rbduckdb_function_callback_t cb, void *user_data) {
+#ifdef _MSC_VER
+    EnterCriticalSection(&proxy->lock);
+    proxy->cb = cb;
+    proxy->user_data = user_data;
+    proxy->request_done = 0;
+    proxy->has_request = 1;
+    WakeConditionVariable(&proxy->request_cond);
+    LeaveCriticalSection(&proxy->lock);
+
+    EnterCriticalSection(&proxy->lock);
+    while (!proxy->request_done) {
+        SleepConditionVariableCS(&proxy->request_done_cond, &proxy->lock, INFINITE);
+    }
+    LeaveCriticalSection(&proxy->lock);
+#else
+    pthread_mutex_lock(&proxy->lock);
+    proxy->cb = cb;
+    proxy->user_data = user_data;
+    proxy->request_done = 0;
+    proxy->has_request = 1;
+    pthread_cond_signal(&proxy->request_cond);
+    pthread_mutex_unlock(&proxy->lock);
+
+    pthread_mutex_lock(&proxy->lock);
+    while (!proxy->request_done) {
+        pthread_cond_wait(&proxy->request_done_cond, &proxy->lock);
+    }
+    pthread_mutex_unlock(&proxy->lock);
+#endif
+}
+
+/* Blocks until the proxy thread has fully exited. Runs without the GVL. */
+static void *proxy_join_func(void *data) {
+    struct worker_proxy *proxy = (struct worker_proxy *)data;
+
+#ifdef _MSC_VER
+    EnterCriticalSection(&proxy->lock);
+    while (!proxy->thread_exited) {
+        SleepConditionVariableCS(&proxy->thread_exit_cond, &proxy->lock, INFINITE);
+    }
+    LeaveCriticalSection(&proxy->lock);
+#else
+    pthread_mutex_lock(&proxy->lock);
+    while (!proxy->thread_exited) {
+        pthread_cond_wait(&proxy->thread_exit_cond, &proxy->lock);
+    }
+    pthread_mutex_unlock(&proxy->lock);
+#endif
+
+    return NULL;
+}
+
+void rbduckdb_worker_proxy_destroy(void *data) {
+    struct worker_proxy *proxy = (struct worker_proxy *)data;
+    if (proxy == NULL) return;
+
+    /* Ask the proxy thread to stop. */
+#ifdef _MSC_VER
+    EnterCriticalSection(&proxy->lock);
+    proxy->stop_requested = 1;
+    WakeConditionVariable(&proxy->request_cond);
+    LeaveCriticalSection(&proxy->lock);
+#else
+    pthread_mutex_lock(&proxy->lock);
+    proxy->stop_requested = 1;
+    pthread_cond_signal(&proxy->request_cond);
+    pthread_mutex_unlock(&proxy->lock);
+#endif
+
+    /*
+     * Wait until the proxy thread has fully exited. Before exiting it runs Ruby
+     * code (removing itself from the GC-protection array), which needs the GVL.
+     * DuckDB may invoke this destructor either from a worker thread (no GVL) or
+     * — depending on when it tears down the local state — from a Ruby thread
+     * that holds the GVL. In the latter case we must release the GVL while
+     * waiting, or the proxy thread could never acquire it and we would deadlock.
+     */
+    if (ruby_native_thread_p() && ruby_thread_has_gvl_p()) {
+        rb_thread_call_without_gvl(proxy_join_func, proxy, NULL, NULL);
+    } else {
+        proxy_join_func(proxy);
+    }
+
+    /* The proxy thread is gone; tear down OS primitives and free the struct. */
+#ifdef _MSC_VER
+    DeleteCriticalSection(&proxy->lock);
+#else
+    pthread_cond_destroy(&proxy->thread_exit_cond);
+    pthread_cond_destroy(&proxy->request_done_cond);
+    pthread_cond_destroy(&proxy->request_cond);
+    pthread_mutex_destroy(&proxy->lock);
+#endif
+
+    free(proxy);
+}
+
+void rbduckdb_function_executor_dispatch_via_proxy(rbduckdb_function_callback_t cb, void *user_data, struct worker_proxy *proxy) {
     if (ruby_native_thread_p()) {
         if (ruby_thread_has_gvl_p()) {
             /* Case 1: Ruby thread with GVL - call directly */
@@ -254,8 +553,15 @@ void rbduckdb_function_executor_dispatch(rbduckdb_function_callback_t cb, void *
             arg.user_data = user_data;
             rb_thread_call_with_gvl(callback_with_gvl, &arg);
         }
+    } else if (proxy != NULL) {
+        /* Case 3a: Non-Ruby thread with a per-worker proxy */
+        dispatch_callback_to_proxy(proxy, cb, user_data);
     } else {
-        /* Case 3: Non-Ruby thread - dispatch to executor */
+        /* Case 3b: Non-Ruby thread - dispatch to the global executor */
         dispatch_callback_to_executor(cb, user_data);
     }
 }
+
+void rbduckdb_function_executor_dispatch(rbduckdb_function_callback_t cb, void *user_data) {
+    rbduckdb_function_executor_dispatch_via_proxy(cb, user_data, NULL);
+}

data/ext/duckdb/function_executor.h

@@ -43,4 +43,48 @@ void rbduckdb_function_executor_ensure_started(void);
  */
 void rbduckdb_function_executor_dispatch(rbduckdb_function_callback_t cb, void *user_data);
 
+/*
+ * ============================================================================
+ * Per-worker proxy threads (DuckDB >= 1.5.0)
+ * ============================================================================
+ *
+ * The global executor above serializes every non-Ruby-thread callback through
+ * a single Ruby thread. A per-worker proxy instead gives each DuckDB worker
+ * thread its own dedicated Ruby thread, so callbacks from different workers can
+ * run concurrently — they compete for the GVL in round-robin fashion, which
+ * helps when callbacks release the GVL (e.g. on I/O).
+ *
+ * Proxies are created lazily from DuckDB's per-worker init hook and stored in
+ * DuckDB's thread-local state; the global executor remains the fallback.
+ */
+
+/* Opaque per-worker proxy handle. */
+struct worker_proxy;
+
+/*
+ * Create a per-worker proxy thread. Must be called with the GVL held
+ * (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.
+ */
+struct worker_proxy *rbduckdb_worker_proxy_create(void);
+
+/*
+ * Destroy a per-worker proxy. The signature matches duckdb_delete_callback_t so
+ * it can be handed directly to DuckDB. Safe to call from a non-Ruby thread: it
+ * touches only OS primitives and frees memory allocated with calloc.
+ */
+void rbduckdb_worker_proxy_destroy(void *proxy);
+
+/*
+ * Like rbduckdb_function_executor_dispatch, but on the non-Ruby-thread path
+ * (Case 3) it routes through the given per-worker proxy when non-NULL, falling
+ * back to the global executor when NULL. Cases 1 and 2 are unchanged.
+ */
+void rbduckdb_function_executor_dispatch_via_proxy(rbduckdb_function_callback_t cb, void *user_data, struct worker_proxy *proxy);
+
 #endif