duckdb 1.5.6.1 → 2.0.0.1

data/ext/duckdb/function_executor.c

@@ -7,13 +7,58 @@
  *
  * See also: FFI gem's approach in ext/ffi_c/Function.c
  *   https://github.com/ffi/ffi/blob/master/ext/ffi_c/Function.c
+ *
+ * This portable sync layer is the only place in this file that splits on
+ * platform. Everything below is written once against these wrappers.
  */
 #ifdef _MSC_VER
 #include <windows.h>
+
+typedef CRITICAL_SECTION sync_mutex_t;
+typedef CONDITION_VARIABLE sync_cond_t;
+
+static void sync_mutex_init(sync_mutex_t *m) { InitializeCriticalSection(m); }
+static void sync_mutex_destroy(sync_mutex_t *m) { DeleteCriticalSection(m); }
+static void sync_lock(sync_mutex_t *m) { EnterCriticalSection(m); }
+static void sync_unlock(sync_mutex_t *m) { LeaveCriticalSection(m); }
+static void sync_cond_init(sync_cond_t *c) { InitializeConditionVariable(c); }
+/* A CONDITION_VARIABLE holds no resources and has no destroy call. */
+static void sync_cond_destroy(sync_cond_t *c) { (void)c; }
+static void sync_signal(sync_cond_t *c) { WakeConditionVariable(c); }
+static void sync_wait(sync_cond_t *c, sync_mutex_t *m) { SleepConditionVariableCS(c, m, INFINITE); }
 #else
 #include <pthread.h>
+
+typedef pthread_mutex_t sync_mutex_t;
+typedef pthread_cond_t sync_cond_t;
+
+static void sync_mutex_init(sync_mutex_t *m) { pthread_mutex_init(m, NULL); }
+static void sync_mutex_destroy(sync_mutex_t *m) { pthread_mutex_destroy(m); }
+static void sync_lock(sync_mutex_t *m) { pthread_mutex_lock(m); }
+static void sync_unlock(sync_mutex_t *m) { pthread_mutex_unlock(m); }
+static void sync_cond_init(sync_cond_t *c) { pthread_cond_init(c, NULL); }
+static void sync_cond_destroy(sync_cond_t *c) { pthread_cond_destroy(c); }
+static void sync_signal(sync_cond_t *c) { pthread_cond_signal(c); }
+static void sync_wait(sync_cond_t *c, sync_mutex_t *m) { pthread_cond_wait(c, m); }
 #endif
 
+/* Under m: set *flag and wake one waiter on c. */
+static void sync_set_and_signal(sync_mutex_t *m, sync_cond_t *c, volatile int *flag) {
+    sync_lock(m);
+    *flag = 1;
+    sync_signal(c);
+    sync_unlock(m);
+}
+
+/* Under m: block on c until *flag is set. */
+static void sync_wait_for_flag(sync_mutex_t *m, sync_cond_t *c, volatile int *flag) {
+    sync_lock(m);
+    while (!*flag) {
+        sync_wait(c, m);
+    }
+    sync_unlock(m);
+}
+
 /*
  * Thread detection functions (available since Ruby 2.3).
  * Used to determine the correct dispatch path for callbacks.
@@ -44,26 +89,19 @@ extern int ruby_native_thread_p(void);
 struct callback_request {
     rbduckdb_function_callback_t cb;
     void *user_data;
-    int done;
-#ifdef _MSC_VER
-    CRITICAL_SECTION done_lock;
-    CONDITION_VARIABLE done_cond;
-#else
-    pthread_mutex_t done_mutex;
-    pthread_cond_t done_cond;
-#endif
+    volatile int done;
+    sync_mutex_t done_lock;
+    sync_cond_t done_cond;
     struct callback_request *next;
 };
 
-/* Global executor state */
-#ifdef _MSC_VER
-static CRITICAL_SECTION g_executor_lock;
-static CONDITION_VARIABLE g_executor_cond;
+/*
+ * Global executor state. The lock and condvar are initialized once by
+ * rbduckdb_function_executor_ensure_started, before any worker can use them.
+ */
+static sync_mutex_t g_executor_lock;
+static sync_cond_t g_executor_cond;
 static int g_sync_initialized = 0;
-#else
-static pthread_mutex_t g_executor_mutex = PTHREAD_MUTEX_INITIALIZER;
-static pthread_cond_t g_executor_cond = PTHREAD_COND_INITIALIZER;
-#endif
 static struct callback_request *g_request_list = NULL;
 static VALUE g_executor_thread = Qnil;
 static int g_executor_started = 0;
