duckdb 1.5.3.0 → 1.5.4.0

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
-
-

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 */