duckdb 1.5.0.0 → 1.5.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6967e763877e2be25116e63383c683925023ba9d51f606da6ebf1479f3725218
-  data.tar.gz: 4b024d154a89394ae168b066aff4073c3a26c1166177bccafad9e9c534dba1ea
+  metadata.gz: 249a190d19c8c4b8ff32f06621a8fd2cba6690008a593e33603761810e3f2263
+  data.tar.gz: f0dd19a5a1b197cf22731b40741771e36b04a59b28388fb68fde6af76233d68e
 SHA512:
-  metadata.gz: 4ac2ab683a46d76848b78cbcbe6505fb7adba13d5ea17eeb3565993b956a348180a2c1db870593acbc6ec5a2ee9313db6c7668652706a542e90a67ba4e59f415
-  data.tar.gz: bcbb01e9178545de06088061aa5a24aae405db4f9c970ef5383a636ae777ce791858c634fdc7f0fbb1d8812831c78221349c4df689f929a39648022625094824
+  metadata.gz: 381f2d2ac0b028e0a8fb2b8ab0f18f22f876f81f868d7921cb6952eaa5059a35f6d87e4bdf39b823de25fa5e0b59f349efdc77507e361aeaac032bf402211b3a
+  data.tar.gz: 8472e39a5f8e1136193f718ad436989fba3ddffe1c5072adc775a59490c08f5a141d2a2826a314413a5a5472aea2c92af467f479e7f2f013fb06bc9630bfd3d0

data/.github/workflows/test_on_macos.yml

@@ -69,9 +69,20 @@ jobs:
       run: |
         bundle exec rake build -- --with-duckdb-include=${GITHUB_WORKSPACE}/duckdb-v${DUCKDB_VERSION}/src/include --with-duckdb-lib=${GITHUB_WORKSPACE}/duckdb-v${DUCKDB_VERSION}/build/release/src/
 
+    - name: Setup MySQL
+      run: |
+        brew install mysql
+        brew services start mysql
+        sleep 5
+        mysql -u root -e "CREATE DATABASE test_db;"
+        mysql -u root -e "CREATE USER 'test_user'@'127.0.0.1' IDENTIFIED BY 'test_password';"
+        mysql -u root -e "GRANT ALL PRIVILEGES ON test_db.* TO 'test_user'@'127.0.0.1';"
+        mysql -u root -e "FLUSH PRIVILEGES;"
+
     - name: test with Ruby ${{ matrix.ruby }}
       env:
         DUCKDB_VERSION: ${{ matrix.duckdb }}
+        MYSQL_TEST: 1
       run: |
         export DYLD_LIBRARY_PATH=${GITHUB_WORKSPACE}/duckdb-v${DUCKDB_VERSION}/build/release/src:${DYLD_LIBRARY_PATH}
         env RUBYOPT=-W:deprecated rake test

data/.github/workflows/test_on_ubuntu.yml

@@ -23,6 +23,18 @@ jobs:
         ruby: ['3.2.9', '3.3.10', '3.4.9', '4.0.1', 'head']
         duckdb: ['1.4.4', '1.5.0']
 
+    services:
+      mysql:
+        image: mysql:8.0
+        env:
+          MYSQL_ROOT_PASSWORD: root
+          MYSQL_DATABASE: test_db
+          MYSQL_USER: test_user
+          MYSQL_PASSWORD: test_password
+        ports:
+          - 3306:3306
+        options: --health-cmd="mysqladmin ping" --health-interval=10s --health-timeout=5s --health-retries=3
+
     steps:
     - uses: actions/checkout@v4
 
@@ -72,6 +84,7 @@ jobs:
     - name: test with Ruby ${{ matrix.ruby }}
       env:
         DUCKDB_VERSION: ${{ matrix.duckdb }}
+        MYSQL_TEST: 1
       run: |
         env RUBYOPT=-W:deprecated rake test
 

data/CHANGELOG.md

@@ -4,7 +4,12 @@ All notable changes to this project will be documented in this file.
 
 # Unreleased
 
