duckdb 1.1.3.1 → 1.2.1.0

data/ext/duckdb/database.c

@@ -43,6 +43,7 @@ rubyDuckDB *rbduckdb_get_struct_database(VALUE obj) {
     return ctx;
 }
 
+/* :nodoc: */
 static VALUE duckdb_database_s_open(int argc, VALUE *argv, VALUE cDuckDBDatabase) {
     rubyDuckDB *ctx;
     VALUE obj;
@@ -64,6 +65,7 @@ static VALUE duckdb_database_s_open(int argc, VALUE *argv, VALUE cDuckDBDatabase
     return obj;
 }
 
+/* :nodoc: */
 static VALUE duckdb_database_s_open_ext(int argc, VALUE *argv, VALUE cDuckDBDatabase) {
     rubyDuckDB *ctx;
     VALUE obj;
@@ -98,6 +100,7 @@ static VALUE duckdb_database_s_open_ext(int argc, VALUE *argv, VALUE cDuckDBData
     return obj;
 }
 
+/* :nodoc: */
 static VALUE duckdb_database_connect(VALUE self) {
     return rbduckdb_create_connection(self);
 }
@@ -116,6 +119,9 @@ static VALUE duckdb_database_close(VALUE self) {
 }
 
 void rbduckdb_init_duckdb_database(void) {
+#if 0
+    VALUE mDuckDB = rb_define_module("DuckDB");
+#endif
     cDuckDBDatabase = rb_define_class_under(mDuckDB, "Database", rb_cObject);
     rb_define_alloc_func(cDuckDBDatabase, allocate);
     rb_define_singleton_method(cDuckDBDatabase, "_open", duckdb_database_s_open, -1);

data/ext/duckdb/duckdb.c

@@ -31,6 +31,7 @@ Init_duckdb_native(void) {
     rbduckdb_init_duckdb_connection();
     rbduckdb_init_duckdb_result();
     rbduckdb_init_duckdb_column();
+    rbduckdb_init_duckdb_logical_type();
     rbduckdb_init_duckdb_prepared_statement();
     rbduckdb_init_duckdb_pending_result();
     rbduckdb_init_duckdb_blob();

data/ext/duckdb/error.c

@@ -3,5 +3,8 @@
 VALUE eDuckDBError;
 
 void rbduckdb_init_duckdb_error(void) {
+#if 0
+    VALUE mDuckDB = rb_define_module("DuckDB");
+#endif
     eDuckDBError = rb_define_class_under(mDuckDB, "Error", rb_eStandardError);
 }

data/ext/duckdb/extconf.rb

@@ -2,7 +2,7 @@
 
 require 'mkmf'
 
-DUCKDB_REQUIRED_VERSION = '1.0.0'
+DUCKDB_REQUIRED_VERSION = '1.1.0'
 
 def check_duckdb_header(header, version)
   found = find_header(
@@ -56,17 +56,14 @@ end
 dir_config('duckdb')
 
 check_duckdb_header('duckdb.h', DUCKDB_REQUIRED_VERSION)
-check_duckdb_library('duckdb', 'duckdb_appender_column_count', DUCKDB_REQUIRED_VERSION)
-
-# check duckdb >= 1.0.0
-have_func('duckdb_fetch_chunk', 'duckdb.h')
-
-# check duckdb >= 1.0.0
-have_func('duckdb_fetch_chunk', 'duckdb.h')
+check_duckdb_library('duckdb', 'duckdb_result_error_type', DUCKDB_REQUIRED_VERSION)
 
 # check duckdb >= 1.1.0
 have_func('duckdb_result_error_type', 'duckdb.h')
 
+# check duckdb >= 1.2.0
+have_func('duckdb_create_instance_cache', 'duckdb.h')
+
 # Building with enabled DUCKDB_API_NO_DEPRECATED is failed with DuckDB v1.1.0 only.
 # DuckDB v1.1.1 is fixed this issue https://github.com/duckdb/duckdb/issues/13872.
 have_const('DUCKDB_TYPE_SQLNULL', 'duckdb.h')

data/ext/duckdb/extracted_statements.c

@@ -95,6 +95,9 @@ static VALUE duckdb_extracted_statements_prepared_statement(VALUE self, VALUE co
 }
 
 void rbduckdb_init_duckdb_extracted_statements(void) {
+#if 0
+    VALUE mDuckDB = rb_define_module("DuckDB");
+#endif
     cDuckDBExtractedStatements = rb_define_class_under(mDuckDB, "ExtractedStatementsImpl", rb_cObject);
 
     rb_define_alloc_func(cDuckDBExtractedStatements, allocate);

data/ext/duckdb/logical_type.c

@@ -0,0 +1,323 @@
+#include "ruby-duckdb.h"
+
+static VALUE cDuckDBLogicalType;
+
+static void deallocate(void *ctx);
+static VALUE allocate(VALUE klass);
+static size_t memsize(const void *p);
+static VALUE duckdb_logical_type__type(VALUE self);
+static VALUE duckdb_logical_type_width(VALUE self);
+static VALUE duckdb_logical_type_scale(VALUE self);
+static VALUE duckdb_logical_type_child_count(VALUE self);
+static VALUE duckdb_logical_type_child_name_at(VALUE self, VALUE cidx);
+static VALUE duckdb_logical_type_child_type(VALUE self);
+static VALUE duckdb_logical_type_child_type_at(VALUE self, VALUE cidx);
+static VALUE duckdb_logical_type_size(VALUE self);
+static VALUE duckdb_logical_type_key_type(VALUE self);
+static VALUE duckdb_logical_type_value_type(VALUE self);
+static VALUE duckdb_logical_type_member_count(VALUE self);
+static VALUE duckdb_logical_type_member_name_at(VALUE self, VALUE midx);
+static VALUE duckdb_logical_type_member_type_at(VALUE self, VALUE midx);
+
+static const rb_data_type_t logical_type_data_type = {
+    "DuckDB/LogicalType",
+    {NULL, deallocate, memsize,},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static void deallocate(void *ctx) {
+    rubyDuckDBLogicalType *p = (rubyDuckDBLogicalType *)ctx;
+
+    if (p->logical_type) {
+        duckdb_destroy_logical_type(&(p->logical_type));
+    }
+
+    xfree(p);
+}
+
+static VALUE allocate(VALUE klass) {
+    rubyDuckDBLogicalType *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBLogicalType));
+    return TypedData_Wrap_Struct(klass, &logical_type_data_type, ctx);
+}
+
+static size_t memsize(const void *p) {
+    return sizeof(rubyDuckDBLogicalType);
+}
+
+/*
+ *  call-seq:
+ *    decimal_col.logical_type.type -> Symbol
+ *
+ *  Returns the logical type's type symbol.
+ *
+ */
+static VALUE duckdb_logical_type__type(VALUE self) {
+    rubyDuckDBLogicalType *ctx;
+    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
+    return INT2FIX(duckdb_get_type_id(ctx->logical_type));
+}
+
+/*
+ *  call-seq:
+ *    decimal_col.logical_type.width -> Integer
+ *
+ *  Returns the width of the decimal column.
+ *
+ */
+static VALUE duckdb_logical_type_width(VALUE self) {
+    rubyDuckDBLogicalType *ctx;
+    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
+    return INT2FIX(duckdb_decimal_width(ctx->logical_type));
+}
+
+/*
+ *  call-seq:
+ *    decimal_col.logical_type.scale -> Integer
+ *
+ *  Returns the scale of the decimal column.
+ *
+ */
+static VALUE duckdb_logical_type_scale(VALUE self) {
+    rubyDuckDBLogicalType *ctx;
+    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
+    return INT2FIX(duckdb_decimal_scale(ctx->logical_type));
+}
+
+/*
+ *  call-seq:
+ *    struct_col.logical_type.child_count -> Integer
+ *
+ *  Returns the number of children of a struct type, otherwise 0.
+ *
+ */
+static VALUE duckdb_logical_type_child_count(VALUE self) {
+    rubyDuckDBLogicalType *ctx;
+    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
+    return INT2FIX(duckdb_struct_type_child_count(ctx->logical_type));
+}
+
+/*
+ *  call-seq:
+ *    struct_col.logical_type.child_name(index) -> String
+ *
+ *  Returns the name of the struct child at the specified index.
+ *
+ */
+static VALUE duckdb_logical_type_child_name_at(VALUE self, VALUE cidx) {
+    rubyDuckDBLogicalType *ctx;
+    VALUE cname;
+    const char *child_name;
+    idx_t idx = NUM2ULL(cidx);
+
+    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
+
+    child_name = duckdb_struct_type_child_name(ctx->logical_type, idx);
+    if (child_name == NULL) {
+        rb_raise(eDuckDBError, "fail to get name of %llu child", (unsigned long long)idx);
+    }
+    cname = rb_str_new_cstr(child_name);
+    duckdb_free((void *)child_name);
+    return cname;
+}
+
+/*
+ *  call-seq:
+ *    list_col.logical_type.child_type -> DuckDB::LogicalType
+ *
+ *  Returns the child logical type for list and map types, otherwise nil.
+ *
+ */
+static VALUE duckdb_logical_type_child_type(VALUE self) {
+    rubyDuckDBLogicalType *ctx;
+    duckdb_type type_id;
+    duckdb_logical_type child_logical_type;
+    VALUE logical_type = Qnil;
+
+    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
+    type_id = duckdb_get_type_id(ctx->logical_type);
+
+    switch(type_id) {
+        case DUCKDB_TYPE_LIST:
+        case DUCKDB_TYPE_MAP:
+            child_logical_type = duckdb_list_type_child_type(ctx->logical_type);
+            logical_type = rbduckdb_create_logical_type(child_logical_type);
+            break;
+        case DUCKDB_TYPE_ARRAY:
+            child_logical_type = duckdb_array_type_child_type(ctx->logical_type);
+            logical_type = rbduckdb_create_logical_type(child_logical_type);
+            break;
+        default:
+            logical_type = Qnil;
+    }
+    return logical_type;
+}
+
+/*
+ *  call-seq:
+ *    struct_col.logical_type.child_type_at(index) -> DuckDB::LogicalType
+ *
+ *  Returns the child logical type for struct types at the specified index as a
+ *  DuckDB::LogicalType object.
+ *
+ */
+static VALUE duckdb_logical_type_child_type_at(VALUE self, VALUE cidx) {
+    rubyDuckDBLogicalType *ctx;
+    duckdb_logical_type struct_child_type;
+    idx_t idx = NUM2ULL(cidx);
+
+    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
+
+    struct_child_type = duckdb_struct_type_child_type(ctx->logical_type, idx);
+    if (struct_child_type == NULL) {
+        rb_raise(eDuckDBError,
+                 "Failed to get the struct child type at index %llu",
+                 (unsigned long long)idx);
+    }
+
+    return rbduckdb_create_logical_type(struct_child_type);
+}
+
+/*
+ *  call-seq:
+ *    list_col.logical_type.size -> Integer
+ *
+ *  Returns the size of the array column, otherwise 0.
+ *
+ */
+static VALUE duckdb_logical_type_size(VALUE self) {
+    rubyDuckDBLogicalType *ctx;
+    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
+    return INT2FIX(duckdb_array_type_array_size(ctx->logical_type));
+}
+
+/*
+ *  call-seq:
+ *    map_col.logical_type.key_type -> DuckDB::LogicalType
+ *
+ *  Returns the key logical type for map type, otherwise nil.
+ *
+ */
+static VALUE duckdb_logical_type_key_type(VALUE self) {
+    rubyDuckDBLogicalType *ctx;
+    duckdb_logical_type key_logical_type;
+    VALUE logical_type = Qnil;
+
+    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
+    key_logical_type = duckdb_map_type_key_type(ctx->logical_type);
+    logical_type = rbduckdb_create_logical_type(key_logical_type);
+    return logical_type;
+}
+
+/*
+ *  call-seq:
+ *    map_col.logical_type.value_type -> DuckDB::LogicalType
+ *
+ *  Returns the value logical type for map type, otherwise nil.
+ *
+ */
+static VALUE duckdb_logical_type_value_type(VALUE self) {
+    rubyDuckDBLogicalType *ctx;
+    duckdb_logical_type value_logical_type;
+    VALUE logical_type = Qnil;
+
+    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
+    value_logical_type = duckdb_map_type_value_type(ctx->logical_type);
+    logical_type = rbduckdb_create_logical_type(value_logical_type);
+    return logical_type;
+}
+
+/*
+ *  call-seq:
+ *    member_col.logical_type.member_count -> Integer
+ *
+ *  Returns the member count of union type, otherwise 0.
+ *
+ */
+static VALUE duckdb_logical_type_member_count(VALUE self) {
+    rubyDuckDBLogicalType *ctx;
+    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
+    return INT2FIX(duckdb_union_type_member_count(ctx->logical_type));
+}
+
+/*
+ *  call-seq:
+ *    union_col.logical_type.member_name_at(index) -> String
+ *
+ *  Returns the name of the union member at the specified index.
+ *
+ */
+static VALUE duckdb_logical_type_member_name_at(VALUE self, VALUE midx) {
+    rubyDuckDBLogicalType *ctx;
+    VALUE mname;
+    const char *member_name;
+    idx_t idx = NUM2ULL(midx);
+
+    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
+
+    member_name = duckdb_union_type_member_name(ctx->logical_type, idx);
+    if (member_name == NULL) {
+        rb_raise(eDuckDBError, "fail to get name of %llu member", (unsigned long long)idx);
+    }
+    mname = rb_str_new_cstr(member_name);
+    duckdb_free((void *)member_name);
+    return mname;
+}
+
+/*
+ *  call-seq:
+ *    union_col.logical_type.member_type_at(index) -> DuckDB::LogicalType
+ *
+ *  Returns the logical type of the union member at the specified index as a
+ *  DuckDB::LogicalType object.
+ *
+ */
+static VALUE duckdb_logical_type_member_type_at(VALUE self, VALUE midx) {
+    rubyDuckDBLogicalType *ctx;
+    duckdb_logical_type union_member_type;
+    idx_t idx = NUM2ULL(midx);
+
+    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
+
+    union_member_type = duckdb_union_type_member_type(ctx->logical_type, idx);
+    if (union_member_type == NULL) {
+        rb_raise(eDuckDBError,
+                 "Failed to get the union member type at index %llu",
+                 (unsigned long long)idx);
+    }
+
+    return rbduckdb_create_logical_type(union_member_type);
+}
+
+VALUE rbduckdb_create_logical_type(duckdb_logical_type logical_type) {
+    VALUE obj;
+    rubyDuckDBLogicalType *ctx;
+
+    obj = allocate(cDuckDBLogicalType);
+    TypedData_Get_Struct(obj, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
+
+    ctx->logical_type = logical_type;
+
+    return obj;
+}
+
+void rbduckdb_init_duckdb_logical_type(void) {
+#if 0
+    VALUE mDuckDB = rb_define_module("DuckDB");
+#endif
+    cDuckDBLogicalType = rb_define_class_under(mDuckDB, "LogicalType", rb_cObject);
+    rb_define_alloc_func(cDuckDBLogicalType, allocate);
+
+    rb_define_private_method(cDuckDBLogicalType, "_type", duckdb_logical_type__type, 0);
+    rb_define_method(cDuckDBLogicalType, "width", duckdb_logical_type_width, 0);
+    rb_define_method(cDuckDBLogicalType, "scale", duckdb_logical_type_scale, 0);
+    rb_define_method(cDuckDBLogicalType, "child_count", duckdb_logical_type_child_count, 0);
+    rb_define_method(cDuckDBLogicalType, "child_name_at", duckdb_logical_type_child_name_at, 1);
+    rb_define_method(cDuckDBLogicalType, "child_type", duckdb_logical_type_child_type, 0);
+    rb_define_method(cDuckDBLogicalType, "child_type_at", duckdb_logical_type_child_type_at, 1);
+    rb_define_method(cDuckDBLogicalType, "size", duckdb_logical_type_size, 0);
+    rb_define_method(cDuckDBLogicalType, "key_type", duckdb_logical_type_key_type, 0);
+    rb_define_method(cDuckDBLogicalType, "value_type", duckdb_logical_type_value_type, 0);
+    rb_define_method(cDuckDBLogicalType, "member_count", duckdb_logical_type_member_count, 0);
+    rb_define_method(cDuckDBLogicalType, "member_name_at", duckdb_logical_type_member_name_at, 1);
+    rb_define_method(cDuckDBLogicalType, "member_type_at", duckdb_logical_type_member_type_at, 1);
+}

data/ext/duckdb/logical_type.h

@@ -0,0 +1,13 @@
+#ifndef RUBY_DUCKDB_LOGICAL_TYPE_H
+#define RUBY_DUCKDB_LOGICAL_TYPE_H
+
+struct _rubyDuckDBLogicalType {
+    duckdb_logical_type logical_type;
+};
+
+typedef struct _rubyDuckDBLogicalType rubyDuckDBLogicalType;
+
+void rbduckdb_init_duckdb_logical_type(void);
+VALUE rbduckdb_create_logical_type(duckdb_logical_type logical_type);
+
+#endif

data/ext/duckdb/pending_result.c

@@ -124,11 +124,13 @@ static VALUE duckdb_pending_result_execute_pending(VALUE self) {
     return result;
 }
 
+/* :nodoc: */
 static VALUE duckdb_pending_result__state(VALUE self) {
     rubyDuckDBPendingResult *ctx = get_struct_pending_result(self);
     return INT2FIX(ctx->state);
 }
 
+/* :nodoc: */
 static VALUE duckdb_pending_result__execute_check_state(VALUE self) {
     rubyDuckDBPendingResult *ctx = get_struct_pending_result(self);
     return INT2FIX(duckdb_pending_execute_check_state(ctx->pending_result));
@@ -141,6 +143,9 @@ rubyDuckDBPendingResult *get_struct_pending_result(VALUE obj) {
 }
 
 void rbduckdb_init_duckdb_pending_result(void) {
+#if 0
+    VALUE mDuckDB = rb_define_module("DuckDB");
+#endif
     cDuckDBPendingResult = rb_define_class_under(mDuckDB, "PendingResult", rb_cObject);
     rb_define_alloc_func(cDuckDBPendingResult, allocate);
 

data/ext/duckdb/prepared_statement.c

@@ -32,6 +32,7 @@ static VALUE duckdb_prepared_statement__bind_time(VALUE self, VALUE vidx, VALUE
 static VALUE duckdb_prepared_statement__bind_timestamp(VALUE self, VALUE vidx, VALUE year, VALUE month, VALUE day, VALUE hour, VALUE min, VALUE sec, VALUE micros);
 static VALUE duckdb_prepared_statement__bind_interval(VALUE self, VALUE vidx, VALUE months, VALUE days, VALUE micros);
 static VALUE duckdb_prepared_statement__bind_hugeint(VALUE self, VALUE vidx, VALUE lower, VALUE upper);
+static VALUE duckdb_prepared_statement__bind_uhugeint(VALUE self, VALUE vidx, VALUE lower, VALUE upper);
 static VALUE duckdb_prepared_statement__bind_decimal(VALUE self, VALUE vidx, VALUE lower, VALUE upper, VALUE width, VALUE scale);
 
 static const rb_data_type_t prepared_statement_data_type = {
@@ -102,21 +103,49 @@ static VALUE duckdb_prepared_statement_nparams(VALUE self) {
     return ULL2NUM(duckdb_nparams(ctx->prepared_statement));
 }
 
+/* :nodoc: */
+typedef struct {
+    duckdb_prepared_statement prepared_statement;
+    duckdb_result *out_result;
+    duckdb_state retval;
+} duckdb_prepared_statement_execute_nogvl_args;
+
+/* :nodoc: */
+static void duckdb_prepared_statement_execute_nogvl(void *ptr) {
+    duckdb_prepared_statement_execute_nogvl_args *args = (duckdb_prepared_statement_execute_nogvl_args *)ptr;
+
+    args->retval = duckdb_execute_prepared(args->prepared_statement, args->out_result);
+}
+
 static VALUE duckdb_prepared_statement_execute(VALUE self) {
     rubyDuckDBPreparedStatement *ctx;
     rubyDuckDBResult *ctxr;
+    const char *error;
     VALUE result = rbduckdb_create_result();
-    const char *p = NULL;
+    VALUE msg;
 
     TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
     ctxr = get_struct_result(result);
-    if (duckdb_execute_prepared(ctx->prepared_statement, &(ctxr->result)) == DuckDBError) {
-        p = duckdb_result_error(&(ctxr->result));
-        if (p == NULL) {
-            p = duckdb_prepare_error(ctx->prepared_statement);
+
+    duckdb_prepared_statement_execute_nogvl_args args = {
+        .prepared_statement = ctx->prepared_statement,
+        .out_result = &(ctxr->result),
+        .retval = DuckDBError,
+    };
+
+    rb_thread_call_without_gvl((void *)duckdb_prepared_statement_execute_nogvl, &args, RUBY_UBF_IO, 0);
+    duckdb_state state = args.retval;
+
+    if (state == DuckDBError) {
+        error = duckdb_prepare_error(args.prepared_statement);
+        if (error == NULL) {
+            error = duckdb_result_error(args.out_result);
         }
-        rb_raise(eDuckDBError, "%s", p ? p : "Failed to execute prepared statement.");
+        msg = rb_str_new2(error ? error : "Failed to execute prepared statement.");
+
+        rb_raise(eDuckDBError, "%s", StringValuePtr(msg));
     }
+
     return result;
 }
 
@@ -316,18 +345,21 @@ static VALUE duckdb_prepared_statement_bind_null(VALUE self, VALUE vidx) {
     return self;
 }
 
+/* :nodoc: */
 static VALUE duckdb_prepared_statement__statement_type(VALUE self) {
     rubyDuckDBPreparedStatement *ctx;
     TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
     return INT2FIX(duckdb_prepared_statement_type(ctx->prepared_statement));
 }
 
+/* :nodoc: */
 static VALUE duckdb_prepared_statement__param_type(VALUE self, VALUE vidx) {
     rubyDuckDBPreparedStatement *ctx;
     TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
     return INT2FIX(duckdb_param_type(ctx->prepared_statement, NUM2ULL(vidx)));
 }
 
+/* :nodoc: */
 static VALUE duckdb_prepared_statement__bind_date(VALUE self, VALUE vidx, VALUE year, VALUE month, VALUE day) {
     rubyDuckDBPreparedStatement *ctx;
     duckdb_date dt;
@@ -344,6 +376,7 @@ static VALUE duckdb_prepared_statement__bind_date(VALUE self, VALUE vidx, VALUE
     return self;
 }
 
+/* :nodoc: */
 static VALUE duckdb_prepared_statement__bind_time(VALUE self, VALUE vidx, VALUE hour, VALUE min, VALUE sec, VALUE micros){
     rubyDuckDBPreparedStatement *ctx;
     duckdb_time time;
@@ -361,6 +394,7 @@ static VALUE duckdb_prepared_statement__bind_time(VALUE self, VALUE vidx, VALUE
     return self;
 }
 
+/* :nodoc: */
 static VALUE duckdb_prepared_statement__bind_timestamp(VALUE self, VALUE vidx, VALUE year, VALUE month, VALUE day, VALUE hour, VALUE min, VALUE sec, VALUE micros) {
     duckdb_timestamp timestamp;
     rubyDuckDBPreparedStatement *ctx;
@@ -375,6 +409,7 @@ static VALUE duckdb_prepared_statement__bind_timestamp(VALUE self, VALUE vidx, V
     return self;
 }
 
+/* :nodoc: */
 static VALUE duckdb_prepared_statement__bind_interval(VALUE self, VALUE vidx, VALUE months, VALUE days, VALUE micros) {
     duckdb_interval interval;
     rubyDuckDBPreparedStatement *ctx;
@@ -390,6 +425,7 @@ static VALUE duckdb_prepared_statement__bind_interval(VALUE self, VALUE vidx, VA
     return self;
 }
 
+/* :nodoc: */
 static VALUE duckdb_prepared_statement__bind_hugeint(VALUE self, VALUE vidx, VALUE lower, VALUE upper) {
     duckdb_hugeint hugeint;
     rubyDuckDBPreparedStatement *ctx;
@@ -406,6 +442,24 @@ static VALUE duckdb_prepared_statement__bind_hugeint(VALUE self, VALUE vidx, VAL
     return self;
 }
 
+/* :nodoc: */
+static VALUE duckdb_prepared_statement__bind_uhugeint(VALUE self, VALUE vidx, VALUE lower, VALUE upper) {
+    duckdb_uhugeint uhugeint;
+    rubyDuckDBPreparedStatement *ctx;
+    idx_t idx = check_index(vidx);
+
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
+    uhugeint.lower = NUM2ULL(lower);
+    uhugeint.upper = NUM2ULL(upper);
+
+    if (duckdb_bind_uhugeint(ctx->prepared_statement, idx, uhugeint) == DuckDBError) {
+        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
+    }
+
+    return self;
+}
+
+/* :nodoc: */
 static VALUE duckdb_prepared_statement__bind_decimal(VALUE self, VALUE vidx, VALUE lower, VALUE upper, VALUE width, VALUE scale) {
     duckdb_hugeint hugeint;
     duckdb_decimal decimal;
@@ -433,6 +487,9 @@ rubyDuckDBPreparedStatement *get_struct_prepared_statement(VALUE self) {
 }
 
 void rbduckdb_init_duckdb_prepared_statement(void) {
+#if 0
+    VALUE mDuckDB = rb_define_module("DuckDB");
+#endif
     cDuckDBPreparedStatement = rb_define_class_under(mDuckDB, "PreparedStatement", rb_cObject);
 
     rb_define_alloc_func(cDuckDBPreparedStatement, allocate);
@@ -461,5 +518,6 @@ void rbduckdb_init_duckdb_prepared_statement(void) {
     rb_define_private_method(cDuckDBPreparedStatement, "_bind_timestamp", duckdb_prepared_statement__bind_timestamp, 8);
     rb_define_private_method(cDuckDBPreparedStatement, "_bind_interval", duckdb_prepared_statement__bind_interval, 4);
     rb_define_private_method(cDuckDBPreparedStatement, "_bind_hugeint", duckdb_prepared_statement__bind_hugeint, 3);
+    rb_define_private_method(cDuckDBPreparedStatement, "_bind_uhugeint", duckdb_prepared_statement__bind_uhugeint, 3);
     rb_define_private_method(cDuckDBPreparedStatement, "_bind_decimal", duckdb_prepared_statement__bind_decimal, 5);
 }