duckdb 1.4.2.0 → 1.4.4.0

data/ext/duckdb/bind_info.c

@@ -0,0 +1,243 @@
+#include "ruby-duckdb.h"
+
+VALUE cDuckDBBindInfo;
+
+static void deallocate(void *ctx);
+static VALUE allocate(VALUE klass);
+static size_t memsize(const void *p);
+static VALUE convert_duckdb_value_to_ruby(duckdb_value param_value);
+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 const rb_data_type_t bind_info_data_type = {
+    "DuckDB/BindInfo",
+    {NULL, deallocate, memsize,},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static void deallocate(void *ctx) {
+    rubyDuckDBBindInfo *p = (rubyDuckDBBindInfo *)ctx;
+    xfree(p);
+}
+
+static VALUE allocate(VALUE klass) {
+    rubyDuckDBBindInfo *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBBindInfo));
+    return TypedData_Wrap_Struct(klass, &bind_info_data_type, ctx);
+}
+
+static size_t memsize(const void *p) {
+    return sizeof(rubyDuckDBBindInfo);
+}
+
+rubyDuckDBBindInfo *get_struct_bind_info(VALUE obj) {
+    rubyDuckDBBindInfo *ctx;
+    TypedData_Get_Struct(obj, rubyDuckDBBindInfo, &bind_info_data_type, ctx);
+    return ctx;
+}
+
+/*
+ * Converts a duckdb_value to a Ruby VALUE.
+ * Handles basic types: BIGINT, INTEGER, VARCHAR, DOUBLE, BOOLEAN.
+ * Returns Qnil for unsupported types.
+ * Note: Caller must destroy duckdb_value and duckdb_logical_type.
+ */
+static VALUE convert_duckdb_value_to_ruby(duckdb_value param_value) {
+    duckdb_logical_type logical_type;
+    duckdb_type type_id;
+    VALUE result;
+
+    logical_type = duckdb_get_value_type(param_value);
+    type_id = duckdb_get_type_id(logical_type);
+
+    switch (type_id) {
+        case DUCKDB_TYPE_BIGINT:
+            result = LL2NUM(duckdb_get_int64(param_value));
+            break;
+        case DUCKDB_TYPE_INTEGER:
+            result = INT2NUM(duckdb_get_int32(param_value));
+            break;
+        case DUCKDB_TYPE_VARCHAR: {
+            char *str = duckdb_get_varchar(param_value);
+            result = rb_str_new_cstr(str);
+            duckdb_free(str);
+            break;
+        }
+        case DUCKDB_TYPE_DOUBLE:
+            result = DBL2NUM(duckdb_get_double(param_value));
+            break;
+        case DUCKDB_TYPE_BOOLEAN:
+            result = duckdb_get_bool(param_value) ? Qtrue : Qfalse;
+            break;
+        default:
+            // For unsupported types, return nil
+            result = Qnil;
+            break;
+    }
+
+    duckdb_destroy_logical_type(&logical_type);
+
+    return result;
+}
+
+/*
+ * call-seq:
+ *   bind_info.parameter_count -> Integer
+ *
+ * Returns the number of parameters passed to the table function.
+ *
+ *   bind_info.parameter_count  # => 2
+ */
+static VALUE rbduckdb_bind_info_parameter_count(VALUE self) {
+    rubyDuckDBBindInfo *ctx;
+    idx_t count;
+
+    TypedData_Get_Struct(self, rubyDuckDBBindInfo, &bind_info_data_type, ctx);
+
+    count = duckdb_bind_get_parameter_count(ctx->bind_info);
+
+    return ULL2NUM(count);
+}
+
+/*
+ * call-seq:
+ *   bind_info.get_parameter(index) -> value
+ *
+ * Gets the parameter value at the given index.
+ *
+ *   param = bind_info.get_parameter(0)
+ */
+static VALUE rbduckdb_bind_info_get_parameter(VALUE self, VALUE index) {
+    rubyDuckDBBindInfo *ctx;
+    idx_t idx;
+    duckdb_value param_value;
+    VALUE result;
+
+    TypedData_Get_Struct(self, rubyDuckDBBindInfo, &bind_info_data_type, ctx);
+
+    idx = NUM2ULL(index);
+    param_value = duckdb_bind_get_parameter(ctx->bind_info, idx);
+
+    result = convert_duckdb_value_to_ruby(param_value);
+
+    duckdb_destroy_value(&param_value);
+
+    return result;
+}
+
+/*
+ * call-seq:
+ *   bind_info.get_named_parameter(name) -> value or nil
+ *
+ * Gets the named parameter value, or nil if not provided.
+ *
+ *   param = bind_info.get_named_parameter('limit')
+ */
+static VALUE rbduckdb_bind_info_get_named_parameter(VALUE self, VALUE name) {
+    rubyDuckDBBindInfo *ctx;
+    const char *param_name;
+    duckdb_value param_value;
+    VALUE result;
+
+    TypedData_Get_Struct(self, rubyDuckDBBindInfo, &bind_info_data_type, ctx);
+
+    param_name = StringValueCStr(name);
+    param_value = duckdb_bind_get_named_parameter(ctx->bind_info, param_name);
+
+    // If parameter not found, return nil
+    if (!param_value) {
+        return Qnil;
+    }
+
+    result = convert_duckdb_value_to_ruby(param_value);
+
+    duckdb_destroy_value(&param_value);
+
+    return result;
+}
+
+/*
+ * call-seq:
+ *   bind_info.add_result_column(name, logical_type) -> self
+ *
+ * Adds a column to the output schema.
+ *
+ *   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) {
+    rubyDuckDBBindInfo *ctx;
+    rubyDuckDBLogicalType *ctx_logical_type;
+    const char *col_name;
+
+    TypedData_Get_Struct(self, rubyDuckDBBindInfo, &bind_info_data_type, ctx);
+    ctx_logical_type = get_struct_logical_type(logical_type);
+
+    col_name = StringValueCStr(column_name);
+    duckdb_bind_add_result_column(ctx->bind_info, col_name, ctx_logical_type->logical_type);
+
+    return self;
+}
+
+/*
+ * call-seq:
+ *   bind_info.set_cardinality(cardinality, is_exact) -> self
+ *
+ * Sets the estimated number of rows this function will return.
+ *
+ *   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) {
+    rubyDuckDBBindInfo *ctx;
+    idx_t card;
+    bool exact;
+
+    TypedData_Get_Struct(self, rubyDuckDBBindInfo, &bind_info_data_type, ctx);
+
+    card = NUM2ULL(cardinality);
+    exact = RTEST(is_exact);
+
+    duckdb_bind_set_cardinality(ctx->bind_info, card, exact);
+
+    return self;
+}
+
+/*
+ * call-seq:
+ *   bind_info.set_error(error_message) -> self
+ *
+ * Reports an error during bind phase.
+ *
+ *   bind_info.set_error('Invalid parameter value')
+ */
+static VALUE rbduckdb_bind_info_set_error(VALUE self, VALUE error) {
+    rubyDuckDBBindInfo *ctx;
+    const char *error_msg;
+
+    TypedData_Get_Struct(self, rubyDuckDBBindInfo, &bind_info_data_type, ctx);
+
+    error_msg = StringValueCStr(error);
+    duckdb_bind_set_error(ctx->bind_info, error_msg);
+
+    return self;
+}
+
+void rbduckdb_init_duckdb_bind_info(void) {
+#if 0
+    VALUE mDuckDB = rb_define_module("DuckDB");
+#endif
+    cDuckDBBindInfo = rb_define_class_under(mDuckDB, "BindInfo", rb_cObject);
+    rb_define_alloc_func(cDuckDBBindInfo, allocate);
+
+    rb_define_method(cDuckDBBindInfo, "parameter_count", rbduckdb_bind_info_parameter_count, 0);
+    rb_define_method(cDuckDBBindInfo, "get_parameter", rbduckdb_bind_info_get_parameter, 1);
+    rb_define_method(cDuckDBBindInfo, "get_named_parameter", rbduckdb_bind_info_get_named_parameter, 1);
+    rb_define_method(cDuckDBBindInfo, "set_cardinality", rbduckdb_bind_info_set_cardinality, 2);
+    rb_define_method(cDuckDBBindInfo, "set_error", rbduckdb_bind_info_set_error, 1);
+
+    rb_define_private_method(cDuckDBBindInfo, "_add_result_column", rbduckdb_bind_info__add_result_column, 2);
+}