-# 1.5.5.0 - 2026-03-15
+# 1.5.0.1 - 2026-03-17
+
+- enable `DuckDB::ScalarFunction` work with duckdb multi threads.
+- fix mysql_query fails
+
+# 1.5.0.0 - 2026-03-15
 - bump duckdb to 1.5.0 on CI.
 
 ## Breaking changes

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    duckdb (1.5.0.0)
+    duckdb (1.5.0.1)
       bigdecimal (>= 3.1.4)
 
 GEM

data/ext/duckdb/connection.c

@@ -147,6 +147,24 @@ static VALUE duckdb_connection_connect(VALUE self, VALUE oDuckDBDatabase) {
     return self;
 }
 
+struct query_nogvl_args {
+    duckdb_connection con;
+    const char *sql;
+    duckdb_result *out_result;
+    duckdb_state retval;
+};
+
+/*
+ * Execute duckdb_query without the GVL.
+ * This allows other Ruby threads (including the scalar function executor thread)
+ * to acquire the GVL while the query runs.
+ */
+static void *duckdb_query_nogvl(void *arg) {
+    struct query_nogvl_args *a = (struct query_nogvl_args *)arg;
+    a->retval = duckdb_query(a->con, a->sql, a->out_result);
+    return NULL;
+}
+
 /* :nodoc: */
 static VALUE duckdb_connection_query_sql(VALUE self, VALUE str) {
     rubyDuckDBConnection *ctx;
@@ -161,7 +179,21 @@ static VALUE duckdb_connection_query_sql(VALUE self, VALUE str) {
         rb_raise(eDuckDBError, "Database connection closed");
     }
 
-    if (duckdb_query(ctx->con, StringValueCStr(str), &(ctxr->result)) == DuckDBError) {
+    /* Extract C string before releasing GVL (StringValueCStr is a Ruby operation) */
+    const char *sql = StringValueCStr(str);
+
+    struct query_nogvl_args args = {
+        .con = ctx->con,
+        .sql = sql,
+        .out_result = &(ctxr->result),
+        .retval = DuckDBError,
+    };
+
+    rb_thread_call_without_gvl(duckdb_query_nogvl, &args, RUBY_UBF_IO, 0);
+
+    RB_GC_GUARD(str);
+
+    if (args.retval == DuckDBError) {
         rb_raise(eDuckDBError, "%s", duckdb_result_error(&(ctxr->result)));
     }
     return result;

data/ext/duckdb/scalar_function.c

@@ -1,5 +1,26 @@
 #include "ruby-duckdb.h"
 
+/*
+ * Cross-platform threading primitives.
+ * MSVC (mswin) does not provide <pthread.h>.
+ * MinGW-w64 (mingw, ucrt) provides <pthread.h> via winpthreads.
+ *
+ * See also: FFI gem's approach in ext/ffi_c/Function.c
+ *   https://github.com/ffi/ffi/blob/master/ext/ffi_c/Function.c
+ */
+#ifdef _MSC_VER
+#include <windows.h>
+#else
+#include <pthread.h>
+#endif
+
+/*
+ * Thread detection functions (available since Ruby 2.3).
+ * Used to determine the correct dispatch path for scalar function callbacks.
+ */
+extern int ruby_thread_has_gvl_p(void);
+extern int ruby_native_thread_p(void);
+
 VALUE cDuckDBScalarFunction;
 
 static void mark(void *);
@@ -17,6 +38,7 @@ static void vector_set_value_at(duckdb_vector vector, duckdb_logical_type elemen
 
 struct callback_arg {
     rubyDuckDBScalarFunction *ctx;
+    duckdb_function_info info;
     duckdb_data_chunk input;
     duckdb_vector output;
     duckdb_logical_type output_type;
@@ -31,6 +53,261 @@ static VALUE process_rows(VALUE arg);
 static VALUE process_no_param_rows(VALUE arg);
 static VALUE cleanup_callback(VALUE arg);
 
+/*
+ * ============================================================================
+ * Global Executor Thread
+ * ============================================================================
+ *
+ * DuckDB calls scalar function callbacks from its own worker threads, which
+ * are NOT Ruby threads. Ruby's GVL (Global VM Lock) cannot be acquired from
+ * non-Ruby threads (rb_thread_call_with_gvl crashes with rb_bug).
+ *
+ * Solution (modeled after FFI gem's async callback dispatcher):
+ * - A global Ruby "executor" thread waits for callback requests.
+ * - DuckDB worker threads enqueue requests via pthread mutex/condvar and block.
+ * - The executor thread processes callbacks with the GVL, then signals completion.
+ *
+ * When the callback is invoked from a Ruby thread (e.g., threads=1 where DuckDB
+ * uses the calling thread), we use rb_thread_call_with_gvl directly, avoiding
+ * the executor overhead.
+ */
+
+/* Per-callback request, stack-allocated on the DuckDB worker thread */
+struct callback_request {
+    struct callback_arg *cb_arg;
+    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
+    struct callback_request *next;
+};
+
+/* Global executor state */
+#ifdef _MSC_VER
+static CRITICAL_SECTION g_executor_lock;
+static CONDITION_VARIABLE 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;
+
+/* Data passed to the executor wait function */
+struct executor_wait_data {
+    struct callback_request *request;
+    int stop;
+};
+
+/* Runs without GVL: blocks on condvar waiting for a callback request */
+static void *executor_wait_func(void *data) {
+    struct executor_wait_data *w = (struct executor_wait_data *)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);
+    while (!w->stop && g_request_list == NULL) {
+        pthread_cond_wait(&g_executor_cond, &g_executor_mutex);
+    }
+    if (g_request_list != NULL) {
+        w->request = g_request_list;
+        g_request_list = g_request_list->next;
+    }
+    pthread_mutex_unlock(&g_executor_mutex);
+#endif
+
+    return NULL;
+}
+
+/* Unblock function: called by Ruby to interrupt the executor (e.g., VM shutdown) */
+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
+}
+
+/* Execute a callback (called with GVL held) */
+static VALUE execute_callback(VALUE varg) {
+    struct callback_arg *arg = (struct callback_arg *)varg;
+
+    if (arg->col_count == 0) {
+        rb_ensure(process_no_param_rows, (VALUE)arg, cleanup_callback, (VALUE)arg);
+    } else {
+        rb_ensure(process_rows, (VALUE)arg, cleanup_callback, (VALUE)arg);
+    }
+
+    return Qnil;
+}
+
+/*
+ * Execute a callback with rb_protect and report any Ruby exception
+ * to DuckDB via duckdb_scalar_function_set_error.
+ */
+static void execute_callback_protected(struct callback_arg *arg) {
+    int exception_state;
+
+    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);
+    }
+}
+
+/* The executor thread main loop (Ruby thread) */
+static VALUE executor_thread_func(void *data) {
+    struct executor_wait_data w;
+    w.stop = 0;
+
+    while (!w.stop) {
+        /* Release GVL and wait for a callback request */
+        rb_thread_call_without_gvl(executor_wait_func, &w, executor_stop_func, &w);
+
+        if (w.request != NULL) {
+            struct callback_request *req = w.request;
+
+            /* Execute the Ruby callback with the GVL */
+            execute_callback_protected(req->cb_arg);
+
+            /* 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
+        }
+    }
+
+    return Qnil;
+}
+
+/*
+ * Start the global executor thread (must be called from a Ruby thread).
+ *
+ * Thread safety: This function is only called from
+ * rbduckdb_scalar_function_set_function(), which is a Ruby method and
+ * always runs with the GVL held.  The GVL serializes all calls, so the
+ * g_executor_started check-then-set is safe without an extra mutex.
+ */
+static void ensure_executor_started(void) {
+    if (g_executor_started) return;
+
+#ifdef _MSC_VER
+    if (!g_sync_initialized) {
+        InitializeCriticalSection(&g_executor_lock);
+        InitializeConditionVariable(&g_executor_cond);
+        g_sync_initialized = 1;
+    }
+#endif
+
+    g_executor_thread = rb_thread_create(executor_thread_func, NULL);
+    rb_global_variable(&g_executor_thread);
+    g_executor_started = 1;
+}
+
+/*
+ * Dispatch a callback to the global executor thread.
+ * Called from a DuckDB worker thread (non-Ruby thread).
+ * The caller blocks until the callback is processed.
+ */
+static void dispatch_callback_to_executor(struct callback_arg *arg) {
+    struct callback_request req;
+
+    req.cb_arg = arg;
+    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);
+
+    /* Enqueue the request */
+    pthread_mutex_lock(&g_executor_mutex);
+    req.next = g_request_list;
+    g_request_list = &req;
+    pthread_cond_signal(&g_executor_cond);
+    pthread_mutex_unlock(&g_executor_mutex);
+
+    /* 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);
+
+    pthread_cond_destroy(&req.done_cond);
+    pthread_mutex_destroy(&req.done_mutex);
+#endif
+}
+
+/*
+ * Wrapper for rb_thread_call_with_gvl: executes the callback after
+ * re-acquiring the GVL. Used when a Ruby thread (without GVL) is the caller.
+ */
+static void *callback_with_gvl(void *data) {
+    execute_callback_protected((struct callback_arg *)data);
+    return NULL;
+}
+
+/* ============================================================================
+ * End of Executor Thread
+ * ============================================================================ */
+
 static const rb_data_type_t scalar_function_data_type = {
     "DuckDB/ScalarFunction",
     {mark, deallocate, memsize, compact},
@@ -112,6 +389,14 @@ static VALUE rbduckdb_scalar_function_add_parameter(VALUE self, VALUE logical_ty
     return self;
 }
 
+/*
+ * The DuckDB callback entry point.
+ *
+ * Three dispatch paths (modeled after FFI gem):
+ *   1. Ruby thread WITH GVL    -> call directly
+ *   2. Ruby thread WITHOUT GVL -> rb_thread_call_with_gvl
+ *   3. Non-Ruby thread         -> dispatch to global executor thread
+ */
 static void scalar_function_callback(duckdb_function_info info, duckdb_data_chunk input, duckdb_vector output) {
     rubyDuckDBScalarFunction *ctx;
     idx_t i;
@@ -120,7 +405,7 @@ static void scalar_function_callback(duckdb_function_info info, duckdb_data_chun
     ctx = (rubyDuckDBScalarFunction *)duckdb_scalar_function_get_extra_info(info);
 
     if (ctx == NULL || ctx->function_proc == Qnil) {
-        // Mark all rows as NULL to avoid returning uninitialized data
+        /* Mark all rows as NULL to avoid returning uninitialized data */
         idx_t row_count = duckdb_data_chunk_get_size(input);
         uint64_t *validity;
         duckdb_vector_ensure_validity_writable(output);
@@ -131,8 +416,9 @@ static void scalar_function_callback(duckdb_function_info info, duckdb_data_chun
         return;
     }
 
-    // Initialize callback argument structure
+    /* Initialize callback argument structure */
     arg.ctx = ctx;
+    arg.info = info;
     arg.input = input;
     arg.output = output;
     arg.output_type = duckdb_vector_get_column_type(output);
@@ -142,14 +428,18 @@ static void scalar_function_callback(duckdb_function_info info, duckdb_data_chun
     arg.row_count = duckdb_data_chunk_get_size(input);
     arg.col_count = duckdb_data_chunk_get_column_count(input);
 
-    // If no parameters, call block once and replicate result to all rows
-    if (arg.col_count == 0) {
-        rb_ensure(process_no_param_rows, (VALUE)&arg, cleanup_callback, (VALUE)&arg);
-        return;
+    if (ruby_native_thread_p()) {
+        if (ruby_thread_has_gvl_p()) {
+            /* Case 1: Ruby thread with GVL - call directly */
+            execute_callback_protected(&arg);
+        } else {
+            /* Case 2: Ruby thread without GVL - reacquire GVL */
+            rb_thread_call_with_gvl(callback_with_gvl, &arg);
+        }
+    } else {
+        /* Case 3: Non-Ruby thread - dispatch to executor */
+        dispatch_callback_to_executor(&arg);
     }
-
-    // Process rows with proper cleanup on exception
-    rb_ensure(process_rows, (VALUE)&arg, cleanup_callback, (VALUE)&arg);
 }
 
 static VALUE process_no_param_rows(VALUE varg) {
@@ -171,28 +461,28 @@ static VALUE process_rows(VALUE varg) {
     idx_t i, j;
     VALUE result;
 
-    // Allocate arrays to hold input vectors and their types
+    /* 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
+    /* Get all input vectors and their types */
     for (j = 0; j < arg->col_count; j++) {
         arg->input_vectors[j] = duckdb_data_chunk_get_vector(arg->input, j);
         arg->input_types[j] = duckdb_vector_get_column_type(arg->input_vectors[j]);
     }
 
-    // Process each row
+    /* Process each row */
     for (i = 0; i < arg->row_count; i++) {
-        // Build arguments array for this row using vector_value_at
+        /* 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);
         }
 
-        // Call the Ruby block with the arguments
+        /* Call the Ruby block with the arguments */
         result = rb_funcallv(arg->ctx->function_proc, rb_intern("call"), arg->col_count, arg->args);
 
-        // Write result to output using helper function
+        /* Write result to output using helper function */
         vector_set_value_at(arg->output, arg->output_type, i, result);
     }
 
@@ -203,7 +493,7 @@ static VALUE cleanup_callback(VALUE varg) {
     struct callback_arg *arg = (struct callback_arg *)varg;
     idx_t j;
 
-    // Destroy all logical types
+    /* Destroy all logical types */
     if (arg->input_types != NULL) {
         for (j = 0; j < arg->col_count; j++) {
             duckdb_destroy_logical_type(&arg->input_types[j]);
@@ -211,7 +501,7 @@ static VALUE cleanup_callback(VALUE varg) {
     }
     duckdb_destroy_logical_type(&arg->output_type);
 
-    // Free allocated memory
+    /* Free allocated memory */
     if (arg->args != NULL) {
         xfree(arg->args);
     }
@@ -230,7 +520,7 @@ static void vector_set_value_at(duckdb_vector vector, duckdb_logical_type elemen
     void* vector_data;
     uint64_t *validity;
 
-    // Handle NULL values
+    /* Handle NULL values */
     if (value == Qnil) {
         duckdb_vector_ensure_validity_writable(vector);
         validity = duckdb_vector_get_validity(vector);
@@ -276,7 +566,7 @@ static void vector_set_value_at(duckdb_vector vector, duckdb_logical_type elemen
             ((double *)vector_data)[index] = NUM2DBL(value);
             break;
         case DUCKDB_TYPE_VARCHAR: {
-            // VARCHAR requires special API, not direct array assignment
+            /* VARCHAR requires special API, not direct array assignment */
             VALUE str = rb_obj_as_string(value);
             const char *str_ptr = StringValuePtr(str);
             idx_t str_len = RSTRING_LEN(str);
@@ -284,7 +574,7 @@ static void vector_set_value_at(duckdb_vector vector, duckdb_logical_type elemen
             break;
         }
         case DUCKDB_TYPE_BLOB: {
-            // BLOB uses same API as VARCHAR, but expects binary data
+            /* BLOB uses same API as VARCHAR, but expects binary data */
             VALUE str = rb_obj_as_string(value);
             const char *str_ptr = StringValuePtr(str);
             idx_t str_len = RSTRING_LEN(str);
@@ -292,7 +582,7 @@ static void vector_set_value_at(duckdb_vector vector, duckdb_logical_type elemen
             break;
         }
         case DUCKDB_TYPE_TIMESTAMP: {
-            // Convert Ruby Time to DuckDB timestamp (microseconds since epoch)
+            /* Convert Ruby Time to DuckDB timestamp (microseconds since epoch) */
             if (!rb_obj_is_kind_of(value, rb_cTime)) {
                 rb_raise(rb_eTypeError, "Expected Time object for TIMESTAMP");
             }
@@ -311,8 +601,7 @@ static void vector_set_value_at(duckdb_vector vector, duckdb_logical_type elemen
             break;
         }
         case DUCKDB_TYPE_DATE: {
-            // Convert Ruby Date to DuckDB date
-            // Ruby Date is defined in date library, check with Class name
+            /* Convert Ruby Date to DuckDB date */
             VALUE date_class = rb_const_get(rb_cObject, rb_intern("Date"));
             if (!rb_obj_is_kind_of(value, date_class)) {
                 rb_raise(rb_eTypeError, "Expected Date object for DATE");
@@ -327,7 +616,7 @@ static void vector_set_value_at(duckdb_vector vector, duckdb_logical_type elemen
             break;
         }
         case DUCKDB_TYPE_TIME: {
-            // Convert Ruby Time to DuckDB time (time-of-day only)
+            /* Convert Ruby Time to DuckDB time (time-of-day only) */
             if (!rb_obj_is_kind_of(value, rb_cTime)) {
                 rb_raise(rb_eTypeError, "Expected Time object for TIME");
             }
@@ -368,12 +657,15 @@ static VALUE rbduckdb_scalar_function_set_function(VALUE self) {
     duckdb_scalar_function_set_extra_info(p->scalar_function, p, NULL);
     duckdb_scalar_function_set_function(p->scalar_function, scalar_function_callback);
 
-    // Mark as volatile to prevent constant folding during query optimization
-    // This prevents DuckDB from evaluating the function at planning time.
-    // NOTE: Ruby scalar functions require single-threaded execution (PRAGMA threads=1)
-    // because Ruby proc callbacks cannot be safely invoked from DuckDB worker threads.
+    /*
+     * Mark as volatile to prevent constant folding during query optimization.
+     * This prevents DuckDB from evaluating the function at planning time.
+     */
     duckdb_scalar_function_set_volatile(p->scalar_function);
 
+    /* Ensure the global executor thread is running for multi-thread dispatch */
+    ensure_executor_started();
+
     return self;
 }
 

data/lib/duckdb/connection.rb

@@ -34,6 +34,8 @@ module DuckDB
 
     def query_multi_sql(sql)
       stmts = ExtractedStatements.new(self, sql)
+      return query_sql(sql) if stmts.size == 1
+
       result = nil
       stmts.each do |stmt|
         result = stmt.execute
@@ -137,8 +139,6 @@ module DuckDB
 
     # Registers a scalar function with the connection.
     #
-    # Scalar functions with Ruby callbacks require single-threaded execution.
-    #
     # @overload register_scalar_function(scalar_function)
     #   Register a pre-created ScalarFunction object.
     #   @param scalar_function [DuckDB::ScalarFunction] the scalar function to register
@@ -151,12 +151,10 @@ module DuckDB
     #   @param parameter_types [Array<DuckDB::LogicalType>, nil] multiple parameter types
     #   @yield [*args] the function implementation
     #
-    # @raise [DuckDB::Error] if threads setting is not 1
     # @raise [ArgumentError] if both object and keywords/block are provided
     # @return [void]
     #
     # @example Register pre-created function
-    #   con.execute('SET threads=1')
     #   sf = DuckDB::ScalarFunction.create(
     #     name: :triple,
     #     return_type: DuckDB::LogicalType::INTEGER,
@@ -165,7 +163,6 @@ module DuckDB
     #   con.register_scalar_function(sf)
     #
     # @example Register inline (single parameter)
-    #   con.execute('SET threads=1')
     #   con.register_scalar_function(
     #     name: :triple,
     #     return_type: DuckDB::LogicalType::INTEGER,
@@ -173,7 +170,6 @@ module DuckDB
     #   ) { |v| v * 3 }
     #
     # @example Register inline (multiple parameters)
-    #   con.execute('SET threads=1')
     #   con.register_scalar_function(
     #     name: :add,
     #     return_type: DuckDB::LogicalType::INTEGER,
@@ -187,7 +183,6 @@ module DuckDB
         raise ArgumentError, 'Cannot pass both ScalarFunction object and block' if block_given?
       end
 
-      check_threads
       sf = scalar_function || ScalarFunction.create(**kwargs, &)
       _register_scalar_function(sf)
     end

data/lib/duckdb/scalar_function.rb

@@ -4,8 +4,6 @@ module DuckDB
   # DuckDB::ScalarFunction encapsulates DuckDB's scalar function
   #
   # @note DuckDB::ScalarFunction is experimental.
-  # @note DuckDB::ScalarFunction must be used with threads=1 in DuckDB.
-  #       Set this with: connection.execute('SET threads=1')
   class ScalarFunction
     # Create and configure a scalar function in one call
     #

data/lib/duckdb/version.rb

@@ -3,5 +3,5 @@
 module DuckDB
   # The version string of ruby-duckdb.
   # Currently, ruby-duckdb is NOT semantic versioning.
-  VERSION = '1.5.0.0'
+  VERSION = '1.5.0.1'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: duckdb
 version: !ruby/object:Gem::Version
-  version: 1.5.0.0
+  version: 1.5.0.1
 platform: ruby
 authors:
 - Masaki Suketa