duckdb 1.5.3.0 → 1.5.5.0

data/ext/duckdb/function_vector.c

@@ -137,6 +137,20 @@ void rbduckdb_vector_set_value_at(duckdb_vector vector, duckdb_logical_type elem
             ((duckdb_time *)vector_data)[index] = time;
             break;
         }
+        case DUCKDB_TYPE_TIME_NS: {
+            if (!rb_obj_is_kind_of(value, rb_cTime)) {
+                rb_raise(rb_eTypeError, "Expected Time object for TIME_NS");
+            }
+
+            VALUE hour = rb_funcall(value, rb_intern("hour"), 0);
+            VALUE min = rb_funcall(value, rb_intern("min"), 0);
+            VALUE sec = rb_funcall(value, rb_intern("sec"), 0);
+            VALUE nsec = rb_funcall(value, rb_intern("nsec"), 0);
+
+            duckdb_time_ns time_ns = rbduckdb_to_duckdb_time_ns_from_value(hour, min, sec, nsec);
+            ((duckdb_time_ns *)vector_data)[index] = time_ns;
+            break;
+        }
         case DUCKDB_TYPE_TIME_TZ: {
             if (!rb_obj_is_kind_of(value, rb_cTime)) {
                 rb_raise(rb_eTypeError, "Expected Time object for TIME_TZ");

data/ext/duckdb/prepared_statement.c

@@ -14,6 +14,7 @@ static idx_t check_index(VALUE vidx);
 
 static VALUE prepared_statement_bind_parameter_index(VALUE self, VALUE name);
 static VALUE prepared_statement_parameter_name(VALUE self, VALUE vidx);
+static VALUE prepared_statement_param_logical_type(VALUE self, VALUE vidx);
 static VALUE prepared_statement_clear_bindings(VALUE self);
 static VALUE prepared_statement_bind_bool(VALUE self, VALUE vidx, VALUE val);
 static VALUE prepared_statement_bind_int8(VALUE self, VALUE vidx, VALUE val);
@@ -27,6 +28,10 @@ static VALUE prepared_statement_bind_blob(VALUE self, VALUE vidx, VALUE blob);
 static VALUE prepared_statement_bind_null(VALUE self, VALUE vidx);
 static VALUE prepared_statement__statement_type(VALUE self);
 static VALUE prepared_statement__param_type(VALUE self, VALUE vidx);
+static VALUE prepared_statement_column_count(VALUE self);
+static VALUE prepared_statement_column_name(VALUE self, VALUE vidx);
+static VALUE prepared_statement__column_type(VALUE self, VALUE vidx);
+static VALUE prepared_statement_column_logical_type(VALUE self, VALUE vidx);
 static VALUE prepared_statement__bind_uint8(VALUE self, VALUE vidx, VALUE val);
 static VALUE prepared_statement__bind_uint16(VALUE self, VALUE vidx, VALUE val);
 static VALUE prepared_statement__bind_uint32(VALUE self, VALUE vidx, VALUE val);
@@ -38,6 +43,7 @@ static VALUE prepared_statement__bind_timestamp_tz(VALUE self, VALUE vidx, VALUE
 static VALUE prepared_statement__bind_interval(VALUE self, VALUE vidx, VALUE months, VALUE days, VALUE micros);
 static VALUE prepared_statement__bind_hugeint(VALUE self, VALUE vidx, VALUE lower, VALUE upper);
 static VALUE prepared_statement__bind_uhugeint(VALUE self, VALUE vidx, VALUE lower, VALUE upper);
+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);
 
@@ -128,7 +134,6 @@ static VALUE prepared_statement_execute(VALUE self) {
     rubyDuckDBResult *ctxr;
     const char *error;
     VALUE result = rbduckdb_create_result();
-    VALUE msg;
 
     TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
     ctxr = rbduckdb_get_struct_result(result);
@@ -145,11 +150,10 @@ static VALUE prepared_statement_execute(VALUE self) {
     if (state == DuckDBError) {
         error = duckdb_prepare_error(args.prepared_statement);
         if (error == NULL) {
-            error = duckdb_result_error(args.out_result);
+            /* error originates from the result, which carries an error type */
+            rbduckdb_raise_result_error(args.out_result);
         }
-        msg = rb_str_new2(error ? error : "Failed to execute prepared statement.");
-
-        rb_raise(eDuckDBError, "%s", StringValuePtr(msg));
+        rb_raise(eDuckDBError, "%s", error);
     }
 
     return result;
@@ -205,6 +209,28 @@ static VALUE prepared_statement_parameter_name(VALUE self, VALUE vidx) {
     return vname;
 }
 
+/*
+ *  call-seq:
+ *    prepared_statement.param_logical_type(param_index) -> DuckDB::LogicalType
+ *
+ *  Returns the logical type of the parameter at the given (1-based) index.
+ *  This provides richer type information than #param_type, e.g. decimal
+ *  width/scale, nested types.
+ */
+static VALUE prepared_statement_param_logical_type(VALUE self, VALUE vidx) {
+    rubyDuckDBPreparedStatement *ctx;
+    duckdb_logical_type logical_type;
+    idx_t idx = check_index(vidx);
+
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
+
+    logical_type = duckdb_param_logical_type(ctx->prepared_statement, idx);
+    if (logical_type == NULL) {
+        rb_raise(eDuckDBError, "fail to get logical type of the parameter at %llu. parameter index is out of range.", (unsigned long long)idx);
+    }
+    return rbduckdb_create_logical_type(logical_type);
+}
+
 /*
  *  call-seq:
  *    prepared_statement.clear_bindings -> DuckDB::PreparedStatement
@@ -359,6 +385,91 @@ static VALUE prepared_statement__statement_type(VALUE self) {
     return INT2FIX(duckdb_prepared_statement_type(ctx->prepared_statement));
 }
 
+/*
+ *  call-seq:
+ *    prepared_statement.column_count -> Integer
+ *
+ *  Returns the number of columns in the result set of the prepared statement
+ *  without executing it.
+ *
+ *    require 'duckdb'
+ *    db = DuckDB::Database.open
+ *    con = db.connect
+ *    stmt = con.prepared_statement('SELECT 1 AS a, 2 AS b')
+ *    stmt.column_count # => 2
+ */
+static VALUE prepared_statement_column_count(VALUE self) {
+    rubyDuckDBPreparedStatement *ctx;
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
+    return ULL2NUM(duckdb_prepared_statement_column_count(ctx->prepared_statement));
+}
+
+/*
+ *  call-seq:
+ *    prepared_statement.column_name(col_index) -> String
+ *
+ *  Returns the name of the column at the specified index (0-based) of the
+ *  result set of the prepared statement without executing it.
+ *  Raises DuckDB::Error if the column index is out of range.
+ *
+ *    require 'duckdb'
+ *    db = DuckDB::Database.open
+ *    con = db.connect
+ *    stmt = con.prepared_statement('SELECT 1 AS a, 2 AS b')
+ *    stmt.column_name(1) # => 'b'
+ */
+static VALUE prepared_statement_column_name(VALUE self, VALUE vidx) {
+    rubyDuckDBPreparedStatement *ctx;
+    VALUE vname;
+    const char *name;
+    idx_t idx = NUM2ULL(vidx);
+
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
+
+    name = duckdb_prepared_statement_column_name(ctx->prepared_statement, idx);
+    if (name == NULL) {
+        rb_raise(eDuckDBError, "fail to get column name at %llu. column index is out of range.", (unsigned long long)idx);
+    }
+    vname = rb_str_new2(name);
+    duckdb_free((void *)name);
+    return vname;
+}
+
+/* :nodoc: */
+static VALUE prepared_statement__column_type(VALUE self, VALUE vidx) {
+    rubyDuckDBPreparedStatement *ctx;
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
+    return INT2FIX(duckdb_prepared_statement_column_type(ctx->prepared_statement, NUM2ULL(vidx)));
+}
+
+/*
+ *  call-seq:
+ *    prepared_statement.column_logical_type(col_index) -> DuckDB::LogicalType
+ *
+ *  Returns the logical type of the column at the specified index (0-based) of
+ *  the result set of the prepared statement without executing it.
+ *  Raises DuckDB::Error if the column index is out of range.
+ *
+ *    require 'duckdb'
+ *    db = DuckDB::Database.open
+ *    con = db.connect
+ *    stmt = con.prepared_statement('SELECT 1.5::DECIMAL(9, 4) AS a')
+ *    stmt.column_logical_type(0).type # => :decimal
+ */
+static VALUE prepared_statement_column_logical_type(VALUE self, VALUE vidx) {
+    rubyDuckDBPreparedStatement *ctx;
+    duckdb_logical_type logical_type;
+    idx_t idx = NUM2ULL(vidx);
+
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
+
+    logical_type = duckdb_prepared_statement_column_logical_type(ctx->prepared_statement, idx);
+    if (logical_type == NULL) {
+        rb_raise(eDuckDBError, "fail to get column logical type at %llu. column index is out of range.", (unsigned long long)idx);
+    }
+    return rbduckdb_create_logical_type(logical_type);
+}
+
 /* :nodoc: */
 static VALUE prepared_statement__param_type(VALUE self, VALUE vidx) {
     rubyDuckDBPreparedStatement *ctx;
@@ -558,6 +669,25 @@ static VALUE prepared_statement__bind_decimal(VALUE self, VALUE vidx, VALUE lowe
     return self;
 }
 
+/* :nodoc: */
+static VALUE prepared_statement__bind_uuid(VALUE self, VALUE vidx, VALUE val) {
+    rubyDuckDBPreparedStatement *ctx;
+    duckdb_uhugeint uhugeint;
+    duckdb_value uuid_val;
+    duckdb_state state;
+    idx_t idx = check_index(vidx);
+
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
+    rbduckdb_uuid_str_to_uhugeint(val, &uhugeint);
+    uuid_val = duckdb_create_uuid(uhugeint);
+    state = duckdb_bind_value(ctx->prepared_statement, idx, uuid_val);
+    duckdb_destroy_value(&uuid_val);
+    if (state == DuckDBError) {
+        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
+    }
+    return self;
+}
+
 /* :nodoc: */
 static VALUE prepared_statement__bind_value(VALUE self, VALUE vidx, VALUE val) {
     rubyDuckDBPreparedStatement *ctx;
@@ -593,7 +723,11 @@ void rbduckdb_init_prepared_statement(void) {
     rb_define_method(cDuckDBPreparedStatement, "nparams", prepared_statement_nparams, 0);
     rb_define_method(cDuckDBPreparedStatement, "bind_parameter_index", prepared_statement_bind_parameter_index, 1);
     rb_define_method(cDuckDBPreparedStatement, "parameter_name", prepared_statement_parameter_name, 1);
+    rb_define_method(cDuckDBPreparedStatement, "param_logical_type", prepared_statement_param_logical_type, 1);
     rb_define_method(cDuckDBPreparedStatement, "clear_bindings", prepared_statement_clear_bindings, 0);
+    rb_define_method(cDuckDBPreparedStatement, "column_count", prepared_statement_column_count, 0);
+    rb_define_method(cDuckDBPreparedStatement, "column_name", prepared_statement_column_name, 1);
+    rb_define_method(cDuckDBPreparedStatement, "column_logical_type", prepared_statement_column_logical_type, 1);
     rb_define_method(cDuckDBPreparedStatement, "bind_bool", prepared_statement_bind_bool, 2);
     rb_define_method(cDuckDBPreparedStatement, "bind_int8", prepared_statement_bind_int8, 2);
     rb_define_method(cDuckDBPreparedStatement, "bind_int16", prepared_statement_bind_int16, 2);
@@ -610,6 +744,7 @@ void rbduckdb_init_prepared_statement(void) {
     rb_define_private_method(cDuckDBPreparedStatement, "_bind_uint64", prepared_statement__bind_uint64, 2);
     rb_define_private_method(cDuckDBPreparedStatement, "_statement_type", prepared_statement__statement_type, 0);
     rb_define_private_method(cDuckDBPreparedStatement, "_param_type", prepared_statement__param_type, 1);
+    rb_define_private_method(cDuckDBPreparedStatement, "_column_type", prepared_statement__column_type, 1);
     rb_define_private_method(cDuckDBPreparedStatement, "_bind_date", prepared_statement__bind_date, 4);
     rb_define_private_method(cDuckDBPreparedStatement, "_bind_time", prepared_statement__bind_time, 5);
     rb_define_private_method(cDuckDBPreparedStatement, "_bind_timestamp", prepared_statement__bind_timestamp, 8);
@@ -617,6 +752,7 @@ void rbduckdb_init_prepared_statement(void) {
     rb_define_private_method(cDuckDBPreparedStatement, "_bind_interval", prepared_statement__bind_interval, 4);
     rb_define_private_method(cDuckDBPreparedStatement, "_bind_hugeint", prepared_statement__bind_hugeint, 3);
     rb_define_private_method(cDuckDBPreparedStatement, "_bind_uhugeint", prepared_statement__bind_uhugeint, 3);
+    rb_define_private_method(cDuckDBPreparedStatement, "_bind_uuid", prepared_statement__bind_uuid, 2);
     rb_define_private_method(cDuckDBPreparedStatement, "_bind_decimal", prepared_statement__bind_decimal, 5);
     rb_define_private_method(cDuckDBPreparedStatement, "_bind_value", prepared_statement__bind_value, 2);
 }

data/ext/duckdb/result.c

@@ -16,6 +16,7 @@ static VALUE result_columns(VALUE oDuckDBResult);
 static VALUE destroy_data_chunk(VALUE arg);
 
 static VALUE result__chunk_stream(VALUE oDuckDBResult);
+static VALUE result_arrow_c_stream(VALUE oDuckDBResult);
 static VALUE yield_rows(VALUE arg);
 static VALUE result__return_type(VALUE oDuckDBResult);
 static VALUE result__statement_type(VALUE oDuckDBResult);
@@ -56,15 +57,30 @@ static const rb_data_type_t result_data_type = {
 static void deallocate(void *ctx) {
     rubyDuckDBResult *p = (rubyDuckDBResult *)ctx;
 
-    duckdb_destroy_result(&(p->result));
-    xfree(p);
+    rbduckdb_result_unref(p);
 }
 
 static VALUE allocate(VALUE klass) {
-    rubyDuckDBResult *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBResult));
+    rubyDuckDBResult *ctx = calloc((size_t)1, sizeof(rubyDuckDBResult));
+
+    if (ctx == NULL) {
+        rb_raise(rb_eNoMemError, "failed to allocate DuckDB::Result");
+    }
+    ctx->refcount = 1;
     return TypedData_Wrap_Struct(klass, &result_data_type, ctx);
 }
 
+void rbduckdb_result_ref(rubyDuckDBResult *ctx) {
+    RUBY_ATOMIC_FETCH_ADD(ctx->refcount, 1);
+}
+
+void rbduckdb_result_unref(rubyDuckDBResult *ctx) {
+    if (RUBY_ATOMIC_FETCH_SUB(ctx->refcount, 1) == 1) {
+        duckdb_destroy_result(&(ctx->result));
+        free(ctx);
+    }
+}
+
 static size_t memsize(const void *p) {
     return sizeof(rubyDuckDBResult);
 }
@@ -647,6 +663,35 @@ static VALUE vector_uuid(void* vector_data, idx_t row_idx) {
     return rbduckdb_uuid_to_ruby(((duckdb_hugeint *)vector_data)[row_idx]);
 }
 
+/*
+ *  call-seq:
+ *    result.arrow_c_stream -> DuckDB::ArrowArrayStream
+ *
+ *  [EXPERIMENTAL] Exports the result as an Arrow C stream
+ *  (Arrow C Data Interface). The returned stream object satisfies the
+ *  Ruby Arrow C stream protocol, so it can be consumed directly by
+ *  ruby-polars, red-arrow and other Arrow consumers:
+ *
+ *    result = con.query('SELECT * FROM users')
+ *    df = Polars::DataFrame.new(result)
+ *
+ *  The stream consumes the result's chunks; a result can be exported
+ *  only once. This API is built on DuckDB's unstable Arrow C API and
+ *  may change in any minor release.
+ */
+static VALUE result_arrow_c_stream(VALUE oDuckDBResult) {
+    rubyDuckDBResult *ctx;
+    VALUE stream;
+
+    TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
+    if (ctx->arrow_exported) {
+        rb_raise(eDuckDBError, "result is already exported as an Arrow stream");
+    }
+    stream = rbduckdb_create_arrow_array_stream(oDuckDBResult);
+    ctx->arrow_exported = true;
+    return stream;
+}
+
 static VALUE vector_value(duckdb_vector vector, idx_t row_idx) {
     duckdb_logical_type ty;
     VALUE obj = Qnil;
@@ -671,6 +716,7 @@ void rbduckdb_init_result(void) {
     rb_define_method(cDuckDBResult, "rows_changed", result_rows_changed, 0);
     rb_define_method(cDuckDBResult, "columns", result_columns, 0);
     rb_define_private_method(cDuckDBResult, "_chunk_stream", result__chunk_stream, 0);
+    rb_define_method(cDuckDBResult, "arrow_c_stream", result_arrow_c_stream, 0);
     rb_define_private_method(cDuckDBResult, "_return_type", result__return_type, 0);
     rb_define_private_method(cDuckDBResult, "_statement_type", result__statement_type, 0);
 

data/ext/duckdb/result.h

@@ -1,13 +1,24 @@
 #ifndef RUBY_DUCKDB_RESULT_H
 #define RUBY_DUCKDB_RESULT_H
 
+/*
+ * Allocated with plain calloc/free and reference-counted: the Ruby Result
+ * 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.
+ */
 struct _rubyDuckDBResult {
     duckdb_result result;
+    bool arrow_exported;
+    rb_atomic_t refcount;
 };
 
 typedef struct _rubyDuckDBResult rubyDuckDBResult;
 
 rubyDuckDBResult *rbduckdb_get_struct_result(VALUE obj);
+void rbduckdb_result_ref(rubyDuckDBResult *ctx);
+void rbduckdb_result_unref(rubyDuckDBResult *ctx);
 void rbduckdb_init_result(void);
 VALUE rbduckdb_create_result(void);
 VALUE rbduckdb_vector_value_at(duckdb_vector vector, duckdb_logical_type element_type, idx_t index);

data/ext/duckdb/ruby-duckdb.h

@@ -6,6 +6,7 @@
 
 #include "ruby.h"
 #include "ruby/thread.h"
+#include "ruby/atomic.h"
 #include <duckdb.h>
 
 #ifdef HAVE_DUCKDB_UNSAFE_VECTOR_ASSIGN_STRING_ELEMENT_LEN
@@ -50,6 +51,8 @@
 #include "./memory_helper.h"
 #include "./table_function.h"
 #include "./table_description.h"
+#include "./arrow_array_stream.h"
+#include "./arrow_import.h"
 
 extern VALUE mDuckDB;
 extern VALUE cDuckDBDatabase;

data/ext/duckdb/scalar_function.c

@@ -7,16 +7,24 @@ static void deallocate(void *);
 static VALUE allocate(VALUE klass);
 static size_t memsize(const void *p);
 static void compact(void *);
-static VALUE duckdb_scalar_function_initialize(VALUE self);
-static VALUE rbduckdb_scalar_function_set_name(VALUE self, VALUE name);
-static VALUE rbduckdb_scalar_function__set_return_type(VALUE self, VALUE logical_type);
-static VALUE rbduckdb_scalar_function__set_varargs(VALUE self, VALUE logical_type);
-static VALUE rbduckdb_scalar_function_add_parameter(VALUE self, VALUE logical_type);
-static VALUE rbduckdb_scalar_function__set_special_handling(VALUE self);
-static VALUE rbduckdb_scalar_function_set_function(VALUE self);
-static VALUE rbduckdb_scalar_function__set_bind(VALUE self);
+static VALUE scalar_function_initialize(VALUE self);
+static VALUE scalar_function_set_name(VALUE self, VALUE name);
+static VALUE scalar_function__set_return_type(VALUE self, VALUE logical_type);
+static VALUE scalar_function__set_varargs(VALUE self, VALUE logical_type);
+static VALUE scalar_function__add_parameter(VALUE self, VALUE logical_type);
+static VALUE scalar_function__set_special_handling(VALUE self);
+static VALUE scalar_function_set_function(VALUE self);
+static VALUE scalar_function__set_bind(VALUE self);
 static void scalar_function_callback(duckdb_function_info info, duckdb_data_chunk input, duckdb_vector output);
 static void scalar_function_bind_callback(duckdb_bind_info info);
+#ifdef HAVE_DUCKDB_H_GE_V1_5_0
+/*
+ * Thread detection functions (available since Ruby 2.3).
+ * Used to skip the proxy on Ruby threads.
+ */
+extern int ruby_native_thread_p(void);
+static void scalar_function_init_callback(duckdb_init_info info);
+#endif
 
 
 struct callback_arg {
@@ -115,7 +123,7 @@ static size_t memsize(const void *p) {
     return sizeof(rubyDuckDBScalarFunction);
 }
 
-static VALUE duckdb_scalar_function_initialize(VALUE self) {
+static VALUE scalar_function_initialize(VALUE self) {
     rubyDuckDBScalarFunction *p;
     TypedData_Get_Struct(self, rubyDuckDBScalarFunction, &scalar_function_data_type, p);
     p->scalar_function = duckdb_create_scalar_function();
@@ -124,7 +132,7 @@ static VALUE duckdb_scalar_function_initialize(VALUE self) {
     return self;
 }
 
-static VALUE rbduckdb_scalar_function_set_name(VALUE self, VALUE name) {
+static VALUE scalar_function_set_name(VALUE self, VALUE name) {
     rubyDuckDBScalarFunction *p;
     TypedData_Get_Struct(self, rubyDuckDBScalarFunction, &scalar_function_data_type, p);
 
@@ -134,7 +142,7 @@ static VALUE rbduckdb_scalar_function_set_name(VALUE self, VALUE name) {
     return self;
 }
 
-static VALUE rbduckdb_scalar_function__set_return_type(VALUE self, VALUE logical_type) {
+static VALUE scalar_function__set_return_type(VALUE self, VALUE logical_type) {
     rubyDuckDBScalarFunction *p;
     rubyDuckDBLogicalType *lt;
 
@@ -146,7 +154,7 @@ static VALUE rbduckdb_scalar_function__set_return_type(VALUE self, VALUE logical
     return self;
 }
 
-static VALUE rbduckdb_scalar_function__set_varargs(VALUE self, VALUE logical_type) {
+static VALUE scalar_function__set_varargs(VALUE self, VALUE logical_type) {
     rubyDuckDBScalarFunction *p;
     rubyDuckDBLogicalType *lt;
 
@@ -158,7 +166,7 @@ static VALUE rbduckdb_scalar_function__set_varargs(VALUE self, VALUE logical_typ
     return self;
 }
 
-static VALUE rbduckdb_scalar_function__set_special_handling(VALUE self) {
+static VALUE scalar_function__set_special_handling(VALUE self) {
     rubyDuckDBScalarFunction *p;
 
     TypedData_Get_Struct(self, rubyDuckDBScalarFunction, &scalar_function_data_type, p);
@@ -167,7 +175,7 @@ static VALUE rbduckdb_scalar_function__set_special_handling(VALUE self) {
     return self;
 }
 
-static VALUE rbduckdb_scalar_function_add_parameter(VALUE self, VALUE logical_type) {
+static VALUE scalar_function__add_parameter(VALUE self, VALUE logical_type) {
     rubyDuckDBScalarFunction *p;
     rubyDuckDBLogicalType *lt;
 
@@ -191,6 +199,7 @@ static void scalar_function_callback(duckdb_function_info info, duckdb_data_chun
     rubyDuckDBScalarFunction *ctx;
     idx_t i;
     struct callback_arg arg;
+    struct worker_proxy *proxy = NULL;
 
     ctx = (rubyDuckDBScalarFunction *)duckdb_scalar_function_get_extra_info(info);
 
@@ -218,7 +227,11 @@ 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);
 
-    rbduckdb_function_executor_dispatch(execute_callback_protected, &arg);
+#ifdef HAVE_DUCKDB_H_GE_V1_5_0
+    /* On DuckDB >= 1.5.0 each worker thread carries its own proxy (see init). */
+    proxy = (struct worker_proxy *)duckdb_scalar_function_get_state(info);
+#endif
+    rbduckdb_function_executor_dispatch_via_proxy(execute_callback_protected, &arg, proxy);
 }
 
 static VALUE process_no_param_rows(VALUE varg) {
@@ -259,7 +272,7 @@ static VALUE process_rows(VALUE varg) {
         }
 
         /* Call the Ruby block with the arguments */
-        result = rb_funcallv(arg->ctx->function_proc, rb_intern("call"), arg->col_count, arg->args);
+        result = rb_funcallv(arg->ctx->function_proc, rb_intern("call"), (int)arg->col_count, arg->args);
 
         /* Write result to output using helper function */
         rbduckdb_vector_set_value_at(arg->output, arg->output_type, i, result);
@@ -294,14 +307,66 @@ static VALUE cleanup_callback(VALUE varg) {
     return Qnil;
 }
 
-rubyDuckDBScalarFunction *get_struct_scalar_function(VALUE obj) {
+#ifdef HAVE_DUCKDB_H_GE_V1_5_0
+/*
+ * Per-worker init for the execute path (DuckDB >= 1.5.0).
+ *
+ * DuckDB calls this once on each worker thread that will run the execute
+ * callback. We create a per-worker proxy (allocating its Ruby thread under the
+ * GVL via the global executor, since this runs on a non-Ruby thread) and store
+ * it as per-worker state. The execute callback then dispatches through it
+ * instead of the shared global executor, so workers run callbacks concurrently.
+ * DuckDB invokes rbduckdb_worker_proxy_destroy when the state is freed.
+ */
+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, init sets no state, and the
+ * execute callback 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);
+    }
+}
+
+static void scalar_function_init_callback(duckdb_init_info info) {
+    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;
+
+    arg.proxy = NULL;
+    rbduckdb_function_executor_dispatch(create_proxy_callback_protected, &arg);
+
+    if (arg.proxy != NULL) {
+        duckdb_scalar_function_init_set_state(info, arg.proxy, rbduckdb_worker_proxy_destroy);
+    }
+}
+#endif
+
+rubyDuckDBScalarFunction *rbduckdb_get_struct_scalar_function(VALUE obj) {
     rubyDuckDBScalarFunction *ctx;
     TypedData_Get_Struct(obj, rubyDuckDBScalarFunction, &scalar_function_data_type, ctx);
     return ctx;
 }
 
 /* :nodoc: */
-static VALUE rbduckdb_scalar_function_set_function(VALUE self) {
+static VALUE scalar_function_set_function(VALUE self) {
     rubyDuckDBScalarFunction *p;
 
     if (!rb_block_given_p()) {
@@ -314,6 +379,10 @@ 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);
+#ifdef HAVE_DUCKDB_H_GE_V1_5_0
+    /* Per-worker proxy threads for the execute path (DuckDB >= 1.5.0). */
+    duckdb_scalar_function_set_init(p->scalar_function, scalar_function_init_callback);
+#endif
 
     /*
      * Mark as volatile to prevent constant folding during query optimization.
@@ -328,7 +397,7 @@ static VALUE rbduckdb_scalar_function_set_function(VALUE self) {
 }
 
 /* :nodoc: */
-static VALUE rbduckdb_scalar_function__set_bind(VALUE self) {
+static VALUE scalar_function__set_bind(VALUE self) {
     rubyDuckDBScalarFunction *p;
 
     TypedData_Get_Struct(self, rubyDuckDBScalarFunction, &scalar_function_data_type, p);
@@ -406,19 +475,18 @@ static void scalar_function_bind_callback(duckdb_bind_info info) {
 }
 
 
-void rbduckdb_init_duckdb_scalar_function(void) {
+void rbduckdb_init_scalar_function(void) {
 #if 0
     VALUE mDuckDB = rb_define_module("DuckDB");
 #endif
     cDuckDBScalarFunction = rb_define_class_under(mDuckDB, "ScalarFunction", rb_cObject);
     rb_define_alloc_func(cDuckDBScalarFunction, allocate);
-    rb_define_method(cDuckDBScalarFunction, "initialize", duckdb_scalar_function_initialize, 0);
-    rb_define_method(cDuckDBScalarFunction, "set_name", rbduckdb_scalar_function_set_name, 1);
-    rb_define_method(cDuckDBScalarFunction, "name=", rbduckdb_scalar_function_set_name, 1);
-    rb_define_private_method(cDuckDBScalarFunction, "_set_return_type", rbduckdb_scalar_function__set_return_type, 1);
-    rb_define_private_method(cDuckDBScalarFunction, "_set_varargs", rbduckdb_scalar_function__set_varargs, 1);
-    rb_define_private_method(cDuckDBScalarFunction, "_set_special_handling", rbduckdb_scalar_function__set_special_handling, 0);
-    rb_define_private_method(cDuckDBScalarFunction, "_add_parameter", rbduckdb_scalar_function_add_parameter, 1);
-    rb_define_method(cDuckDBScalarFunction, "set_function", rbduckdb_scalar_function_set_function, 0);
-    rb_define_private_method(cDuckDBScalarFunction, "_set_bind", rbduckdb_scalar_function__set_bind, 0);
+    rb_define_method(cDuckDBScalarFunction, "initialize", scalar_function_initialize, 0);
+    rb_define_method(cDuckDBScalarFunction, "set_name", scalar_function_set_name, 1);
+    rb_define_private_method(cDuckDBScalarFunction, "_set_return_type", scalar_function__set_return_type, 1);
+    rb_define_private_method(cDuckDBScalarFunction, "_set_varargs", scalar_function__set_varargs, 1);
+    rb_define_private_method(cDuckDBScalarFunction, "_set_special_handling", scalar_function__set_special_handling, 0);
+    rb_define_private_method(cDuckDBScalarFunction, "_add_parameter", scalar_function__add_parameter, 1);
+    rb_define_method(cDuckDBScalarFunction, "set_function", scalar_function_set_function, 0);
+    rb_define_private_method(cDuckDBScalarFunction, "_set_bind", scalar_function__set_bind, 0);
 }

data/ext/duckdb/scalar_function.h

@@ -9,9 +9,7 @@ struct _rubyDuckDBScalarFunction {
 
 typedef struct _rubyDuckDBScalarFunction rubyDuckDBScalarFunction;
 
-void rbduckdb_init_duckdb_scalar_function(void);
-rubyDuckDBScalarFunction *get_struct_scalar_function(VALUE obj);
+void rbduckdb_init_scalar_function(void);
+rubyDuckDBScalarFunction *rbduckdb_get_struct_scalar_function(VALUE obj);
 
 #endif
-
-