duckdb 1.2.0.0 → 1.2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ed07310471afbddcd5b4facd1720eeae0868af7d2682754a30361bafdf45b5a
-  data.tar.gz: 984fd1ac1d47a72c0d20a2b1225656baf8838a47c70c3edc54d58bde0490cf25
+  metadata.gz: d8003b16f724b8a5c4863dbc507476601992e002767aa3cf7cfd7d87583265bc
+  data.tar.gz: a82ef0f5617349c568dd2be3cb8ad1deb5bdee8796483e376eaabc266232f280
 SHA512:
-  metadata.gz: 5e85e65243f72ac9d1d8bab1ec44a18b7ac31dccba3cfd12dc81c075f44ea79592b7357dde7f30b4276fda2eee769aa93986ca216061ea2aa497a7e7038872df
-  data.tar.gz: ee8db3baf4385b71e4c4d4765200baacef1df273702281e33809d2b4037bc25b4bae008e0501c178f615ba22f5a1b99021a22d15d5982054dbe675a769ca1cd8
+  metadata.gz: 8220ad5939d4c60819636488a783118ba8040429348ad157515ea1801fe9462ad20e2fff12440ce3e1ffae642f3d6fca0a02b43b4ed8958a105cfd079f85de47
+  data.tar.gz: f221a85106b80b654750faeb855c51ff760d82082cb86d7c77834c20194ab71b21feff55d883f1d2d13b1dac699bb50ff6fc5473a04db0e50f4dbbfcb1cd5d22

data/.github/workflows/test_on_macos.yml

@@ -15,8 +15,8 @@ jobs:
     runs-on: macos-latest
     strategy:
       matrix:
-        ruby: ['3.1.6', '3.2.6', '3.3.6', '3.4.2', 'head']
-        duckdb: ['1.2.0', '1.1.3', '1.1.1', '1.0.0']
+        ruby: ['3.1.6', '3.2.7', '3.3.7', '3.4.2', 'head']
+        duckdb: ['1.2.1', '1.1.3', '1.1.1']
 
     steps:
     - uses: actions/checkout@v4

data/.github/workflows/test_on_ubuntu.yml

@@ -15,8 +15,8 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby: ['3.1.6', '3.2.6', '3.3.6', '3.4.2', 'head']
-        duckdb: ['1.2.0', '1.1.3', '1.1.1', '1.0.0']
+        ruby: ['3.1.6', '3.2.7', '3.3.7', '3.4.2', 'head']
+        duckdb: ['1.2.1', '1.1.3', '1.1.1']
 
     steps:
     - uses: actions/checkout@v4

data/.github/workflows/test_on_windows.yml

@@ -16,7 +16,7 @@ jobs:
     strategy:
       matrix:
         ruby: ['3.1.6', '3.2.6', '3.3.6', '3.4.1', 'ucrt', 'mingw', 'mswin', 'head']
-        duckdb: ['1.2.0', '1.1.3', '1.1.1', '1.0.0']
+        duckdb: ['1.2.1', '1.1.3', '1.1.1']
 
     steps:
     - uses: actions/checkout@v4

data/CHANGELOG.md

@@ -3,6 +3,24 @@
 All notable changes to this project will be documented in this file.
 # Unreleased
 
+# 1.2.1.0 - 2025-03-30
+- bump duckdb v1.2.1 on CI.
+- drop duckdb v1.0.0.
+- add `DuckDB::LogicalType` class.
+  - `DuckDB::LogicalType` class is under construction. `DuckDB::LogicalType#member_count`,
+    `DuckDB::LogicalType#member_name_at`, `DuckDB::LogicalType#member_type_at`,
+    `DuckDB::LogicalType#each_member_name`, `DuckDB::LogicalType#each_member_type`,
+    `DuckDB::LogicalType#child_count`, `DuckDB::LogicalType#child_name_at`,
+    `DuckDB::LogicalType#child_type_at`, `DuckDB::LogicalType#each_child_name`, and
+    `DuckDB::LogicalType#each_child_type` are available.
+- fix error message when `DuckDB::Appender#append_uint16`, `DuckDB::Appender#append_uint32`,
+  `DuckDB::Appender#append_uint64`, `DuckDB::Appender#append_float`, `DuckDB::Appender#append_double`,
+  `DuckDB::Appender#append_varchar`, `DuckDB::Appender#append_varchar_length`,
+  `DuckDB::Appender#append_blob`, `DuckDB::Appender#append_null`, `DuckDB::Appender#append_default`,
+  `DuckDB::Appender#append_date`, `DuckDB::Appender#append_interval`, `DuckDB::Appender#append_time`,
+  `DuckDB::Appender#append_timestamp`, `DuckDB::Appender#append_hugeint` failed.
+- add `DuckDB::PreparedStatement#bind_uhugeint`.
+
 # 1.2.0.0 - 2025-02-24
 - bump duckdb to 1.2.0.
 - add `DuckDB::LogicalType` class(Thanks to @otegami).