data/ext/duckdb/bind_info.h

@@ -0,0 +1,13 @@
+#ifndef RUBY_DUCKDB_BIND_INFO_H
+#define RUBY_DUCKDB_BIND_INFO_H
+
+struct _rubyDuckDBBindInfo {
+    duckdb_bind_info bind_info;
+};
+
+typedef struct _rubyDuckDBBindInfo rubyDuckDBBindInfo;
+
+rubyDuckDBBindInfo *get_struct_bind_info(VALUE obj);
+void rbduckdb_init_duckdb_bind_info(void);
+
+#endif

data/ext/duckdb/connection.c

@@ -3,6 +3,7 @@
 VALUE cDuckDBConnection;
 
 static void deallocate(void *ctx);
+static void mark(void *ctx);
 static VALUE allocate(VALUE klass);
 static size_t memsize(const void *p);
 static VALUE duckdb_connection_disconnect(VALUE self);
@@ -10,10 +11,12 @@ static VALUE duckdb_connection_interrupt(VALUE self);
 static VALUE duckdb_connection_query_progress(VALUE self);
 static VALUE duckdb_connection_connect(VALUE self, VALUE oDuckDBDatabase);
 static VALUE duckdb_connection_query_sql(VALUE self, VALUE str);
+static VALUE duckdb_connection_register_scalar_function(VALUE self, VALUE scalar_function);
+static VALUE duckdb_connection_register_table_function(VALUE self, VALUE table_function);
 
 static const rb_data_type_t connection_data_type = {
     "DuckDB/Connection",
-    {NULL, deallocate, memsize,},
+    {mark, deallocate, memsize,},
     0, 0, RUBY_TYPED_FREE_IMMEDIATELY
 };
 
