duckdb 1.5.3.0 → 1.5.5.0

data/ext/duckdb/scalar_function_bind_info.c

@@ -5,10 +5,10 @@ VALUE cDuckDBScalarFunctionBindInfo;
 static void deallocate(void *ctx);
 static VALUE allocate(VALUE klass);
 static size_t memsize(const void *p);
-static VALUE rbduckdb_scalar_function_bind_info_argument_count(VALUE self);
-static VALUE rbduckdb_scalar_function_bind_info_set_error(VALUE self, VALUE error);
-static VALUE rbduckdb_scalar_function_bind_info_get_argument(VALUE self, VALUE index);
-static VALUE rbduckdb_scalar_function_bind_info_client_context(VALUE self);
+static VALUE scalar_function_bind_info_argument_count(VALUE self);
+static VALUE scalar_function_bind_info_set_error(VALUE self, VALUE error);
+static VALUE scalar_function_bind_info__get_argument(VALUE self, VALUE index);
+static VALUE scalar_function_bind_info_client_context(VALUE self);
 
 static const rb_data_type_t scalar_function_bind_info_data_type = {
     "DuckDB/ScalarFunction/BindInfo",
@@ -46,7 +46,7 @@ VALUE rbduckdb_scalar_function_bind_info_new(duckdb_bind_info bind_info) {
  *
  *   bind_info.argument_count  # => 2
  */
-static VALUE rbduckdb_scalar_function_bind_info_argument_count(VALUE self) {
+static VALUE scalar_function_bind_info_argument_count(VALUE self) {
     rubyDuckDBScalarFunctionBindInfo *ctx;
     TypedData_Get_Struct(self, rubyDuckDBScalarFunctionBindInfo, &scalar_function_bind_info_data_type, ctx);
     return ULL2NUM(duckdb_scalar_function_bind_get_argument_count(ctx->bind_info));
@@ -61,7 +61,7 @@ static VALUE rbduckdb_scalar_function_bind_info_argument_count(VALUE self) {
  *
  *   bind_info.set_error('invalid argument')
  */
-static VALUE rbduckdb_scalar_function_bind_info_set_error(VALUE self, VALUE error) {
+static VALUE scalar_function_bind_info_set_error(VALUE self, VALUE error) {
     rubyDuckDBScalarFunctionBindInfo *ctx;
     TypedData_Get_Struct(self, rubyDuckDBScalarFunctionBindInfo, &scalar_function_bind_info_data_type, ctx);
     duckdb_scalar_function_bind_set_error(ctx->bind_info, StringValueCStr(error));
@@ -75,7 +75,7 @@ static VALUE rbduckdb_scalar_function_bind_info_set_error(VALUE self, VALUE erro
  * Returns the expression at the given argument index.
  * Called internally by +get_argument+ after index validation.
  */
-static VALUE rbduckdb_scalar_function_bind_info_get_argument(VALUE self, VALUE index) {
+static VALUE scalar_function_bind_info__get_argument(VALUE self, VALUE index) {
     rubyDuckDBScalarFunctionBindInfo *ctx;
     TypedData_Get_Struct(self, rubyDuckDBScalarFunctionBindInfo, &scalar_function_bind_info_data_type, ctx);
     duckdb_expression expr = duckdb_scalar_function_bind_get_argument(ctx->bind_info, (idx_t)NUM2ULL(index));
@@ -88,7 +88,7 @@ static VALUE rbduckdb_scalar_function_bind_info_get_argument(VALUE self, VALUE i
  *
  * Returns the client context associated with the bind phase of the scalar function.
  */
-static VALUE rbduckdb_scalar_function_bind_info_client_context(VALUE self) {
+static VALUE scalar_function_bind_info_client_context(VALUE self) {
     rubyDuckDBScalarFunctionBindInfo *ctx;
     duckdb_client_context client_context;
     TypedData_Get_Struct(self, rubyDuckDBScalarFunctionBindInfo, &scalar_function_bind_info_data_type, ctx);
@@ -96,14 +96,14 @@ static VALUE rbduckdb_scalar_function_bind_info_client_context(VALUE self) {
     return rbduckdb_client_context_new(client_context);
 }
 
-void rbduckdb_init_duckdb_scalar_function_bind_info(void) {
+void rbduckdb_init_scalar_function_bind_info(void) {
 #if 0
     VALUE mDuckDB = rb_define_module("DuckDB");
 #endif
     cDuckDBScalarFunctionBindInfo = rb_define_class_under(cDuckDBScalarFunction, "BindInfo", rb_cObject);
     rb_define_alloc_func(cDuckDBScalarFunctionBindInfo, allocate);
-    rb_define_method(cDuckDBScalarFunctionBindInfo, "argument_count", rbduckdb_scalar_function_bind_info_argument_count, 0);
-    rb_define_method(cDuckDBScalarFunctionBindInfo, "set_error", rbduckdb_scalar_function_bind_info_set_error, 1);
-    rb_define_private_method(cDuckDBScalarFunctionBindInfo, "_get_argument", rbduckdb_scalar_function_bind_info_get_argument, 1);
-    rb_define_method(cDuckDBScalarFunctionBindInfo, "client_context", rbduckdb_scalar_function_bind_info_client_context, 0);
+    rb_define_method(cDuckDBScalarFunctionBindInfo, "argument_count", scalar_function_bind_info_argument_count, 0);
+    rb_define_method(cDuckDBScalarFunctionBindInfo, "set_error", scalar_function_bind_info_set_error, 1);
+    rb_define_private_method(cDuckDBScalarFunctionBindInfo, "_get_argument", scalar_function_bind_info__get_argument, 1);
+    rb_define_method(cDuckDBScalarFunctionBindInfo, "client_context", scalar_function_bind_info_client_context, 0);
 }

data/ext/duckdb/scalar_function_bind_info.h

@@ -7,7 +7,7 @@ struct _rubyDuckDBScalarFunctionBindInfo {
 
 typedef struct _rubyDuckDBScalarFunctionBindInfo rubyDuckDBScalarFunctionBindInfo;
 
-void rbduckdb_init_duckdb_scalar_function_bind_info(void);
+void rbduckdb_init_scalar_function_bind_info(void);
 VALUE rbduckdb_scalar_function_bind_info_new(duckdb_bind_info bind_info);
 
 #endif

data/ext/duckdb/scalar_function_set.c

@@ -7,8 +7,8 @@ static void deallocate(void *);
 static VALUE allocate(VALUE klass);
 static size_t memsize(const void *p);
 static void compact(void *);
-static VALUE rbduckdb_scalar_function_set__initialize(VALUE self, VALUE name);
-static VALUE rbduckdb_scalar_function_set__add(VALUE self, VALUE scalar_function);
+static VALUE scalar_function_set__initialize(VALUE self, VALUE name);
+static VALUE scalar_function_set__add(VALUE self, VALUE scalar_function);
 
 static const rb_data_type_t scalar_function_set_data_type = {
     "DuckDB/ScalarFunctionSet",
@@ -44,14 +44,14 @@ static size_t memsize(const void *p) {
     return sizeof(rubyDuckDBScalarFunctionSet);
 }
 
-rubyDuckDBScalarFunctionSet *get_struct_scalar_function_set(VALUE obj) {
+rubyDuckDBScalarFunctionSet *rbduckdb_get_struct_scalar_function_set(VALUE obj) {
     rubyDuckDBScalarFunctionSet *ctx;
     TypedData_Get_Struct(obj, rubyDuckDBScalarFunctionSet, &scalar_function_set_data_type, ctx);
     return ctx;
 }
 
 /* :nodoc: */
-static VALUE rbduckdb_scalar_function_set__initialize(VALUE self, VALUE name) {
+static VALUE scalar_function_set__initialize(VALUE self, VALUE name) {
     rubyDuckDBScalarFunctionSet *p;
 
     TypedData_Get_Struct(self, rubyDuckDBScalarFunctionSet, &scalar_function_set_data_type, p);
@@ -60,12 +60,12 @@ static VALUE rbduckdb_scalar_function_set__initialize(VALUE self, VALUE name) {
 }
 
 /* :nodoc: */
-static VALUE rbduckdb_scalar_function_set__add(VALUE self, VALUE scalar_function) {
+static VALUE scalar_function_set__add(VALUE self, VALUE scalar_function) {
     rubyDuckDBScalarFunctionSet *p;
     rubyDuckDBScalarFunction *sf;
 
     TypedData_Get_Struct(self, rubyDuckDBScalarFunctionSet, &scalar_function_set_data_type, p);
-    sf = get_struct_scalar_function(scalar_function);
+    sf = rbduckdb_get_struct_scalar_function(scalar_function);
 
     if (duckdb_add_scalar_function_to_set(p->scalar_function_set, sf->scalar_function) == DuckDBError) {
         rb_raise(eDuckDBError, "failed to add scalar function to set (duplicate overload?)");
@@ -75,12 +75,12 @@ static VALUE rbduckdb_scalar_function_set__add(VALUE self, VALUE scalar_function
     return self;
 }
 
-void rbduckdb_init_duckdb_scalar_function_set(void) {
+void rbduckdb_init_scalar_function_set(void) {
 #if 0
     VALUE mDuckDB = rb_define_module("DuckDB");
 #endif
     cDuckDBScalarFunctionSet = rb_define_class_under(mDuckDB, "ScalarFunctionSet", rb_cObject);
     rb_define_alloc_func(cDuckDBScalarFunctionSet, allocate);
-    rb_define_private_method(cDuckDBScalarFunctionSet, "_initialize", rbduckdb_scalar_function_set__initialize, 1);
-    rb_define_private_method(cDuckDBScalarFunctionSet, "_add", rbduckdb_scalar_function_set__add, 1);
+    rb_define_private_method(cDuckDBScalarFunctionSet, "_initialize", scalar_function_set__initialize, 1);
+    rb_define_private_method(cDuckDBScalarFunctionSet, "_add", scalar_function_set__add, 1);
 }

data/ext/duckdb/scalar_function_set.h

@@ -8,7 +8,7 @@ struct _rubyDuckDBScalarFunctionSet {
 
 typedef struct _rubyDuckDBScalarFunctionSet rubyDuckDBScalarFunctionSet;
 
-void rbduckdb_init_duckdb_scalar_function_set(void);
-rubyDuckDBScalarFunctionSet *get_struct_scalar_function_set(VALUE obj);
+void rbduckdb_init_scalar_function_set(void);
+rubyDuckDBScalarFunctionSet *rbduckdb_get_struct_scalar_function_set(VALUE obj);
 
 #endif

data/ext/duckdb/table_description.c

@@ -8,13 +8,13 @@ static void deallocate(void *ctx);
 static VALUE allocate(VALUE klass);
 static size_t memsize(const void *p);
 static rubyDuckDBTableDescription *get_struct_table_description(VALUE obj);
-static VALUE rbduckdb_table_description_error_message(VALUE self);
-static VALUE duckdb_table_description__initialize(VALUE self, VALUE conn, VALUE catalog, VALUE schema, VALUE table);
+static VALUE table_description_error_message(VALUE self);
+static VALUE table_description__initialize(VALUE self, VALUE conn, VALUE catalog, VALUE schema, VALUE table);
 
-static VALUE duckdb_table_description__column_count(VALUE self);
-static VALUE duckdb_table_description__column_name(VALUE self, VALUE idx);
-static VALUE duckdb_table_description__column_logical_type(VALUE self, VALUE idx);
-static VALUE duckdb_table_description__column_has_default(VALUE self, VALUE idx);
+static VALUE table_description__column_count(VALUE self);
+static VALUE table_description__column_name(VALUE self, VALUE idx);
+static VALUE table_description__column_logical_type(VALUE self, VALUE idx);
+static VALUE table_description__column_has_default(VALUE self, VALUE idx);
 
 static const rb_data_type_t table_description_data_type = {
     "DuckDB/TableDescription",
@@ -46,14 +46,14 @@ static rubyDuckDBTableDescription *get_struct_table_description(VALUE obj) {
     return ctx;
 }
 
-static VALUE rbduckdb_table_description_error_message(VALUE self) {
+static VALUE table_description_error_message(VALUE self) {
     rubyDuckDBTableDescription *ctx = get_struct_table_description(self);
     const char *p = duckdb_table_description_error(ctx->table_description);
     return p ? rb_str_new2(p) : Qnil;
 }
 
 /* nodoc */
-static VALUE duckdb_table_description__initialize(VALUE self, VALUE con, VALUE catalog, VALUE schema, VALUE table) {
+static VALUE table_description__initialize(VALUE self, VALUE con, VALUE catalog, VALUE schema, VALUE table) {
     char *pcatalog = NULL;
     char *pschema = NULL;
     char *ptable = NULL;
@@ -89,14 +89,14 @@ static VALUE duckdb_table_description__initialize(VALUE self, VALUE con, VALUE c
 }
 
 /* nodoc */
-static VALUE duckdb_table_description__column_count(VALUE self) {
+static VALUE table_description__column_count(VALUE self) {
     rubyDuckDBTableDescription *ctx;
     ctx = get_struct_table_description(self);
     return ULL2NUM(duckdb_table_description_get_column_count(ctx->table_description));
 }
 
 /* nodoc */
-static VALUE duckdb_table_description__column_name(VALUE self, VALUE idx) {
+static VALUE table_description__column_name(VALUE self, VALUE idx) {
     VALUE name = Qnil;
     rubyDuckDBTableDescription *ctx;
     ctx = get_struct_table_description(self);
@@ -109,7 +109,7 @@ static VALUE duckdb_table_description__column_name(VALUE self, VALUE idx) {
 }
 
 /* nodoc */
-static VALUE duckdb_table_description__column_logical_type(VALUE self, VALUE idx) {
+static VALUE table_description__column_logical_type(VALUE self, VALUE idx) {
     rubyDuckDBTableDescription *ctx;
     duckdb_logical_type lt;
     ctx = get_struct_table_description(self);
@@ -117,7 +117,7 @@ static VALUE duckdb_table_description__column_logical_type(VALUE self, VALUE idx
     return rbduckdb_create_logical_type(lt);
 }
 
-static VALUE duckdb_table_description__column_has_default(VALUE self, VALUE idx) {
+static VALUE table_description__column_has_default(VALUE self, VALUE idx) {
     rubyDuckDBTableDescription *ctx;
     bool has_default;
     ctx = get_struct_table_description(self);
@@ -128,17 +128,17 @@ static VALUE duckdb_table_description__column_has_default(VALUE self, VALUE idx)
     return has_default ? Qtrue : Qfalse;
 }
 
-void rbduckdb_init_duckdb_table_description(void) {
+void rbduckdb_init_table_description(void) {
 #if 0
     VALUE mDuckDB = rb_define_module("DuckDB");
 #endif
     cDuckDBTableDescription = rb_define_class_under(mDuckDB, "TableDescription", rb_cObject);
     rb_define_alloc_func(cDuckDBTableDescription, allocate);
-    rb_define_method(cDuckDBTableDescription, "error_message", rbduckdb_table_description_error_message, 0);
-    rb_define_private_method(cDuckDBTableDescription, "_initialize", duckdb_table_description__initialize, 4);
-    rb_define_private_method(cDuckDBTableDescription, "_column_count", duckdb_table_description__column_count, 0);
-    rb_define_private_method(cDuckDBTableDescription, "_column_name", duckdb_table_description__column_name, 1);
-    rb_define_private_method(cDuckDBTableDescription, "_column_logical_type", duckdb_table_description__column_logical_type, 1);
-    rb_define_private_method(cDuckDBTableDescription, "_column_has_default", duckdb_table_description__column_has_default, 1);
+    rb_define_method(cDuckDBTableDescription, "error_message", table_description_error_message, 0);
+    rb_define_private_method(cDuckDBTableDescription, "_initialize", table_description__initialize, 4);
+    rb_define_private_method(cDuckDBTableDescription, "_column_count", table_description__column_count, 0);
+    rb_define_private_method(cDuckDBTableDescription, "_column_name", table_description__column_name, 1);
+    rb_define_private_method(cDuckDBTableDescription, "_column_logical_type", table_description__column_logical_type, 1);
+    rb_define_private_method(cDuckDBTableDescription, "_column_has_default", table_description__column_has_default, 1);
 }
 #endif

data/ext/duckdb/table_description.h

@@ -9,7 +9,7 @@ struct _rubyDuckDBTableDescription {
 
 typedef struct _rubyDuckDBTableDescription rubyDuckDBTableDescription;
 
-void rbduckdb_init_duckdb_table_description(void);
+void rbduckdb_init_table_description(void);
 
 #endif /* HAVE_DUCKDB_H_GE_V1_5_0 */
 

data/ext/duckdb/table_function.c

@@ -11,16 +11,21 @@ static void deallocate(void *ctx);
 static VALUE allocate(VALUE klass);
 static size_t memsize(const void *p);
 static void compact(void *ctx);
-static VALUE duckdb_table_function_initialize(VALUE self);
-static VALUE rbduckdb_table_function_set_name(VALUE self, VALUE name);
-static VALUE rbduckdb_table_function_add_parameter(VALUE self, VALUE logical_type);
-static VALUE rbduckdb_table_function_add_named_parameter(VALUE self, VALUE name, VALUE logical_type);
-static VALUE rbduckdb_table_function_set_bind(VALUE self);
+static VALUE table_function_initialize(VALUE self);
+static VALUE table_function_set_name(VALUE self, VALUE name);
+static VALUE table_function_add_parameter(VALUE self, VALUE logical_type);
+static VALUE table_function_add_named_parameter(VALUE self, VALUE name, VALUE logical_type);
+static VALUE table_function_bind(VALUE self);
 static void table_function_bind_callback(duckdb_bind_info info);
-static VALUE rbduckdb_table_function_set_init(VALUE self);
+static VALUE table_function_init(VALUE self);
 static void table_function_init_callback(duckdb_init_info info);
-static VALUE rbduckdb_table_function_set_execute(VALUE self);
+static VALUE table_function_execute(VALUE self);
 static void table_function_execute_callback(duckdb_function_info info, duckdb_data_chunk output);
+#ifdef HAVE_DUCKDB_H_GE_V1_5_0
+/* Thread detection (declared in function_executor.c); used to skip the proxy on Ruby threads. */
+extern int ruby_native_thread_p(void);
+static void table_function_local_init_callback(duckdb_init_info info);
+#endif
 
 static const rb_data_type_t table_function_data_type = {
     "DuckDB/TableFunction",
@@ -84,7 +89,7 @@ static size_t memsize(const void *p) {
  *   tf.name = "my_function"
  *   # ... configure tf ...
  */
-static VALUE duckdb_table_function_initialize(VALUE self) {
+static VALUE table_function_initialize(VALUE self) {
     rubyDuckDBTableFunction *ctx;
 
     TypedData_Get_Struct(self, rubyDuckDBTableFunction, &table_function_data_type, ctx);
@@ -113,7 +118,7 @@ static VALUE duckdb_table_function_initialize(VALUE self) {
  *
  *   tf.name = "my_function"
  */
-static VALUE rbduckdb_table_function_set_name(VALUE self, VALUE name) {
+static VALUE table_function_set_name(VALUE self, VALUE name) {
     rubyDuckDBTableFunction *ctx;
     const char *func_name;
 
@@ -138,7 +143,7 @@ static VALUE rbduckdb_table_function_set_name(VALUE self, VALUE name) {
  *   tf.add_parameter(DuckDB::LogicalType::BIGINT)
  *   tf.add_parameter(DuckDB::LogicalType::VARCHAR)
  */
-static VALUE rbduckdb_table_function_add_parameter(VALUE self, VALUE logical_type) {
+static VALUE table_function_add_parameter(VALUE self, VALUE logical_type) {
     rubyDuckDBTableFunction *ctx;
     rubyDuckDBLogicalType *ctx_logical_type;
 
@@ -162,7 +167,7 @@ static VALUE rbduckdb_table_function_add_parameter(VALUE self, VALUE logical_typ
  *
  *   tf.add_named_parameter("limit", DuckDB::LogicalType::BIGINT)
  */
-static VALUE rbduckdb_table_function_add_named_parameter(VALUE self, VALUE name, VALUE logical_type) {
+static VALUE table_function_add_named_parameter(VALUE self, VALUE name, VALUE logical_type) {
     rubyDuckDBTableFunction *ctx;
     rubyDuckDBLogicalType *ctx_logical_type;
     const char *param_name;
@@ -192,7 +197,7 @@ static VALUE rbduckdb_table_function_add_named_parameter(VALUE self, VALUE name,
  *     bind_info.add_result_column('name', DuckDB::LogicalType::VARCHAR)
  *   end
  */
-static VALUE rbduckdb_table_function_set_bind(VALUE self) {
+static VALUE table_function_bind(VALUE self) {
     rubyDuckDBTableFunction *ctx;
 
     if (!rb_block_given_p()) {
@@ -231,7 +236,7 @@ static void execute_bind_callback_protected(void *user_data) {
     int state = 0;
 
     bind_info_obj = rb_class_new_instance(0, NULL, cDuckDBTableFunctionBindInfo);
-    bind_info_ctx = get_struct_bind_info(bind_info_obj);
+    bind_info_ctx = rbduckdb_get_struct_bind_info(bind_info_obj);
     bind_info_ctx->bind_info = darg->info;
 
     VALUE call_args[2] = { darg->ctx->bind_proc, bind_info_obj };
@@ -269,7 +274,7 @@ static void table_function_bind_callback(duckdb_bind_info info) {
  *     # Initialize execution state
  *   end
  */
-static VALUE rbduckdb_table_function_set_init(VALUE self) {
+static VALUE table_function_init(VALUE self) {
     rubyDuckDBTableFunction *ctx;
 
     if (!rb_block_given_p()) {
@@ -307,7 +312,7 @@ static void execute_init_callback_protected(void *user_data) {
     int state = 0;
 
     init_info_obj = rb_class_new_instance(0, NULL, cDuckDBTableFunctionInitInfo);
-    init_info_ctx = get_struct_init_info(init_info_obj);
+    init_info_ctx = rbduckdb_get_struct_init_info(init_info_obj);
     init_info_ctx->info = darg->info;
 
     VALUE call_args[2] = { darg->ctx->init_proc, init_info_obj };
@@ -347,7 +352,7 @@ static void table_function_init_callback(duckdb_init_info info) {
  *     # Write data...
  *   end
  */
-static VALUE rbduckdb_table_function_set_execute(VALUE self) {
+static VALUE table_function_execute(VALUE self) {
     rubyDuckDBTableFunction *ctx;
 
     if (!rb_block_given_p()) {
@@ -358,6 +363,10 @@ static VALUE rbduckdb_table_function_set_execute(VALUE self) {
 
     ctx->execute_proc = rb_block_proc();
     duckdb_table_function_set_function(ctx->table_function, table_function_execute_callback);
+#ifdef HAVE_DUCKDB_H_GE_V1_5_0
+    /* Per-worker proxy threads for the execute path (DuckDB >= 1.5.0). */
+    duckdb_table_function_set_local_init(ctx->table_function, table_function_local_init_callback);
+#endif
 
     rbduckdb_function_executor_ensure_started();
 
@@ -384,7 +393,7 @@ static void execute_execute_callback_protected(void *user_data) {
     int state = 0;
 
     func_info_obj = rb_class_new_instance(0, NULL, cDuckDBTableFunctionFunctionInfo);
-    func_info_ctx = get_struct_function_info(func_info_obj);
+    func_info_ctx = rbduckdb_get_struct_function_info(func_info_obj);
     func_info_ctx->info = darg->info;
 
     data_chunk_obj = rb_class_new_instance(0, NULL, cDuckDBDataChunk);
@@ -405,6 +414,7 @@ static void execute_execute_callback_protected(void *user_data) {
 static void table_function_execute_callback(duckdb_function_info info, duckdb_data_chunk output) {
     rubyDuckDBTableFunction *ctx;
     struct execute_dispatch_arg darg;
+    struct worker_proxy *proxy = NULL;
 
     ctx = (rubyDuckDBTableFunction *)duckdb_function_get_extra_info(info);
     if (!ctx || ctx->execute_proc == Qnil) return;
@@ -413,28 +423,84 @@ static void table_function_execute_callback(duckdb_function_info info, duckdb_da
     darg.info = info;
     darg.output = output;
 
-    rbduckdb_function_executor_dispatch(execute_execute_callback_protected, &darg);
+#ifdef HAVE_DUCKDB_H_GE_V1_5_0
+    /* On DuckDB >= 1.5.0 each worker thread carries its own proxy (see local_init). */
+    proxy = (struct worker_proxy *)duckdb_function_get_local_init_data(info);
+#endif
+    rbduckdb_function_executor_dispatch_via_proxy(execute_execute_callback_protected, &darg, proxy);
+}
+
+#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 thread-local init data. 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 local 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, local_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 table_function_local_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_init_set_init_data(info, arg.proxy, rbduckdb_worker_proxy_destroy);
+    }
 }
+#endif
 
-rubyDuckDBTableFunction *get_struct_table_function(VALUE self) {
+rubyDuckDBTableFunction *rbduckdb_get_struct_table_function(VALUE self) {
     rubyDuckDBTableFunction *ctx;
     TypedData_Get_Struct(self, rubyDuckDBTableFunction, &table_function_data_type, ctx);
     return ctx;
 }
 
-void rbduckdb_init_duckdb_table_function(void) {
+void rbduckdb_init_table_function(void) {
 #if 0
     VALUE mDuckDB = rb_define_module("DuckDB");
 #endif
     cDuckDBTableFunction = rb_define_class_under(mDuckDB, "TableFunction", rb_cObject);
     rb_define_alloc_func(cDuckDBTableFunction, allocate);
 
-    rb_define_method(cDuckDBTableFunction, "initialize", duckdb_table_function_initialize, 0);
-    rb_define_method(cDuckDBTableFunction, "set_name", rbduckdb_table_function_set_name, 1);
-    rb_define_method(cDuckDBTableFunction, "name=", rbduckdb_table_function_set_name, 1);
-    rb_define_method(cDuckDBTableFunction, "add_parameter", rbduckdb_table_function_add_parameter, 1);
-    rb_define_method(cDuckDBTableFunction, "add_named_parameter", rbduckdb_table_function_add_named_parameter, 2);
-    rb_define_method(cDuckDBTableFunction, "bind", rbduckdb_table_function_set_bind, 0);
-    rb_define_method(cDuckDBTableFunction, "init", rbduckdb_table_function_set_init, 0);
-    rb_define_method(cDuckDBTableFunction, "execute", rbduckdb_table_function_set_execute, 0);
+    rb_define_method(cDuckDBTableFunction, "initialize", table_function_initialize, 0);
+    rb_define_method(cDuckDBTableFunction, "set_name", table_function_set_name, 1);
+    rb_define_method(cDuckDBTableFunction, "name=", table_function_set_name, 1);
+    rb_define_method(cDuckDBTableFunction, "add_parameter", table_function_add_parameter, 1);
+    rb_define_method(cDuckDBTableFunction, "add_named_parameter", table_function_add_named_parameter, 2);
+    rb_define_method(cDuckDBTableFunction, "bind", table_function_bind, 0);
+    rb_define_method(cDuckDBTableFunction, "init", table_function_init, 0);
+    rb_define_method(cDuckDBTableFunction, "execute", table_function_execute, 0);
 }

data/ext/duckdb/table_function.h

@@ -11,7 +11,7 @@ struct _rubyDuckDBTableFunction {
 typedef struct _rubyDuckDBTableFunction rubyDuckDBTableFunction;
 
 extern VALUE cDuckDBTableFunction;
-rubyDuckDBTableFunction *get_struct_table_function(VALUE self);
-void rbduckdb_init_duckdb_table_function(void);
+rubyDuckDBTableFunction *rbduckdb_get_struct_table_function(VALUE self);
+void rbduckdb_init_table_function(void);
 
 #endif

data/ext/duckdb/table_function_bind_info.c

@@ -5,12 +5,12 @@ VALUE cDuckDBTableFunctionBindInfo;
 static void deallocate(void *ctx);
 static VALUE allocate(VALUE klass);
 static size_t memsize(const void *p);
-static VALUE rbduckdb_bind_info_parameter_count(VALUE self);
-static VALUE rbduckdb_bind_info_get_parameter(VALUE self, VALUE index);
-static VALUE rbduckdb_bind_info_get_named_parameter(VALUE self, VALUE name);
-static VALUE rbduckdb_bind_info__add_result_column(VALUE self, VALUE column_name, VALUE logical_type);
-static VALUE rbduckdb_bind_info_set_cardinality(VALUE self, VALUE cardinality, VALUE is_exact);
-static VALUE rbduckdb_bind_info_set_error(VALUE self, VALUE error);
+static VALUE table_function_bind_info_parameter_count(VALUE self);
+static VALUE table_function_bind_info_get_parameter(VALUE self, VALUE index);
+static VALUE table_function_bind_info_get_named_parameter(VALUE self, VALUE name);
+static VALUE table_function_bind_info__add_result_column(VALUE self, VALUE column_name, VALUE logical_type);
+static VALUE table_function_bind_info_set_cardinality(VALUE self, VALUE cardinality, VALUE is_exact);
+static VALUE table_function_bind_info_set_error(VALUE self, VALUE error);
 
 static const rb_data_type_t bind_info_data_type = {
     "DuckDB/TableFunctionBindInfo",
@@ -32,7 +32,7 @@ static size_t memsize(const void *p) {
     return sizeof(rubyDuckDBBindInfo);
 }
 
-rubyDuckDBBindInfo *get_struct_bind_info(VALUE obj) {
+rubyDuckDBBindInfo *rbduckdb_get_struct_bind_info(VALUE obj) {
     rubyDuckDBBindInfo *ctx;
     TypedData_Get_Struct(obj, rubyDuckDBBindInfo, &bind_info_data_type, ctx);
     return ctx;
@@ -52,7 +52,7 @@ rubyDuckDBBindInfo *get_struct_bind_info(VALUE obj) {
  *
  *   bind_info.parameter_count  # => 2
  */
-static VALUE rbduckdb_bind_info_parameter_count(VALUE self) {
+static VALUE table_function_bind_info_parameter_count(VALUE self) {
     rubyDuckDBBindInfo *ctx;
     idx_t count;
 
@@ -71,7 +71,7 @@ static VALUE rbduckdb_bind_info_parameter_count(VALUE self) {
  *
  *   param = bind_info.get_parameter(0)
  */
-static VALUE rbduckdb_bind_info_get_parameter(VALUE self, VALUE index) {
+static VALUE table_function_bind_info_get_parameter(VALUE self, VALUE index) {
     rubyDuckDBBindInfo *ctx;
     idx_t idx;
     duckdb_value param_value;
@@ -97,7 +97,7 @@ static VALUE rbduckdb_bind_info_get_parameter(VALUE self, VALUE index) {
  *
  *   param = bind_info.get_named_parameter('limit')
  */
-static VALUE rbduckdb_bind_info_get_named_parameter(VALUE self, VALUE name) {
+static VALUE table_function_bind_info_get_named_parameter(VALUE self, VALUE name) {
     rubyDuckDBBindInfo *ctx;
     const char *param_name;
     duckdb_value param_value;
@@ -129,7 +129,7 @@ static VALUE rbduckdb_bind_info_get_named_parameter(VALUE self, VALUE name) {
  *   bind_info.add_result_column('id', DuckDB::LogicalType::BIGINT)
  *   bind_info.add_result_column('name', DuckDB::LogicalType::VARCHAR)
  */
-static VALUE rbduckdb_bind_info__add_result_column(VALUE self, VALUE column_name, VALUE logical_type) {
+static VALUE table_function_bind_info__add_result_column(VALUE self, VALUE column_name, VALUE logical_type) {
     rubyDuckDBBindInfo *ctx;
     rubyDuckDBLogicalType *ctx_logical_type;
     const char *col_name;
@@ -152,7 +152,7 @@ static VALUE rbduckdb_bind_info__add_result_column(VALUE self, VALUE column_name
  *   bind_info.set_cardinality(100, true)  # Exactly 100 rows
  *   bind_info.set_cardinality(1000, false)  # Approximately 1000 rows
  */
-static VALUE rbduckdb_bind_info_set_cardinality(VALUE self, VALUE cardinality, VALUE is_exact) {
+static VALUE table_function_bind_info_set_cardinality(VALUE self, VALUE cardinality, VALUE is_exact) {
     rubyDuckDBBindInfo *ctx;
     idx_t card;
     bool exact;
@@ -175,7 +175,7 @@ static VALUE rbduckdb_bind_info_set_cardinality(VALUE self, VALUE cardinality, V
  *
  *   bind_info.set_error('Invalid parameter value')
  */
-static VALUE rbduckdb_bind_info_set_error(VALUE self, VALUE error) {
+static VALUE table_function_bind_info_set_error(VALUE self, VALUE error) {
     rubyDuckDBBindInfo *ctx;
     const char *error_msg;
 
@@ -187,18 +187,18 @@ static VALUE rbduckdb_bind_info_set_error(VALUE self, VALUE error) {
     return self;
 }
 
-void rbduckdb_init_duckdb_table_function_bind_info(void) {
+void rbduckdb_init_table_function_bind_info(void) {
 #if 0
     VALUE mDuckDB = rb_define_module("DuckDB");
 #endif
     cDuckDBTableFunctionBindInfo = rb_define_class_under(cDuckDBTableFunction, "BindInfo", rb_cObject);
     rb_define_alloc_func(cDuckDBTableFunctionBindInfo, allocate);
 
-    rb_define_method(cDuckDBTableFunctionBindInfo, "parameter_count", rbduckdb_bind_info_parameter_count, 0);
-    rb_define_method(cDuckDBTableFunctionBindInfo, "get_parameter", rbduckdb_bind_info_get_parameter, 1);
-    rb_define_method(cDuckDBTableFunctionBindInfo, "get_named_parameter", rbduckdb_bind_info_get_named_parameter, 1);
-    rb_define_method(cDuckDBTableFunctionBindInfo, "set_cardinality", rbduckdb_bind_info_set_cardinality, 2);
-    rb_define_method(cDuckDBTableFunctionBindInfo, "set_error", rbduckdb_bind_info_set_error, 1);
+    rb_define_method(cDuckDBTableFunctionBindInfo, "parameter_count", table_function_bind_info_parameter_count, 0);
+    rb_define_method(cDuckDBTableFunctionBindInfo, "get_parameter", table_function_bind_info_get_parameter, 1);
+    rb_define_method(cDuckDBTableFunctionBindInfo, "get_named_parameter", table_function_bind_info_get_named_parameter, 1);
+    rb_define_method(cDuckDBTableFunctionBindInfo, "set_cardinality", table_function_bind_info_set_cardinality, 2);
+    rb_define_method(cDuckDBTableFunctionBindInfo, "set_error", table_function_bind_info_set_error, 1);
 
-    rb_define_private_method(cDuckDBTableFunctionBindInfo, "_add_result_column", rbduckdb_bind_info__add_result_column, 2);
+    rb_define_private_method(cDuckDBTableFunctionBindInfo, "_add_result_column", table_function_bind_info__add_result_column, 2);
 }

data/ext/duckdb/table_function_bind_info.h

@@ -8,7 +8,7 @@ struct _rubyDuckDBBindInfo {
 typedef struct _rubyDuckDBBindInfo rubyDuckDBBindInfo;
 
 extern VALUE cDuckDBTableFunctionBindInfo;
-rubyDuckDBBindInfo *get_struct_bind_info(VALUE obj);
-void rbduckdb_init_duckdb_table_function_bind_info(void);
+rubyDuckDBBindInfo *rbduckdb_get_struct_bind_info(VALUE obj);
+void rbduckdb_init_table_function_bind_info(void);
 
 #endif

data/ext/duckdb/table_function_function_info.c

@@ -5,7 +5,7 @@ VALUE cDuckDBTableFunctionFunctionInfo;
 static void deallocate(void *ctx);
 static VALUE allocate(VALUE klass);
 static size_t memsize(const void *p);
-static VALUE rbduckdb_function_info_set_error(VALUE self, VALUE error);
+static VALUE table_function_function_info_set_error(VALUE self, VALUE error);
 
 static const rb_data_type_t function_info_data_type = {
     "DuckDB/TableFunctionFunctionInfo",
@@ -27,7 +27,7 @@ static size_t memsize(const void *p) {
     return sizeof(rubyDuckDBFunctionInfo);
 }
 
-rubyDuckDBFunctionInfo *get_struct_function_info(VALUE obj) {
+rubyDuckDBFunctionInfo *rbduckdb_get_struct_function_info(VALUE obj) {
     rubyDuckDBFunctionInfo *ctx;
     TypedData_Get_Struct(obj, rubyDuckDBFunctionInfo, &function_info_data_type, ctx);
     return ctx;
@@ -42,7 +42,7 @@ rubyDuckDBFunctionInfo *get_struct_function_info(VALUE obj) {
  *
  *   function_info.set_error('Invalid parameter value')
  */
-static VALUE rbduckdb_function_info_set_error(VALUE self, VALUE error) {
+static VALUE table_function_function_info_set_error(VALUE self, VALUE error) {
     rubyDuckDBFunctionInfo *ctx;
     const char *error_msg;
 
@@ -54,12 +54,12 @@ static VALUE rbduckdb_function_info_set_error(VALUE self, VALUE error) {
     return self;
 }
 
-void rbduckdb_init_duckdb_table_function_function_info(void) {
+void rbduckdb_init_table_function_function_info(void) {
 #if 0
     VALUE mDuckDB = rb_define_module("DuckDB");
 #endif
     cDuckDBTableFunctionFunctionInfo = rb_define_class_under(cDuckDBTableFunction, "FunctionInfo", rb_cObject);
     rb_define_alloc_func(cDuckDBTableFunctionFunctionInfo, allocate);
 
-    rb_define_method(cDuckDBTableFunctionFunctionInfo, "set_error", rbduckdb_function_info_set_error, 1);
+    rb_define_method(cDuckDBTableFunctionFunctionInfo, "set_error", table_function_function_info_set_error, 1);
 }