data/Dockerfile

@@ -1,7 +1,7 @@
 ARG RUBY_VERSION=3.4.2
 FROM ruby:${RUBY_VERSION}
 
-ARG DUCKDB_VERSION=1.2.0
+ARG DUCKDB_VERSION=1.2.1
 ARG VALGRIND_VERSION=3.21.0
 
 RUN apt update -qq && \

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    duckdb (1.2.0.0)
+    duckdb (1.2.1.0)
       bigdecimal (>= 3.1.4)
 
 GEM
@@ -10,19 +10,19 @@ GEM
     benchmark-ips (2.14.0)
     bigdecimal (3.1.9)
     mini_portile2 (2.8.8)
-    minitest (5.25.4)
-    nokogiri (1.18.3)
+    minitest (5.25.5)
+    nokogiri (1.18.6)
       mini_portile2 (~> 2.8.2)
       racc (~> 1.4)
-    nokogiri (1.18.3-aarch64-linux-gnu)
+    nokogiri (1.18.6-aarch64-linux-gnu)
       racc (~> 1.4)
-    nokogiri (1.18.3-arm-linux-gnu)
+    nokogiri (1.18.6-arm-linux-gnu)
       racc (~> 1.4)
-    nokogiri (1.18.3-arm64-darwin)
+    nokogiri (1.18.6-arm64-darwin)
       racc (~> 1.4)
-    nokogiri (1.18.3-x86_64-darwin)
+    nokogiri (1.18.6-x86_64-darwin)
       racc (~> 1.4)
-    nokogiri (1.18.3-x86_64-linux-gnu)
+    nokogiri (1.18.6-x86_64-linux-gnu)
       racc (~> 1.4)
     racc (1.8.1)
     rake (13.2.1)

data/ext/duckdb/appender.c

@@ -13,20 +13,16 @@ static VALUE appender__append_int16(VALUE self, VALUE val);
 static VALUE appender__append_int32(VALUE self, VALUE val);
 static VALUE appender__append_int64(VALUE self, VALUE val);
 static VALUE appender__append_uint8(VALUE self, VALUE val);
-static VALUE appender_append_uint16(VALUE self, VALUE val);
-static VALUE appender_append_uint32(VALUE self, VALUE val);
-static VALUE appender_append_uint64(VALUE self, VALUE val);
-static VALUE appender_append_float(VALUE self, VALUE val);
-static VALUE appender_append_double(VALUE self, VALUE val);
-static VALUE appender_append_varchar(VALUE self, VALUE val);
-static VALUE appender_append_varchar_length(VALUE self, VALUE val, VALUE len);
-static VALUE appender_append_blob(VALUE self, VALUE val);
-static VALUE appender_append_null(VALUE self);
-
-#ifdef HAVE_DUCKDB_H_GE_V1_1_0
-static VALUE appender_append_default(VALUE self);
-#endif
-
+static VALUE appender__append_uint16(VALUE self, VALUE val);
+static VALUE appender__append_uint32(VALUE self, VALUE val);
+static VALUE appender__append_uint64(VALUE self, VALUE val);
+static VALUE appender__append_float(VALUE self, VALUE val);
+static VALUE appender__append_double(VALUE self, VALUE val);
+static VALUE appender__append_varchar(VALUE self, VALUE val);
+static VALUE appender__append_varchar_length(VALUE self, VALUE val, VALUE len);
+static VALUE appender__append_blob(VALUE self, VALUE val);
+static VALUE appender__append_null(VALUE self);
+static VALUE appender__append_default(VALUE self);
 static VALUE appender__end_row(VALUE self);
 static VALUE appender__append_date(VALUE self, VALUE yearval, VALUE monthval, VALUE dayval);
 static VALUE appender__append_interval(VALUE self, VALUE months, VALUE days, VALUE micros);
@@ -177,79 +173,68 @@ static VALUE appender__append_uint8(VALUE self, VALUE val) {
     return duckdb_state_to_bool_value(duckdb_append_uint8(ctx->appender, ui8val));
 }
 