@@ -24,9 +27,18 @@ static void deallocate(void *ctx) {
     xfree(p);
 }
 
+static void mark(void *ctx) {
+    rubyDuckDBConnection *p = (rubyDuckDBConnection *)ctx;
+    rb_gc_mark(p->registered_functions);
+}
+
 static VALUE allocate(VALUE klass) {
     rubyDuckDBConnection *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBConnection));
-    return TypedData_Wrap_Struct(klass, &connection_data_type, ctx);
+    VALUE obj = TypedData_Wrap_Struct(klass, &connection_data_type, ctx);
+    VALUE registered_functions = rb_ary_new();
+    ctx->registered_functions = registered_functions;
+    RB_GC_GUARD(registered_functions);
+    return obj;
 }
 
 static size_t memsize(const void *p) {
@@ -62,6 +74,9 @@ static VALUE duckdb_connection_disconnect(VALUE self) {
     TypedData_Get_Struct(self, rubyDuckDBConnection, &connection_data_type, ctx);
     duckdb_disconnect(&(ctx->con));
 
+    /* Clear registered functions to release memory */
+    rb_ary_clear(ctx->registered_functions);
+
     return self;
 }
 
@@ -152,6 +167,47 @@ static VALUE duckdb_connection_query_sql(VALUE self, VALUE str) {
     return result;
 }
 
+/* :nodoc: */
+static VALUE duckdb_connection_register_scalar_function(VALUE self, VALUE scalar_function) {
+    rubyDuckDBConnection *ctxcon;
+    rubyDuckDBScalarFunction *ctxsf;
+    duckdb_state state;
+
+    ctxcon = get_struct_connection(self);
+    ctxsf = get_struct_scalar_function(scalar_function);
+
+    state = duckdb_register_scalar_function(ctxcon->con, ctxsf->scalar_function);
+
+    if (state == DuckDBError) {
+        rb_raise(eDuckDBError, "Failed to register scalar function");
+    }
+
+    /* Keep reference to prevent GC while connection is alive */
+    rb_ary_push(ctxcon->registered_functions, scalar_function);
+
+    return self;
+}
+
+static VALUE duckdb_connection_register_table_function(VALUE self, VALUE table_function) {
+    rubyDuckDBConnection *ctxcon;
+    rubyDuckDBTableFunction *ctxtf;
+    duckdb_state state;
+
+    ctxcon = get_struct_connection(self);
+    ctxtf = get_struct_table_function(table_function);
+
+    state = duckdb_register_table_function(ctxcon->con, ctxtf->table_function);
+
+    if (state == DuckDBError) {
+        rb_raise(eDuckDBError, "Failed to register table function");
+    }
+
+    /* Keep reference to prevent GC while connection is alive */
+    rb_ary_push(ctxcon->registered_functions, table_function);
+
+    return self;
+}
+
 void rbduckdb_init_duckdb_connection(void) {
 #if 0
     VALUE mDuckDB = rb_define_module("DuckDB");
@@ -162,6 +218,8 @@ void rbduckdb_init_duckdb_connection(void) {
     rb_define_method(cDuckDBConnection, "disconnect", duckdb_connection_disconnect, 0);
     rb_define_method(cDuckDBConnection, "interrupt", duckdb_connection_interrupt, 0);
     rb_define_method(cDuckDBConnection, "query_progress", duckdb_connection_query_progress, 0);
+    rb_define_private_method(cDuckDBConnection, "_register_scalar_function", duckdb_connection_register_scalar_function, 1);
+    rb_define_private_method(cDuckDBConnection, "_register_table_function", duckdb_connection_register_table_function, 1);
     rb_define_private_method(cDuckDBConnection, "_connect", duckdb_connection_connect, 1);
     /* TODO: query_sql => _query_sql */
     rb_define_private_method(cDuckDBConnection, "query_sql", duckdb_connection_query_sql, 1);

data/ext/duckdb/connection.h

@@ -3,6 +3,7 @@
 
 struct _rubyDuckDBConnection {
     duckdb_connection con;
+    VALUE registered_functions;
 };
 
 typedef struct _rubyDuckDBConnection rubyDuckDBConnection;

data/ext/duckdb/data_chunk.c

@@ -0,0 +1,137 @@
+#include "ruby-duckdb.h"
+
+VALUE cDuckDBDataChunk;
+extern VALUE cDuckDBVector;
+
+static void deallocate(void *ctx);
+static VALUE allocate(VALUE klass);
+static size_t memsize(const void *p);
+static VALUE rbduckdb_data_chunk_column_count(VALUE self);
+static VALUE rbduckdb_data_chunk_get_size(VALUE self);
+static VALUE rbduckdb_data_chunk_set_size(VALUE self, VALUE size);
+static VALUE rbduckdb_data_chunk_get_vector(VALUE self, VALUE col_idx);
+
+static const rb_data_type_t data_chunk_data_type = {
+    "DuckDB/DataChunk",
+    {NULL, deallocate, memsize,},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static void deallocate(void *ctx) {
+    rubyDuckDBDataChunk *p = (rubyDuckDBDataChunk *)ctx;
+    xfree(p);
+}
+
+static VALUE allocate(VALUE klass) {
+    rubyDuckDBDataChunk *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBDataChunk));
+    return TypedData_Wrap_Struct(klass, &data_chunk_data_type, ctx);
+}
+
+static size_t memsize(const void *p) {
+    return sizeof(rubyDuckDBDataChunk);
+}
+
+rubyDuckDBDataChunk *get_struct_data_chunk(VALUE obj) {
+    rubyDuckDBDataChunk *ctx;
+    TypedData_Get_Struct(obj, rubyDuckDBDataChunk, &data_chunk_data_type, ctx);
+    return ctx;
+}
+
+/*
+ * call-seq:
+ *   data_chunk.column_count -> Integer
+ *
+ * Returns the number of columns in the data chunk.
+ *
+ *   data_chunk.column_count  # => 2
+ */
+static VALUE rbduckdb_data_chunk_column_count(VALUE self) {
+    rubyDuckDBDataChunk *ctx;
+    idx_t count;
+
+    TypedData_Get_Struct(self, rubyDuckDBDataChunk, &data_chunk_data_type, ctx);
+
+    count = duckdb_data_chunk_get_column_count(ctx->data_chunk);
+
+    return ULL2NUM(count);
+}
+
+/*
+ * call-seq:
+ *   data_chunk.size -> Integer
+ *
+ * Returns the current number of tuples in the data chunk.
+ *
+ *   data_chunk.size  # => 100
+ */
+static VALUE rbduckdb_data_chunk_get_size(VALUE self) {
+    rubyDuckDBDataChunk *ctx;
+    idx_t size;
+
+    TypedData_Get_Struct(self, rubyDuckDBDataChunk, &data_chunk_data_type, ctx);
+
+    size = duckdb_data_chunk_get_size(ctx->data_chunk);
+
+    return ULL2NUM(size);
+}
+
+/*
+ * call-seq:
+ *   data_chunk.size = size -> size
+ *
+ * Sets the number of tuples in the data chunk.
+ *
+ *   data_chunk.size = 50
+ */
+static VALUE rbduckdb_data_chunk_set_size(VALUE self, VALUE size) {
+    rubyDuckDBDataChunk *ctx;
+    idx_t sz;
+
+    TypedData_Get_Struct(self, rubyDuckDBDataChunk, &data_chunk_data_type, ctx);
+
+    sz = NUM2ULL(size);
+    duckdb_data_chunk_set_size(ctx->data_chunk, sz);
+
+    return size;
+}
+
+/*
+ * call-seq:
+ *   data_chunk.get_vector(col_idx) -> DuckDB::Vector
+ *
+ * Gets the vector at the specified column index.
+ *
+ *   vector = data_chunk.get_vector(0)
+ */
+static VALUE rbduckdb_data_chunk_get_vector(VALUE self, VALUE col_idx) {
+    rubyDuckDBDataChunk *ctx;
+    idx_t idx;
+    duckdb_vector vector;
+    VALUE vector_obj;
+    rubyDuckDBVector *vector_ctx;
+
+    TypedData_Get_Struct(self, rubyDuckDBDataChunk, &data_chunk_data_type, ctx);
+
+    idx = NUM2ULL(col_idx);
+    vector = duckdb_data_chunk_get_vector(ctx->data_chunk, idx);
+
+    // Create Vector wrapper
+    vector_obj = rb_class_new_instance(0, NULL, cDuckDBVector);
+    vector_ctx = get_struct_vector(vector_obj);
+    vector_ctx->vector = vector;
+
+    return vector_obj;
+}
+
+void rbduckdb_init_duckdb_data_chunk(void) {
+#if 0
+    VALUE mDuckDB = rb_define_module("DuckDB");
+#endif
+    cDuckDBDataChunk = rb_define_class_under(mDuckDB, "DataChunk", rb_cObject);
+    rb_define_alloc_func(cDuckDBDataChunk, allocate);
+
+    rb_define_method(cDuckDBDataChunk, "column_count", rbduckdb_data_chunk_column_count, 0);
+    rb_define_method(cDuckDBDataChunk, "size", rbduckdb_data_chunk_get_size, 0);
+    rb_define_method(cDuckDBDataChunk, "size=", rbduckdb_data_chunk_set_size, 1);
+    rb_define_method(cDuckDBDataChunk, "get_vector", rbduckdb_data_chunk_get_vector, 1);
+}

data/ext/duckdb/data_chunk.h

@@ -0,0 +1,13 @@
+#ifndef RUBY_DUCKDB_DATA_CHUNK_H
+#define RUBY_DUCKDB_DATA_CHUNK_H
+
+struct _rubyDuckDBDataChunk {
+    duckdb_data_chunk data_chunk;
+};
+
+typedef struct _rubyDuckDBDataChunk rubyDuckDBDataChunk;
+
+rubyDuckDBDataChunk *get_struct_data_chunk(VALUE obj);
+void rbduckdb_init_duckdb_data_chunk(void);
+
+#endif

data/ext/duckdb/duckdb.c

@@ -42,4 +42,11 @@ Init_duckdb_native(void) {
     rbduckdb_init_duckdb_instance_cache();
     rbduckdb_init_duckdb_value_impl();
     rbduckdb_init_duckdb_scalar_function();
+    rbduckdb_init_duckdb_bind_info();
+    rbduckdb_init_duckdb_init_info();
+    rbduckdb_init_duckdb_function_info();
+    rbduckdb_init_duckdb_vector();
+    rbduckdb_init_duckdb_data_chunk();
+    rbduckdb_init_memory_helper();
+    rbduckdb_init_duckdb_table_function();
 }

data/ext/duckdb/function_info.c

@@ -0,0 +1,65 @@
+#include "ruby-duckdb.h"
+
+VALUE cDuckDBFunctionInfo;
+
+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 const rb_data_type_t function_info_data_type = {
+    "DuckDB/FunctionInfo",
+    {NULL, deallocate, memsize,},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static void deallocate(void *ctx) {
+    rubyDuckDBFunctionInfo *p = (rubyDuckDBFunctionInfo *)ctx;
+    xfree(p);
+}
+
+static VALUE allocate(VALUE klass) {
+    rubyDuckDBFunctionInfo *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBFunctionInfo));
+    return TypedData_Wrap_Struct(klass, &function_info_data_type, ctx);
+}
+
+static size_t memsize(const void *p) {
+    return sizeof(rubyDuckDBFunctionInfo);
+}
+
+rubyDuckDBFunctionInfo *get_struct_function_info(VALUE obj) {
+    rubyDuckDBFunctionInfo *ctx;
+    TypedData_Get_Struct(obj, rubyDuckDBFunctionInfo, &function_info_data_type, ctx);
+    return ctx;
+}
+
+/*
+ * call-seq:
+ *   function_info.set_error(error_message) -> self
+ *
+ * Sets an error message for the function execution.
+ * This will cause the query to fail with the specified error.
+ *
+ *   function_info.set_error('Invalid parameter value')
+ */
+static VALUE rbduckdb_function_info_set_error(VALUE self, VALUE error) {
+    rubyDuckDBFunctionInfo *ctx;
+    const char *error_msg;
+
+    TypedData_Get_Struct(self, rubyDuckDBFunctionInfo, &function_info_data_type, ctx);
+
+    error_msg = StringValueCStr(error);
+    duckdb_function_set_error(ctx->info, error_msg);
+
+    return self;
+}
+
+void rbduckdb_init_duckdb_function_info(void) {
+#if 0
+    VALUE mDuckDB = rb_define_module("DuckDB");
+#endif
+    cDuckDBFunctionInfo = rb_define_class_under(mDuckDB, "FunctionInfo", rb_cObject);
+    rb_define_alloc_func(cDuckDBFunctionInfo, allocate);
+
+    rb_define_method(cDuckDBFunctionInfo, "set_error", rbduckdb_function_info_set_error, 1);
+}

data/ext/duckdb/function_info.h

@@ -0,0 +1,13 @@
+#ifndef RUBY_DUCKDB_FUNCTION_INFO_H
+#define RUBY_DUCKDB_FUNCTION_INFO_H
+
+struct _rubyDuckDBFunctionInfo {
+    duckdb_function_info info;
+};
+
+typedef struct _rubyDuckDBFunctionInfo rubyDuckDBFunctionInfo;
+
+rubyDuckDBFunctionInfo *get_struct_function_info(VALUE obj);
+void rbduckdb_init_duckdb_function_info(void);
+
+#endif

data/ext/duckdb/init_info.c

@@ -0,0 +1,65 @@
+#include "ruby-duckdb.h"
+
+VALUE cDuckDBInitInfo;
+
+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 const rb_data_type_t init_info_data_type = {
+    "DuckDB/InitInfo",
+    {NULL, deallocate, memsize,},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static void deallocate(void *ctx) {
+    rubyDuckDBInitInfo *p = (rubyDuckDBInitInfo *)ctx;
+    xfree(p);
+}
+
+static VALUE allocate(VALUE klass) {
+    rubyDuckDBInitInfo *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBInitInfo));
+    return TypedData_Wrap_Struct(klass, &init_info_data_type, ctx);
+}
+
+static size_t memsize(const void *p) {
+    return sizeof(rubyDuckDBInitInfo);
+}
+
+rubyDuckDBInitInfo *get_struct_init_info(VALUE obj) {
+    rubyDuckDBInitInfo *ctx;
+    TypedData_Get_Struct(obj, rubyDuckDBInitInfo, &init_info_data_type, ctx);
+    return ctx;
+}
+
+/*
+ * call-seq:
+ *   init_info.set_error(error_message) -> self
+ *
+ * Sets an error message for the init phase.
+ * This will cause the query to fail with the specified error.
+ *
+ *   init_info.set_error('Invalid initialization')
+ */
+static VALUE rbduckdb_init_info_set_error(VALUE self, VALUE error) {
+    rubyDuckDBInitInfo *ctx;
+    const char *error_msg;
+
+    TypedData_Get_Struct(self, rubyDuckDBInitInfo, &init_info_data_type, ctx);
+
+    error_msg = StringValueCStr(error);
+    duckdb_init_set_error(ctx->info, error_msg);
+
+    return self;
+}
+
+void rbduckdb_init_duckdb_init_info(void) {
+#if 0
+    VALUE mDuckDB = rb_define_module("DuckDB");
+#endif
+    cDuckDBInitInfo = rb_define_class_under(mDuckDB, "InitInfo", rb_cObject);
+    rb_define_alloc_func(cDuckDBInitInfo, allocate);
+
+    rb_define_method(cDuckDBInitInfo, "set_error", rbduckdb_init_info_set_error, 1);
+}

data/ext/duckdb/init_info.h

@@ -0,0 +1,13 @@
+#ifndef RUBY_DUCKDB_INIT_INFO_H
+#define RUBY_DUCKDB_INIT_INFO_H
+
+struct _rubyDuckDBInitInfo {
+    duckdb_init_info info;
+};
+
+typedef struct _rubyDuckDBInitInfo rubyDuckDBInitInfo;
+
+rubyDuckDBInitInfo *get_struct_init_info(VALUE obj);
+void rbduckdb_init_duckdb_init_info(void);
+
+#endif