@@ -76,6 +114,14 @@ static int g_executor_started = 0;
  */
 static VALUE g_proxy_threads = Qnil;
 
+/* Lazy-init g_proxy_threads. Must be called with the GVL. */
+static void proxy_threads_ensure(void) {
+    if (g_proxy_threads == Qnil) {
+        g_proxy_threads = rb_ary_new();
+        rb_global_variable(&g_proxy_threads);
+    }
+}
+
 /*
  * Replace embedded NUL bytes so the message can be handed to a C API.
  * Returns str unchanged when there is nothing to replace.
@@ -125,7 +171,7 @@ VALUE rbduckdb_pending_error_message(void) {
 /* Data passed to the executor wait function */
 struct executor_wait_data {
     struct callback_request *request;
-    int stop;
+    volatile int stop;
 };
 
 /* Runs without GVL: blocks on condvar waiting for a callback request */
@@ -134,27 +180,15 @@ static void *executor_wait_func(void *data) {
 
     w->request = NULL;
 
-#ifdef _MSC_VER
-    EnterCriticalSection(&g_executor_lock);
-    while (!w->stop && g_request_list == NULL) {
-        SleepConditionVariableCS(&g_executor_cond, &g_executor_lock, INFINITE);
-    }
-    if (g_request_list != NULL) {
-        w->request = g_request_list;
-        g_request_list = g_request_list->next;
-    }
-    LeaveCriticalSection(&g_executor_lock);
-#else
-    pthread_mutex_lock(&g_executor_mutex);
+    sync_lock(&g_executor_lock);
     while (!w->stop && g_request_list == NULL) {
-        pthread_cond_wait(&g_executor_cond, &g_executor_mutex);
+        sync_wait(&g_executor_cond, &g_executor_lock);
     }
     if (g_request_list != NULL) {
         w->request = g_request_list;
         g_request_list = g_request_list->next;
     }
-    pthread_mutex_unlock(&g_executor_mutex);
-#endif
+    sync_unlock(&g_executor_lock);
 
     return NULL;
 }
@@ -163,17 +197,7 @@ static void *executor_wait_func(void *data) {
 static void executor_stop_func(void *data) {
     struct executor_wait_data *w = (struct executor_wait_data *)data;
 
-#ifdef _MSC_VER
-    EnterCriticalSection(&g_executor_lock);
-    w->stop = 1;
-    WakeConditionVariable(&g_executor_cond);
-    LeaveCriticalSection(&g_executor_lock);
-#else
-    pthread_mutex_lock(&g_executor_mutex);
-    w->stop = 1;
-    pthread_cond_signal(&g_executor_cond);
-    pthread_mutex_unlock(&g_executor_mutex);
-#endif
+    sync_set_and_signal(&g_executor_lock, &g_executor_cond, &w->stop);
 }
 
 /*
@@ -200,18 +224,7 @@ static VALUE request_run_body(VALUE varg) {
 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
-
+    sync_set_and_signal(&req->done_lock, &req->done_cond, &req->done);
     return Qnil;
 }
 
@@ -244,18 +257,13 @@ static VALUE executor_thread_func(void *data) {
 void rbduckdb_function_executor_ensure_started(void) {
     if (g_executor_started) return;
 
-#ifdef _MSC_VER
     if (!g_sync_initialized) {
-        InitializeCriticalSection(&g_executor_lock);
-        InitializeConditionVariable(&g_executor_cond);
+        sync_mutex_init(&g_executor_lock);
+        sync_cond_init(&g_executor_cond);
         g_sync_initialized = 1;
     }
-#endif
 
-    if (g_proxy_threads == Qnil) {
-        g_proxy_threads = rb_ary_new();
-        rb_global_variable(&g_proxy_threads);
-    }
+    proxy_threads_ensure();
 
     g_executor_thread = rb_thread_create(executor_thread_func, NULL);
     rb_global_variable(&g_executor_thread);
@@ -275,46 +283,21 @@ static void dispatch_callback_to_executor(rbduckdb_function_callback_t cb, void
     req.done = 0;
     req.next = NULL;
 
-#ifdef _MSC_VER
-    InitializeCriticalSection(&req.done_lock);
-    InitializeConditionVariable(&req.done_cond);
-
-    /* Enqueue the request */
-    EnterCriticalSection(&g_executor_lock);
-    req.next = g_request_list;
-    g_request_list = &req;
-    WakeConditionVariable(&g_executor_cond);
-    LeaveCriticalSection(&g_executor_lock);
-
-    /* Wait for the executor to process our callback */
-    EnterCriticalSection(&req.done_lock);
-    while (!req.done) {
-        SleepConditionVariableCS(&req.done_cond, &req.done_lock, INFINITE);
-    }
-    LeaveCriticalSection(&req.done_lock);
-
-    DeleteCriticalSection(&req.done_lock);
-#else
-    pthread_mutex_init(&req.done_mutex, NULL);
-    pthread_cond_init(&req.done_cond, NULL);
+    sync_mutex_init(&req.done_lock);
+    sync_cond_init(&req.done_cond);
 
     /* Enqueue the request */
-    pthread_mutex_lock(&g_executor_mutex);
+    sync_lock(&g_executor_lock);
     req.next = g_request_list;
     g_request_list = &req;
-    pthread_cond_signal(&g_executor_cond);
-    pthread_mutex_unlock(&g_executor_mutex);
+    sync_signal(&g_executor_cond);
+    sync_unlock(&g_executor_lock);
 
     /* Wait for the executor to process our callback */
-    pthread_mutex_lock(&req.done_mutex);
-    while (!req.done) {
-        pthread_cond_wait(&req.done_cond, &req.done_mutex);
-    }
-    pthread_mutex_unlock(&req.done_mutex);
+    sync_wait_for_flag(&req.done_lock, &req.done_cond, &req.done);
 
-    pthread_cond_destroy(&req.done_cond);
-    pthread_mutex_destroy(&req.done_mutex);
-#endif
+    sync_cond_destroy(&req.done_cond);
+    sync_mutex_destroy(&req.done_lock);
 }
 
 /* Payload for rb_thread_call_with_gvl wrapper */