-static VALUE appender_append_uint16(VALUE self, VALUE val) {
+/* :nodoc: */
+static VALUE appender__append_uint16(VALUE self, VALUE val) {
     rubyDuckDBAppender *ctx;
     uint16_t ui16val = (uint16_t)NUM2UINT(val);
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    if (duckdb_append_uint16(ctx->appender, ui16val) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to append uint16");
-    }
-    return self;
+    return  duckdb_state_to_bool_value(duckdb_append_uint16(ctx->appender, ui16val));
 }
 
-static VALUE appender_append_uint32(VALUE self, VALUE val) {
+/* :nodoc: */
+static VALUE appender__append_uint32(VALUE self, VALUE val) {
     rubyDuckDBAppender *ctx;
     uint32_t ui32val = (uint32_t)NUM2UINT(val);
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    if (duckdb_append_uint32(ctx->appender, ui32val) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to append uint32");
-    }
-    return self;
+    return  duckdb_state_to_bool_value(duckdb_append_uint32(ctx->appender, ui32val));
 }
 
-static VALUE appender_append_uint64(VALUE self, VALUE val) {
+/* :nodoc: */
+static VALUE appender__append_uint64(VALUE self, VALUE val) {
     rubyDuckDBAppender *ctx;
     uint64_t ui64val = (uint64_t)NUM2ULL(val);
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    if (duckdb_append_uint64(ctx->appender, ui64val) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to append uint64");
-    }
-    return self;
+    return duckdb_state_to_bool_value(duckdb_append_uint64(ctx->appender, ui64val));
 }
 
-static VALUE appender_append_float(VALUE self, VALUE val) {
+/* :nodoc: */
+static VALUE appender__append_float(VALUE self, VALUE val) {
     rubyDuckDBAppender *ctx;
     float fval = (float)NUM2DBL(val);
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    if (duckdb_append_float(ctx->appender, fval) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to append float");
-    }
-    return self;
+    return duckdb_state_to_bool_value(duckdb_append_float(ctx->appender, fval));
 }
 
-static VALUE appender_append_double(VALUE self, VALUE val) {
+/* :nodoc: */
+static VALUE appender__append_double(VALUE self, VALUE val) {
     rubyDuckDBAppender *ctx;
     double dval = NUM2DBL(val);
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    if (duckdb_append_double(ctx->appender, dval) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to append double");
-    }
-    return self;
+    return duckdb_state_to_bool_value(duckdb_append_double(ctx->appender, dval));
 }
 
-static VALUE appender_append_varchar(VALUE self, VALUE val) {
+/* :nodoc: */
+static VALUE appender__append_varchar(VALUE self, VALUE val) {
     rubyDuckDBAppender *ctx;
     char *pval = StringValuePtr(val);
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    if (duckdb_append_varchar(ctx->appender, pval) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to append varchar");
-    }
-    return self;
+    return duckdb_state_to_bool_value(duckdb_append_varchar(ctx->appender, pval));
 }
 
-static VALUE appender_append_varchar_length(VALUE self, VALUE val, VALUE len) {
+/* :nodoc: */
+static VALUE appender__append_varchar_length(VALUE self, VALUE val, VALUE len) {
     rubyDuckDBAppender *ctx;
 
     char *pval = StringValuePtr(val);
@@ -257,13 +242,11 @@ static VALUE appender_append_varchar_length(VALUE self, VALUE val, VALUE len) {
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    if (duckdb_append_varchar_length(ctx->appender, pval, length) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to append varchar with length");
-    }
-    return self;
+    return duckdb_state_to_bool_value(duckdb_append_varchar_length(ctx->appender, pval, length));
 }
 
-static VALUE appender_append_blob(VALUE self, VALUE val) {
+/* :nodoc: */
+static VALUE appender__append_blob(VALUE self, VALUE val) {
     rubyDuckDBAppender *ctx;
 
     char *pval = StringValuePtr(val);
@@ -271,33 +254,24 @@ static VALUE appender_append_blob(VALUE self, VALUE val) {
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    if (duckdb_append_blob(ctx->appender, (void *)pval, length) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to append blob");
-    }
-    return self;
+    return duckdb_state_to_bool_value(duckdb_append_blob(ctx->appender, (void *)pval, length));
 }
 
-static VALUE appender_append_null(VALUE self) {
+/* :nodoc: */
+static VALUE appender__append_null(VALUE self) {
     rubyDuckDBAppender *ctx;
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    if (duckdb_append_null(ctx->appender) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to append null");
-    }
-    return self;
+    return duckdb_state_to_bool_value(duckdb_append_null(ctx->appender));
 }
 
-#ifdef HAVE_DUCKDB_H_GE_V1_1_0
-static VALUE appender_append_default(VALUE self) {
+/* :nodoc: */
+static VALUE appender__append_default(VALUE self) {
     rubyDuckDBAppender *ctx;
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
 
-    if (duckdb_append_default(ctx->appender) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to append default");
-    }
-    return self;
+    return duckdb_state_to_bool_value(duckdb_append_default(ctx->appender));
 }
-#endif
 
 /* :nodoc: */
 static VALUE appender__append_date(VALUE self, VALUE year, VALUE month, VALUE day) {
@@ -307,10 +281,7 @@ static VALUE appender__append_date(VALUE self, VALUE year, VALUE month, VALUE da
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
     dt = rbduckdb_to_duckdb_date_from_value(year, month, day);
 
-    if (duckdb_append_date(ctx->appender, dt) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to append date");
-    }
-    return self;
+    return duckdb_state_to_bool_value(duckdb_append_date(ctx->appender, dt));
 }
 
 /* :nodoc: */
@@ -321,10 +292,7 @@ static VALUE appender__append_interval(VALUE self, VALUE months, VALUE days, VAL
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
     rbduckdb_to_duckdb_interval_from_value(&interval, months, days, micros);
 
-    if (duckdb_append_interval(ctx->appender, interval) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to append interval");
-    }
-    return self;
+    return duckdb_state_to_bool_value(duckdb_append_interval(ctx->appender, interval));
 }
 
 /* :nodoc: */
@@ -335,10 +303,7 @@ static VALUE appender__append_time(VALUE self, VALUE hour, VALUE min, VALUE sec,
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
     time = rbduckdb_to_duckdb_time_from_value(hour, min, sec, micros);
 
-    if (duckdb_append_time(ctx->appender, time) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to append time");
-    }
-    return self;
+    return duckdb_state_to_bool_value(duckdb_append_time(ctx->appender, time));
 }
 
 /* :nodoc: */
@@ -351,10 +316,7 @@ static VALUE appender__append_timestamp(VALUE self, VALUE year, VALUE month, VAL
 
     timestamp = rbduckdb_to_duckdb_timestamp_from_value(year, month, day, hour, min, sec, micros);
 
-    if (duckdb_append_timestamp(ctx->appender, timestamp) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to append timestamp");
-    }
-    return self;
+    return duckdb_state_to_bool_value(duckdb_append_timestamp(ctx->appender, timestamp));
 }
 
 /* :nodoc: */
@@ -367,10 +329,8 @@ static VALUE appender__append_hugeint(VALUE self, VALUE lower, VALUE upper) {
     rubyDuckDBAppender *ctx;
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
-    if (duckdb_append_hugeint(ctx->appender, hugeint) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to append hugeint");
-    }
-    return self;
+
+    return duckdb_state_to_bool_value(duckdb_append_hugeint(ctx->appender, hugeint));
 }
 
 /* :nodoc: */
@@ -383,10 +343,8 @@ static VALUE appender__append_uhugeint(VALUE self, VALUE lower, VALUE upper) {
     rubyDuckDBAppender *ctx;
 
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
-    if (duckdb_append_uhugeint(ctx->appender, uhugeint) == DuckDBError) {
-        rb_raise(eDuckDBError, "failed to append uhugeint");
-    }
-    return self;
+
+    return duckdb_state_to_bool_value(duckdb_append_uhugeint(ctx->appender, uhugeint));
 }
 
 /* :nodoc: */
@@ -420,20 +378,6 @@ void rbduckdb_init_duckdb_appender(void) {
     rb_define_alloc_func(cDuckDBAppender, allocate);
     rb_define_method(cDuckDBAppender, "initialize", appender_initialize, 3);
     rb_define_method(cDuckDBAppender, "error_message", appender_error_message, 0);
-    rb_define_method(cDuckDBAppender, "append_uint16", appender_append_uint16, 1);
-    rb_define_method(cDuckDBAppender, "append_uint32", appender_append_uint32, 1);
-    rb_define_method(cDuckDBAppender, "append_uint64", appender_append_uint64, 1);
-    rb_define_method(cDuckDBAppender, "append_float", appender_append_float, 1);
-    rb_define_method(cDuckDBAppender, "append_double", appender_append_double, 1);
-    rb_define_method(cDuckDBAppender, "append_varchar", appender_append_varchar, 1);
-    rb_define_method(cDuckDBAppender, "append_varchar_length", appender_append_varchar_length, 2);
-    rb_define_method(cDuckDBAppender, "append_blob", appender_append_blob, 1);
-    rb_define_method(cDuckDBAppender, "append_null", appender_append_null, 0);
-
-#ifdef HAVE_DUCKDB_H_GE_V1_1_0
-    rb_define_method(cDuckDBAppender, "append_default", appender_append_default, 0);
-#endif
-
     rb_define_private_method(cDuckDBAppender, "_end_row", appender__end_row, 0);
     rb_define_private_method(cDuckDBAppender, "_flush", appender__flush, 0);
     rb_define_private_method(cDuckDBAppender, "_close", appender__close, 0);
@@ -443,6 +387,16 @@ void rbduckdb_init_duckdb_appender(void) {
     rb_define_private_method(cDuckDBAppender, "_append_int32", appender__append_int32, 1);
     rb_define_private_method(cDuckDBAppender, "_append_int64", appender__append_int64, 1);
     rb_define_private_method(cDuckDBAppender, "_append_uint8", appender__append_uint8, 1);
+    rb_define_private_method(cDuckDBAppender, "_append_uint16", appender__append_uint16, 1);
+    rb_define_private_method(cDuckDBAppender, "_append_uint32", appender__append_uint32, 1);
+    rb_define_private_method(cDuckDBAppender, "_append_uint64", appender__append_uint64, 1);
+    rb_define_private_method(cDuckDBAppender, "_append_float", appender__append_float, 1);
+    rb_define_private_method(cDuckDBAppender, "_append_double", appender__append_double, 1);
+    rb_define_private_method(cDuckDBAppender, "_append_varchar", appender__append_varchar, 1);
+    rb_define_private_method(cDuckDBAppender, "_append_varchar_length", appender__append_varchar_length, 2);
+    rb_define_private_method(cDuckDBAppender, "_append_blob", appender__append_blob, 1);
+    rb_define_private_method(cDuckDBAppender, "_append_null", appender__append_null, 0);
+    rb_define_private_method(cDuckDBAppender, "_append_default", appender__append_default, 0);
     rb_define_private_method(cDuckDBAppender, "_append_date", appender__append_date, 3);
     rb_define_private_method(cDuckDBAppender, "_append_interval", appender__append_interval, 3);
     rb_define_private_method(cDuckDBAppender, "_append_time", appender__append_time, 4);

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,14 +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_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/logical_type.c

@@ -8,10 +8,16 @@ 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",
@@ -77,6 +83,43 @@ static VALUE duckdb_logical_type_scale(VALUE self) {
     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
@@ -109,6 +152,31 @@ static VALUE duckdb_logical_type_child_type(VALUE self) {
     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
@@ -158,6 +226,68 @@ static VALUE duckdb_logical_type_value_type(VALUE self) {
     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;
@@ -180,8 +310,14 @@ void rbduckdb_init_duckdb_logical_type(void) {
     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/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 = {
@@ -121,6 +122,7 @@ static VALUE duckdb_prepared_statement_execute(VALUE self) {
     rubyDuckDBResult *ctxr;
     const char *error;
     VALUE result = rbduckdb_create_result();
+    VALUE msg;
 
     TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
     ctxr = get_struct_result(result);
@@ -135,12 +137,13 @@ static VALUE duckdb_prepared_statement_execute(VALUE self) {
     duckdb_state state = args.retval;
 
     if (state == DuckDBError) {
-        error = duckdb_result_error(args.out_result);
+        error = duckdb_prepare_error(args.prepared_statement);
         if (error == NULL) {
-            error = duckdb_prepare_error(args.prepared_statement);
+            error = duckdb_result_error(args.out_result);
         }
+        msg = rb_str_new2(error ? error : "Failed to execute prepared statement.");
 
-        rb_raise(eDuckDBError, "%s", error ? error : "Failed to execute prepared statement.");
+        rb_raise(eDuckDBError, "%s", StringValuePtr(msg));
     }
 
     return result;
@@ -439,6 +442,23 @@ 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;
@@ -498,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);
 }

data/ext/duckdb/result.c

@@ -279,7 +279,7 @@ static VALUE duckdb_result__return_type(VALUE oDuckDBResult) {
 /*
  * remove this #if ... #else statement when dropping duckdb 1.1.0.
  */
-#if !defined(HAVE_DUCKDB_H_GE_V1_1_1) && defined(HAVE_DUCKDB_H_GE_V1_1_0) && defined(DUCKDB_API_NO_DEPRECATED)
+#if !defined(HAVE_DUCKDB_H_GE_V1_1_1) && defined(DUCKDB_API_NO_DEPRECATED)
     rb_raise(eDuckDBError, "duckdb_result_return_type C-API is not available with duckdb v1.1.0 with enabled DUCKDB_API_NO_DEPRECATED.");
 #else
     return INT2FIX(duckdb_result_return_type(ctx->result));

data/ext/duckdb/ruby-duckdb.h

@@ -8,18 +8,14 @@
 #include "ruby/thread.h"
 #include <duckdb.h>
 
-#ifdef HAVE_DUCKDB_FETCH_CHUNK
-#define HAVE_DUCKDB_H_GE_V1_0_0 1
-#endif
-
-#ifdef HAVE_DUCKDB_RESULT_ERROR_TYPE
-#define HAVE_DUCKDB_H_GE_V1_1_0 1
-#endif
-
 #ifdef HAVE_CONST_DUCKDB_TYPE_SQLNULL
 #define HAVE_DUCKDB_H_GE_V1_1_1 1
 #endif
 
+#ifdef HAVE_DUCKDB_CREATE_INSTANCE_CACHE
+#define HAVE_DUCKDB_H_GE_V1_2_0 1
+#endif
+
 #include "./error.h"
 #include "./database.h"
 #include "./connection.h"

data/lib/duckdb/appender.rb

@@ -203,27 +203,235 @@ module DuckDB
     end
 
     # call-seq:
-    #  appender.append_uint8(val) -> self
+    #   appender.append_uint8(val) -> self
     #
     # Appends an uint8 value to the current row in the appender.
     #
-    #  require 'duckdb'
-    #  db = DuckDB::Database.open
-    #  con = db.connect
-    #  con.query('CREATE TABLE users (id INTEGER, age UTINYINT)')
-    #  appender = con.appender('users')
-    #  appender
-    #    .append_int32(1)
-    #    .append_uint8(20)
-    #    .end_row
-    #    .flush
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open
+    #   con = db.connect
+    #   con.query('CREATE TABLE users (id INTEGER, age UTINYINT)')
+    #   appender = con.appender('users')
+    #   appender
+    #     .append_int32(1)
+    #     .append_uint8(20)
+    #     .end_row
+    #     .flush
     def append_uint8(value)
       return self if _append_uint8(value)
 
       raise_appender_error('failed to append_uint8')
     end
 
-    # appends huge int value.
+    # call-seq:
+    #   appender.append_uint16(val) -> self
+    #
+    # Appends an uint16 value to the current row in the appender.
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open
+    #   con = db.connect
+    #   con.query('CREATE TABLE users (id INTEGER, age USMALLINT)')
+    #   appender = con.appender('users')
+    #   appender
+    #     .append_int32(1)
+    #     .append_uint16(20)
+    #     .end_row
+    #     .flush
+    def append_uint16(value)
+      return self if _append_uint16(value)
+
+      raise_appender_error('failed to append_uint16')
+    end
+
+    # call-seq:
+    #   appender.append_uint32(val) -> self
+    #
+    # Appends an uint32 value to the current row in the appender.
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open
+    #   con = db.connect
+    #   con.query('CREATE TABLE users (id INTEGER, age UINTEGER)')
+    #   appender = con.appender('users')
+    #   appender
+    #     .append_int32(1)
+    #     .append_uint32(20)
+    #     .end_row
+    #     .flush
+    def append_uint32(value)
+      return self if _append_uint32(value)
+
+      raise_appender_error('failed to append_uint32')
+    end
+
+    # call-seq:
+    #   appender.append_uint64(val) -> self
+    #
+    # Appends an uint64 value to the current row in the appender.
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open
+    #   con = db.connect
+    #   con.query('CREATE TABLE users (id INTEGER, age UBIGINT)')
+    #   appender = con.appender('users')
+    #   Appender
+    #     .append_int32(1)
+    #     .append_uint64(20)
+    #     .end_row
+    #     .flush
+    def append_uint64(value)
+      return self if _append_uint64(value)
+
+      raise_appender_error('failed to append_uint64')
+    end
+
+    # call-seq:
+    #   appender.append_float(val) -> self
+    #
+    # Appends a float value to the current row in the appender.
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open
+    #   con = db.connect
+    #   con.query('CREATE TABLE numbers (num FLOAT)')
+    #   appender = con.appender('numbers')
+    #   appender
+    #     .append_float(1.23)
+    #     .end_row
+    #     .flush
+    def append_float(value)
+      return self if _append_float(value)
+
+      raise_appender_error('failed to append_float')
+    end
+
+    # call-seq:
+    #   appender.append_double(val) -> self
+    #
+    # Appends a double value to the current row in the appender.
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open
+    #   con = db.connect
+    #   con.query('CREATE TABLE numbers (num DOUBLE)')
+    #   appender = con.appender('numbers')
+    #   appender
+    #     .append_double(1.23)
+    #     .end_row
+    #     .flush
+    def append_double(value)
+      return self if _append_double(value)
+
+      raise_appender_error('failed to append_double')
+    end
+
+    # call-seq:
+    #   appender.append_varchar(val) -> self
+    #
+    # Appends a varchar value to the current row in the appender.
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open
+    #   con = db.connect
+    #   con.query('CREATE TABLE names (name VARCHAR)')
+    #   appender = con.appender('names')
+    #   appender
+    #     .append_varchar('Alice')
+    #     .end_row
+    #     .flush
+    def append_varchar(value)
+      return self if _append_varchar(value)
+
+      raise_appender_error('failed to append_varchar')
+    end
+
+    # call-seq:
+    #   appender.append_varchar_length(val, len) -> self
+    #
+    # Appends a varchar value to the current row in the appender.
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open
+    #   con = db.connect
+    #   con.query('CREATE TABLE names (name VARCHAR)')
+    #   appender = con.appender('names')
+    #   appender
+    #     .append_varchar_length('Alice', 5)
+    #     .end_row
+    #     .flush
+    def append_varchar_length(value, length)
+      return self if _append_varchar_length(value, length)
+
+      raise_appender_error('failed to append_varchar_length')
+    end
+
+    # call-seq:
+    #   appender.append_blob(val) -> self
+    #
+    # Appends a varchar value to the current row in the appender.
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open
+    #   con = db.connect
+    #   con.query('CREATE TABLE values (value BLOB)')
+    #   appender = con.appender('values')
+    #   appender
+    #     .append('\0\1\2\3\4\5'.encode(Encoding::BINARY))
+    #     .end_row
+    #     .flush
+    def append_blob(value)
+      return self if _append_blob(value)
+
+      raise_appender_error('failed to append_blob')
+    end
+
+    # call-seq:
+    #   appender.append_null -> self
+    #
+    # Appends a NULL value to the current row in the appender.
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open
+    #   con = db.connect
+    #   con.query('CREATE TABLE values (value INTEGER)')
+    #   appender = con.appender('values')
+    #   appender
+    #     .append_null
+    #     .end_row
+    #     .flush
+    def append_null
+      return self if _append_null
+
+      raise_appender_error('failed to append_null')
+    end
+
+    # call-seq:
+    #   appender.append_default -> self
+    #
+    # Appends a default value to the current row in the appender.
+    # If the column does not have a default value, this method
+    # appends a NULL value.
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open
+    #   con = db.connect
+    #   con.query('CREATE TABLE values (value INTEGER DEFAULT 1)')
+    #   appender = con.appender('values')
+    #   appender
+    #     .append_default
+    #     .end_row
+    #     .flush
+    def append_default
+      return self if _append_default
+
+      raise_appender_error('failed to append_default')
+    end
+
+    # call-seq:
+    #   appender.append_hugeint(val) -> self
+    #
+    # Appends a huge int value to the current row in the appender.
     #
     #   require 'duckdb'
     #   db = DuckDB::Database.open
@@ -233,12 +441,19 @@ module DuckDB
     #   appender
     #     .append_hugeint(-170_141_183_460_469_231_731_687_303_715_884_105_727)
     #     .end_row
+    #     .flush
     def append_hugeint(value)
       lower, upper = integer_to_hugeint(value)
-      _append_hugeint(lower, upper)
+
+      return self if _append_hugeint(lower, upper)
+
+      raise_appender_error('failed to append_hugeint')
     end
 
-    # appends unsigned huge int value.
+    # call-seq:
+    #   appender.append_uhugeint(val) -> self
+    #
+    # Appends an unsigned huge int value to the current row in the appender.
     #
     #   require 'duckdb'
     #   db = DuckDB::Database.open
@@ -248,12 +463,19 @@ module DuckDB
     #   appender
     #     .append_hugeint(340_282_366_920_938_463_463_374_607_431_768_211_455)
     #     .end_row
+    #     .flush
     def append_uhugeint(value)
       lower, upper = integer_to_hugeint(value)
-      _append_uhugeint(lower, upper)
+
+      return self if _append_uhugeint(lower, upper)
+
+      raise_appender_error('failed to append_uhugeint')
     end
 
-    # appends date value.
+    # call-seq:
+    #   appender.append_date(val) -> self
+    #
+    # Appends a date value to the current row in the appender.
     #
     #   require 'duckdb'
     #   db = DuckDB::Database.open
@@ -269,10 +491,15 @@ module DuckDB
     def append_date(value)
       date = _parse_date(value)
 
-      _append_date(date.year, date.month, date.day)
+      return self if _append_date(date.year, date.month, date.day)
+
+      raise_appender_error('failed to append_date')
     end
 
-    # appends time value.
+    # call-seq:
+    #   appender.append_time(val) -> self
+    #
+    # Appends a time value to the current row in the appender.
     #
     #   require 'duckdb'
     #   db = DuckDB::Database.open
@@ -287,10 +514,15 @@ module DuckDB
     def append_time(value)
       time = _parse_time(value)
 
-      _append_time(time.hour, time.min, time.sec, time.usec)
+      return self if _append_time(time.hour, time.min, time.sec, time.usec)
+
+      raise_appender_error('failed to append_time')
     end
 
-    # appends timestamp value.
+    # call-seq:
+    #   appender.append_timestamp(val) -> self
+    #
+    # Appends a timestamp value to the current row in the appender.
     #
     #   require 'duckdb'
     #   db = DuckDB::Database.open
@@ -306,12 +538,16 @@ module DuckDB
     def append_timestamp(value)
       time = to_time(value)
 
-      _append_timestamp(time.year, time.month, time.day, time.hour, time.min, time.sec, time.nsec / 1000)
+      return self if _append_timestamp(time.year, time.month, time.day, time.hour, time.min, time.sec, time.nsec / 1000)
+
+      raise_appender_error('failed to append_timestamp')
     end
 
-    # appends interval.
+    # call-seq:
+    #   appender.append_interval(val) -> self
+    #
+    # Appends an interval value to the current row in the appender.
     # The argument must be ISO8601 duration format.
-    # WARNING: This method is expremental.
     #
     #   require 'duckdb'
     #   db = DuckDB::Database.open
@@ -324,7 +560,10 @@ module DuckDB
     #     .flush
     def append_interval(value)
       value = Interval.to_interval(value)
-      _append_interval(value.interval_months, value.interval_days, value.interval_micros)
+
+      return self if _append_interval(value.interval_months, value.interval_days, value.interval_micros)
+
+      raise_appender_error('failed to append_interval')
     end
 
     # appends value.

data/lib/duckdb/logical_type.rb

@@ -18,5 +18,93 @@ module DuckDB
       type_id = _type
       DuckDB::Converter::IntToSym.type_to_sym(type_id)
     end
+
+    # Iterates over each union member name.
+    #
+    # When a block is provided, this method yields each union member name in
+    # order. It also returns the total number of members yielded.
+    #
+    #   union_logical_type.each_member_name do |name|
+    #     puts "Union member: #{name}"
+    #   end
+    #
+    # If no block is given, an Enumerator is returned, which can be used to
+    # retrieve all member names.
+    #
+    #   names = union_logical_type.each_member_name.to_a
+    #   # => ["member1", "member2"]
+    def each_member_name
+      return to_enum(__method__) {member_count} unless block_given?
+
+      member_count.times do |i|
+        yield member_name_at(i)
+      end
+    end
+
+    # Iterates over each union member type.
+    #
+    # When a block is provided, this method yields each union member logical
+    # type in order. It also returns the total number of members yielded.
+    #
+    #   union_logical_type.each_member_type do |logical_type|
+    #     puts "Union member: #{logical_type.type}"
+    #   end
+    #
+    # If no block is given, an Enumerator is returned, which can be used to
+    # retrieve all member logical types.
+    #
+    #   names = union_logical_type.each_member_type.map(&:type)
+    #   # => [:varchar, :integer]
+    def each_member_type
+      return to_enum(__method__) {member_count} unless block_given?
+
+      member_count.times do |i|
+        yield member_type_at(i)
+      end
+    end
+
+    # Iterates over each struct child name.
+    #
+    # When a block is provided, this method yields each struct child name in
+    # order. It also returns the total number of children yielded.
+    #
+    #   struct_logical_type.each_child_name do |name|
+    #     puts "Struct child: #{name}"
+    #   end
+    #
+    # If no block is given, an Enumerator is returned, which can be used to
+    # retrieve all child names.
+    #
+    #   names = struct_logical_type.each_child_name.to_a
+    #   # => ["child1", "child2"]
+    def each_child_name
+      return to_enum(__method__) {child_count} unless block_given?
+
+      child_count.times do |i|
+        yield child_name_at(i)
+      end
+    end
+
+    # Iterates over each struct child type.
+    #
+    # When a block is provided, this method yields each struct child type in
+    # order. It also returns the total number of children yielded.
+    #
+    #   struct_logical_type.each_child_type do |logical_type|
+    #     puts "Struct child type: #{logical_type.type}"
+    #   end
+    #
+    # If no block is given, an Enumerator is returned, which can be used to
+    # retrieve all child logical types.
+    #
+    #   types = struct_logical_type.each_child_type.map(&:type)
+    #   # => [:integer, :varchar]
+    def each_child_type
+      return to_enum(__method__) {child_count} unless block_given?
+
+      child_count.times do |i|
+        yield child_type_at(i)
+      end
+    end
   end
 end

data/lib/duckdb/prepared_statement.rb

@@ -135,7 +135,7 @@ module DuckDB
     #   require 'duckdb'
     #   db = DuckDB::Database.open('duckdb_database')
     #   con = db.connect
-    #   sql ='SELECT name FROM users WHERE bigint_col = ?'
+    #   sql ='SELECT name FROM users WHERE hugeint_col = ?'
     #   stmt = PreparedStatement.new(con, sql)
     #   stmt.bind_hugeint_internal(1, 1_234_567_890_123_456_789_012_345)
     def bind_hugeint_internal(index, value)
@@ -143,6 +143,23 @@ module DuckDB
       _bind_hugeint(index, lower, upper)
     end
 
+    # binds i-th parameter with SQL prepared statement.
+    # The first argument is index of parameter.
+    # The index of first parameter is 1 not 0.
+    # The second argument value must be Integer value.
+    # This method uses duckdb_bind_uhugeint internally.
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open('duckdb_database')
+    #   con = db.connect
+    #   sql ='SELECT name FROM users WHERE uhugeint_col = ?'
+    #   stmt = PreparedStatement.new(con, sql)
+    #   stmt.bind_uhugeint(1, (2**128) - 1)
+    def bind_uhugeint(index, value)
+      lower, upper = integer_to_hugeint(value)
+      _bind_uhugeint(index, lower, upper)
+    end
+
     # binds i-th parameter with SQL prepared statement.
     # The first argument is index of parameter.
     # The index of first parameter is 1 not 0.

data/lib/duckdb/version.rb

@@ -3,5 +3,5 @@
 module DuckDB
   # The version string of ruby-duckdb.
   # Currently, ruby-duckdb is NOT semantic versioning.
-  VERSION = '1.2.0.0'
+  VERSION = '1.2.1.0'
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: duckdb
 version: !ruby/object:Gem::Version
-  version: 1.2.0.0
+  version: 1.2.1.0
 platform: ruby
 authors:
 - Masaki Suketa
 bindir: bin
 cert_chain: []
-date: 2025-02-23 00:00:00.000000000 Z
+date: 2025-03-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal