duckdb 1.5.3.0 → 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/appender.rb

@@ -558,6 +558,29 @@ module DuckDB
       raise_appender_error('failed to append_uhugeint')
     end
 
+    # :call-seq:
+    #   appender.append_uuid(val) -> self
+    #
+    # Appends a UUID value to the current row in the appender.
+    # +val+ must be a String in canonical UUID format
+    # (<tt>xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx</tt>).
+    # Raises ArgumentError if +val+ is not a valid UUID string.
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open
+    #   con = db.connect
+    #   con.query('CREATE TABLE uuids (id UUID)')
+    #   appender = con.appender('uuids')
+    #   appender
+    #     .append_uuid('550e8400-e29b-41d4-a716-446655440000')
+    #     .end_row
+    #     .flush
+    def append_uuid(value)
+      return self if _append_uuid(value)
+
+      raise_appender_error('failed to append_uuid')
+    end
+
     # call-seq:
     #   appender.append_date(val) -> self
     #

data/lib/duckdb/arrow_array_stream.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module DuckDB
+  # The ArrowArrayStream class represents an exported Arrow C stream of a
+  # query result (Arrow C Data Interface). It is created by
+  # DuckDB::Result#arrow_c_stream and cannot be instantiated directly.
+  #
+  # The object satisfies the Ruby Arrow C stream protocol: #arrow_c_stream
+  # returns self and #to_i returns the address of the underlying
+  # <tt>struct ArrowArrayStream</tt>, so it can be consumed by ruby-polars,
+  # red-arrow and other Arrow consumers:
+  #
+  #   result = con.query('SELECT * FROM users')
+  #
+  #   # ruby-polars
+  #   df = Polars::DataFrame.new(result)
+  #
+  #   # red-arrow
+  #   reader = Arrow::RecordBatchReader.import(result.arrow_c_stream.to_i)
+  #
+  # The consumer takes ownership of the stream's contents; a result can be
+  # exported only once.
+  #
+  # [EXPERIMENTAL] This API is built on DuckDB's unstable Arrow C API and
+  # may change in any minor release.
+  class ArrowArrayStream
+    class << self
+      def new
+        raise DuckDB::Error, 'DuckDB::ArrowArrayStream cannot be instantiated directly. Use DuckDB::Result#arrow_c_stream.'
+      end
+    end
+  end
+end

data/lib/duckdb/connection.rb

@@ -383,8 +383,62 @@ module DuckDB
       register_table_function(tf)
     end
 
+    # [EXPERIMENTAL] Appends an Arrow producer into an existing table.
+    #
+    # Reads +producer+ (any object responding to +#arrow_c_stream+, such as a
+    # ruby-polars +DataFrame+ or a +DuckDB::Result+) as an Arrow C stream and
+    # appends its chunks into the existing table +table+. The producer's Arrow
+    # columns must line up with the table's columns positionally and by count.
+    # DuckDB casts compatible column types (e.g. INTEGER into a BIGINT column);
+    # a type that cannot be cast (e.g. a non-numeric VARCHAR into an INTEGER
+    # column) or a column-count mismatch raises +DuckDB::Error+.
+    #
+    # This is not transactional: a schema mismatch fails before any rows are
+    # written, but a rarer mid-stream failure can leave earlier chunks
+    # appended. Wrap the call in your own transaction for all-or-nothing.
+    #
+    # This API is built on DuckDB's unstable Arrow C API and may change in any
+    # minor release.
+    #
+    # @param table [String] the name of the existing target table
+    # @param producer [#arrow_c_stream] the Arrow producer
+    # @raise [TypeError] if +producer+ does not respond to +#arrow_c_stream+
+    # @return [Integer] the number of rows appended
+    #
+    # @example Load a Polars DataFrame into a table
+    #   con.query('CREATE TABLE t (id INTEGER, name VARCHAR)')
+    #   con.append_arrow('t', polars_df)
+    #
+    def append_arrow(table, producer)
+      unless producer.respond_to?(:arrow_c_stream)
+        raise TypeError, "Arrow producer must respond to #arrow_c_stream, got #{producer.class}"
+      end
+
+      stream = producer.arrow_c_stream # keep the producer's stream alive for the duration
+      address = stream.to_i
+      begin
+        append_arrow_chunks(table, address)
+      ensure
+        _arrow_release(address)
+      end
+    end
+
     private
 
+    # Drives the Arrow stream at +address+ chunk by chunk into +table+,
+    # returning the number of rows appended.
+    def append_arrow_chunks(table, address)
+      converted_schema = _arrow_converted_schema(address)
+      rows = 0
+      appender(table) do |app|
+        while (chunk = _arrow_next_chunk(address, converted_schema))
+          rows += chunk.size
+          app.append_data_chunk(chunk)
+        end
+      end
+      rows
+    end
+
     def run_appender_block(appender, &)
       return appender unless block_given?