@@ -353,55 +336,36 @@ struct worker_proxy {
     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
+    sync_mutex_t lock;
+    sync_cond_t request_cond;
+    sync_cond_t request_done_cond;
+    sync_cond_t thread_exit_cond;
 };
 
-/* Runs without GVL: the proxy waits for a callback request */
+/*
+ * Runs without GVL: the proxy waits for a callback request. Returns non-NULL
+ * if the request should run, NULL if the proxy should stop. The flags are
+ * read here, under the lock, so the caller never reads them unlocked.
+ */
 static void *proxy_wait_func(void *data) {
     struct worker_proxy *proxy = (struct worker_proxy *)data;
+    int run;
 
-#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);
+    sync_lock(&proxy->lock);
     while (!proxy->stop_requested && !proxy->has_request) {
-        pthread_cond_wait(&proxy->request_cond, &proxy->lock);
+        sync_wait(&proxy->request_cond, &proxy->lock);
     }
-    pthread_mutex_unlock(&proxy->lock);
-#endif
+    run = !proxy->stop_requested;
+    sync_unlock(&proxy->lock);
 
-    return NULL;
+    return run ? proxy : 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
+    sync_set_and_signal(&proxy->lock, &proxy->request_cond, &proxy->stop_requested);
 }
 
 static VALUE proxy_run_body(VALUE data) {
@@ -414,19 +378,11 @@ static VALUE proxy_run_body(VALUE data) {
 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);
+    sync_lock(&proxy->lock);
     proxy->has_request = 0;
     proxy->request_done = 1;
-    pthread_cond_signal(&proxy->request_done_cond);
-    pthread_mutex_unlock(&proxy->lock);
-#endif
+    sync_signal(&proxy->request_done_cond);
+    sync_unlock(&proxy->lock);
 
     return Qnil;
 }
