duckdb 1.5.2.1 → 1.5.4.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);
 }

data/ext/duckdb/table_function_function_info.h

@@ -7,7 +7,7 @@ struct _rubyDuckDBFunctionInfo {
 
 typedef struct _rubyDuckDBFunctionInfo rubyDuckDBFunctionInfo;
 
-rubyDuckDBFunctionInfo *get_struct_function_info(VALUE obj);
-void rbduckdb_init_duckdb_table_function_function_info(void);
+rubyDuckDBFunctionInfo *rbduckdb_get_struct_function_info(VALUE obj);
+void rbduckdb_init_table_function_function_info(void);
 
 #endif

data/ext/duckdb/table_function_init_info.c

@@ -5,7 +5,10 @@ VALUE cDuckDBTableFunctionInitInfo;
 static void deallocate(void *ctx);
 static VALUE allocate(VALUE klass);
 static size_t memsize(const void *p);
-static VALUE rbduckdb_init_info_set_error(VALUE self, VALUE error);
+static VALUE table_function_init_info_set_error(VALUE self, VALUE error);
+static VALUE table_function_init_info_set_max_threads(VALUE self, VALUE max_threads);
+static VALUE table_function_init_info_column_count(VALUE self);
+static VALUE table_function_init_info_column_index(VALUE self, VALUE index);
 
 static const rb_data_type_t init_info_data_type = {
     "DuckDB/TableFunctionInitInfo",
@@ -27,7 +30,7 @@ static size_t memsize(const void *p) {
     return sizeof(rubyDuckDBInitInfo);
 }
 
-rubyDuckDBInitInfo *get_struct_init_info(VALUE obj) {
+rubyDuckDBInitInfo *rbduckdb_get_struct_init_info(VALUE obj) {
     rubyDuckDBInitInfo *ctx;
     TypedData_Get_Struct(obj, rubyDuckDBInitInfo, &init_info_data_type, ctx);
     return ctx;
@@ -42,7 +45,7 @@ rubyDuckDBInitInfo *get_struct_init_info(VALUE obj) {
  *
  *   init_info.set_error('Invalid initialization')
  */
-static VALUE rbduckdb_init_info_set_error(VALUE self, VALUE error) {
+static VALUE table_function_init_info_set_error(VALUE self, VALUE error) {
     rubyDuckDBInitInfo *ctx;
     const char *error_msg;
 
@@ -54,12 +57,74 @@ static VALUE rbduckdb_init_info_set_error(VALUE self, VALUE error) {
     return self;
 }
 
-void rbduckdb_init_duckdb_table_function_init_info(void) {
+/*
+ * call-seq:
+ *   init_info.set_max_threads(max_threads) -> self
+ *   init_info.max_threads = max_threads
+ *
+ * Sets the maximum number of threads that can execute the table function concurrently.
+ * This is a hint to DuckDB's scheduler; the actual number of threads is also bounded
+ * by the configured worker pool size (e.g., +SET threads+).
+ *
+ *   init_info.max_threads = 4
+ */
+static VALUE table_function_init_info_set_max_threads(VALUE self, VALUE max_threads) {
+    rubyDuckDBInitInfo *ctx;
+
+    TypedData_Get_Struct(self, rubyDuckDBInitInfo, &init_info_data_type, ctx);
+
+    duckdb_init_set_max_threads(ctx->info, NUM2ULL(max_threads));
+
+    return self;
+}
+
+/*
+ * call-seq:
+ *   init_info.column_count -> Integer
+ *
+ * Returns the number of projected result columns for this scan.
+ * Without projection pushdown this equals the number of result columns
+ * added in the bind callback.
+ *
+ *   init_info.column_count # => 2
+ */
+static VALUE table_function_init_info_column_count(VALUE self) {
+    rubyDuckDBInitInfo *ctx;
+
+    TypedData_Get_Struct(self, rubyDuckDBInitInfo, &init_info_data_type, ctx);
+
+    return ULL2NUM(duckdb_init_get_column_count(ctx->info));
+}
+
+/*
+ * call-seq:
+ *   init_info.column_index(index) -> Integer
+ *
+ * Returns the column index of the projected result column at +index+
+ * (0 <= +index+ < column_count). Without projection pushdown the projected
+ * columns mirror the columns added in the bind callback, so this returns
+ * +index+ itself.
+ *
+ *   init_info.column_index(0) # => 0
+ */
+static VALUE table_function_init_info_column_index(VALUE self, VALUE index) {
+    rubyDuckDBInitInfo *ctx;
+
+    TypedData_Get_Struct(self, rubyDuckDBInitInfo, &init_info_data_type, ctx);
+
+    return ULL2NUM(duckdb_init_get_column_index(ctx->info, NUM2ULL(index)));
+}
+
+void rbduckdb_init_table_function_init_info(void) {
 #if 0
     VALUE mDuckDB = rb_define_module("DuckDB");
 #endif
     cDuckDBTableFunctionInitInfo = rb_define_class_under(cDuckDBTableFunction, "InitInfo", rb_cObject);
     rb_define_alloc_func(cDuckDBTableFunctionInitInfo, allocate);
 
-    rb_define_method(cDuckDBTableFunctionInitInfo, "set_error", rbduckdb_init_info_set_error, 1);
+    rb_define_method(cDuckDBTableFunctionInitInfo, "set_error", table_function_init_info_set_error, 1);
+    rb_define_method(cDuckDBTableFunctionInitInfo, "set_max_threads", table_function_init_info_set_max_threads, 1);
+    rb_define_method(cDuckDBTableFunctionInitInfo, "max_threads=", table_function_init_info_set_max_threads, 1);
+    rb_define_method(cDuckDBTableFunctionInitInfo, "column_count", table_function_init_info_column_count, 0);
+    rb_define_method(cDuckDBTableFunctionInitInfo, "column_index", table_function_init_info_column_index, 1);
 }

data/ext/duckdb/table_function_init_info.h

@@ -8,7 +8,7 @@ struct _rubyDuckDBInitInfo {
 typedef struct _rubyDuckDBInitInfo rubyDuckDBInitInfo;
 
 extern VALUE cDuckDBTableFunctionInitInfo;
-rubyDuckDBInitInfo *get_struct_init_info(VALUE obj);
-void rbduckdb_init_duckdb_table_function_init_info(void);
+rubyDuckDBInitInfo *rbduckdb_get_struct_init_info(VALUE obj);
+void rbduckdb_init_table_function_init_info(void);
 
 #endif

data/lib/duckdb/aggregate_function.rb

@@ -57,6 +57,12 @@ module DuckDB
   class AggregateFunction
     include FunctionTypeValidation
 
+    def name=(value)
+      set_name(value.to_s)
+    end
+
+    private :set_name
+
     class << self
       # Creates a new AggregateFunction in a single call.
       #
@@ -64,7 +70,7 @@ module DuckDB
       # AggregateFunction without requiring you to set each attribute
       # separately.
       #
-      # @param name [String] the SQL function name
+      # @param name [String, Symbol] the SQL function name
       # @param return_type [DuckDB::LogicalType | Symbol] the SQL return type
       # @param params [Array<DuckDB::LogicalType | Symbol>] input parameter types
       #   (empty array for a zero-argument aggregate)

data/lib/duckdb/aggregate_function_set.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module DuckDB
+  # DuckDB::AggregateFunctionSet encapsulates DuckDB's aggregate function set,
+  # which allows registering multiple overloads of an aggregate function under one name.
+  #
+  # @note DuckDB::AggregateFunctionSet is experimental.
+  class AggregateFunctionSet
+    # @param name [String, Symbol] the function set name shared by all overloads
+    # @raise [TypeError] if name is not a String or Symbol
+    def initialize(name)
+      raise TypeError, "#{name.class} is not a String or Symbol" unless name.is_a?(String) || name.is_a?(Symbol)
+
+      _initialize(name.to_s)
+    end
+
+    # @param aggregate_function [DuckDB::AggregateFunction] the overload to add
+    # @return [self]
+    # @raise [TypeError] if aggregate_function is not a DuckDB::AggregateFunction
+    # @raise [DuckDB::Error] if the overload already exists in the set
+    def add(aggregate_function)
+      unless aggregate_function.is_a?(DuckDB::AggregateFunction)
+        raise TypeError, "#{aggregate_function.class} is not a DuckDB::AggregateFunction"
+      end
+
+      _add(aggregate_function)
+    end
+  end
+end