@@ -439,19 +395,13 @@ static VALUE proxy_run(VALUE data) {
 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) {
-            int state = 0;
+    /* Release the GVL and wait for a request */
+    while (rb_thread_call_without_gvl(proxy_wait_func, proxy, proxy_stop_func, proxy) != NULL) {
+        int state = 0;
 
-            rb_protect(proxy_run, data, &state);
-            if (state) {
-                discard_callback_exception(state);
-            }
+        rb_protect(proxy_run, data, &state);
+        if (state) {
+            discard_callback_exception(state);
         }
     }
 
@@ -475,19 +425,14 @@ static VALUE proxy_cleanup(VALUE data) {
     /*
      * Signal that this thread has finished and no longer touches the proxy
      * struct. Only after this may rbduckdb_worker_proxy_destroy free it.
+     * Also wake a worker waiting on a request this thread will never run
+     * (e.g. Thread#kill while idle, #1512); it falls back to the executor.
      */
-#ifdef _MSC_VER
-    EnterCriticalSection(&proxy->lock);
-    proxy->thread_exited = 1;
-    WakeConditionVariable(&proxy->thread_exit_cond);
-    LeaveCriticalSection(&proxy->lock);
-#else
-    pthread_mutex_lock(&proxy->lock);
+    sync_lock(&proxy->lock);
     proxy->thread_exited = 1;
-    pthread_cond_signal(&proxy->thread_exit_cond);
-    pthread_mutex_unlock(&proxy->lock);
-#endif
-
+    sync_signal(&proxy->thread_exit_cond);
+    sync_signal(&proxy->request_done_cond);
+    sync_unlock(&proxy->lock);
     return Qnil;
 }
 
@@ -496,12 +441,39 @@ static VALUE proxy_thread_func(void *data) {
     return rb_ensure(proxy_loop_body, (VALUE)data, proxy_cleanup, (VALUE)data);
 }
 
+/* Tear down the OS primitives and free the struct. The proxy thread must be gone. */
+static void proxy_free(struct worker_proxy *proxy) {
+    sync_cond_destroy(&proxy->thread_exit_cond);
+    sync_cond_destroy(&proxy->request_done_cond);
+    sync_cond_destroy(&proxy->request_cond);
+    sync_mutex_destroy(&proxy->lock);
+
+    free(proxy);
+}
+
+static VALUE proxy_start_thread(VALUE data) {
+    struct worker_proxy *proxy = (struct worker_proxy *)data;
+
+    proxy->ruby_thread = rb_thread_create(proxy_thread_func, proxy);
+    rb_ary_push(g_proxy_threads, proxy->ruby_thread);
+    return Qnil;
+}
+
 struct worker_proxy *rbduckdb_worker_proxy_create(void) {
+    struct worker_proxy *proxy;
+    int state = 0;
+
+    /*
+     * Before allocating so a raise here leaks nothing; create runs with the
+     * GVL, so safe.
+     */
+    proxy_threads_ensure();
+
     /*
      * 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));
+    proxy = calloc(1, sizeof(struct worker_proxy));
     if (proxy == NULL) {
         rb_raise(rb_eNoMemError, "failed to allocate worker_proxy");
     }
@@ -511,87 +483,101 @@ struct worker_proxy *rbduckdb_worker_proxy_create(void) {
     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
+    sync_mutex_init(&proxy->lock);
+    sync_cond_init(&proxy->request_cond);
+    sync_cond_init(&proxy->request_done_cond);
+    sync_cond_init(&proxy->thread_exit_cond);
 
-    /*
-     * 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);
+    rb_protect(proxy_start_thread, (VALUE)proxy, &state);
+    if (state) {
+        if (proxy->ruby_thread) {
+            /*
+             * The thread started but could not be registered (rb_ary_push
+             * raised NoMemError): stop and join it. Like any destroy, the join
+             * has no unblock function; see #1512 for the hang analysis.
+             */
+            rbduckdb_worker_proxy_destroy(proxy);
+        } else {
+            /* rb_thread_create raised: no thread ever touched the proxy. */
+            proxy_free(proxy);
+        }
+        rb_jump_tag(state);
     }
 
-    proxy->ruby_thread = rb_thread_create(proxy_thread_func, proxy);
-    rb_ary_push(g_proxy_threads, proxy->ruby_thread);
-
     return proxy;
 }
 
+struct create_proxy_callback_arg {
+    struct worker_proxy *proxy;
+};
+
+static VALUE create_proxy_callback(VALUE varg) {
+    struct create_proxy_callback_arg *arg = (struct create_proxy_callback_arg *)varg;
+    arg->proxy = rbduckdb_worker_proxy_create();
+    return Qnil;
+}
+
+/*
+ * rbduckdb_worker_proxy_create may raise (NoMemError, Thread.new failure),
+ * and the executor runs callbacks unprotected - a raise would longjmp past
+ * its done-signaling and block the waiting DuckDB worker forever. Swallow
+ * the exception instead: the proxy stays NULL and the caller falls back to
+ * the global executor.
+ */
+static void create_proxy_callback_protected(void *user_data) {
+    int exception_state;
+
+    rb_protect(create_proxy_callback, (VALUE)user_data, &exception_state);
+    if (exception_state) {
+        rb_set_errinfo(Qnil);
+    }
+}
+
+struct worker_proxy *rbduckdb_worker_proxy_create_for_current_thread(void) {
+    struct create_proxy_callback_arg arg;
+
+    /* A Ruby calling thread runs the callback inline (Case 1/2); no proxy needed. */
+    if (ruby_native_thread_p()) return NULL;
+
+    arg.proxy = NULL;
+    rbduckdb_function_executor_dispatch(create_proxy_callback_protected, &arg);
+    return arg.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.
+ * If the proxy thread has exited (or exits before running the request), the
+ * callback goes to the global executor instead.
  */
 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);
+    int done;
 
-    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;
+    sync_lock(&proxy->lock);
     proxy->request_done = 0;
-    proxy->has_request = 1;
-    pthread_cond_signal(&proxy->request_cond);
-    pthread_mutex_unlock(&proxy->lock);
+    if (!proxy->thread_exited) {
+        proxy->cb = cb;
+        proxy->user_data = user_data;
+        proxy->has_request = 1;
+        sync_signal(&proxy->request_cond);
+        while (!proxy->request_done && !proxy->thread_exited) {
+            sync_wait(&proxy->request_done_cond, &proxy->lock);
+        }
+        proxy->has_request = 0;
+    }
+    done = proxy->request_done;
+    sync_unlock(&proxy->lock);
 
-    pthread_mutex_lock(&proxy->lock);
-    while (!proxy->request_done) {
-        pthread_cond_wait(&proxy->request_done_cond, &proxy->lock);
+    if (!done) {
+        dispatch_callback_to_executor(cb, user_data);
     }
-    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
-
+    sync_wait_for_flag(&proxy->lock, &proxy->thread_exit_cond, &proxy->thread_exited);
     return NULL;
 }
 
@@ -600,17 +586,7 @@ void rbduckdb_worker_proxy_destroy(void *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
+    proxy_stop_func(proxy);
 
     /*
      * Wait until the proxy thread has fully exited. Before exiting it runs Ruby
@@ -626,17 +602,7 @@ void rbduckdb_worker_proxy_destroy(void *data) {
         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);
+    proxy_free(proxy);
 }
 
 void rbduckdb_function_executor_dispatch_via_proxy(rbduckdb_function_callback_t cb, void *user_data, struct worker_proxy *proxy) {

data/ext/duckdb/function_executor.h

@@ -72,6 +72,16 @@ struct worker_proxy;
  */
 struct worker_proxy *rbduckdb_worker_proxy_create(void);
 
+/*
+ * Create a per-worker proxy for the calling DuckDB worker thread, for use from
+ * a per-worker init callback. Returns NULL when called from a Ruby thread (the
+ * callback then runs inline, no proxy needed) or when creation failed (the
+ * exception is swallowed; callers fall back to the global executor). The caller
+ * stores the proxy as its state, with rbduckdb_worker_proxy_destroy as the
+ * destructor.
+ */
+struct worker_proxy *rbduckdb_worker_proxy_create_for_current_thread(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

data/ext/duckdb/function_vector.c

@@ -219,3 +219,29 @@ void rbduckdb_vector_set_value_at(duckdb_vector vector, duckdb_logical_type elem
             break;
     }
 }
+
+void rbduckdb_input_columns_load(duckdb_data_chunk input, idx_t n, duckdb_vector **vectors, duckdb_logical_type **types) {
+    idx_t j;
+
+    *vectors = ALLOC_N(duckdb_vector, n);
+    *types = ALLOC_N(duckdb_logical_type, n);
+
+    for (j = 0; j < n; j++) {
+        (*vectors)[j] = duckdb_data_chunk_get_vector(input, j);
+        (*types)[j] = duckdb_vector_get_column_type((*vectors)[j]);
+    }
+}
+
+void rbduckdb_input_columns_free(duckdb_vector *vectors, duckdb_logical_type *types, idx_t n) {
+    idx_t j;
+
+    if (types != NULL) {
+        for (j = 0; j < n; j++) {
+            duckdb_destroy_logical_type(&types[j]);
+        }
+        xfree(types);
+    }
+    if (vectors != NULL) {
+        xfree(vectors);
+    }
+}