duckdb 1.2.1.0 → 1.2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d8003b16f724b8a5c4863dbc507476601992e002767aa3cf7cfd7d87583265bc
-  data.tar.gz: a82ef0f5617349c568dd2be3cb8ad1deb5bdee8796483e376eaabc266232f280
+  metadata.gz: 9dc90028f52da778feed9afafb7e1bddfa8128120dea8c798fec4c21317cc8e1
+  data.tar.gz: 5cb1ae0ae04c712c0edcd5dc61ac7a05c12e6ee59c7c72a113f8ea3a8012aa2e
 SHA512:
-  metadata.gz: 8220ad5939d4c60819636488a783118ba8040429348ad157515ea1801fe9462ad20e2fff12440ce3e1ffae642f3d6fca0a02b43b4ed8958a105cfd079f85de47
-  data.tar.gz: f221a85106b80b654750faeb855c51ff760d82082cb86d7c77834c20194ab71b21feff55d883f1d2d13b1dac699bb50ff6fc5473a04db0e50f4dbbfcb1cd5d22
+  metadata.gz: 3dce5d6c09d593ae95e59aed616ce83d1849136bcbfe7b1f668e8e515a1c8941cf18bd62593bfaec7a4f587731e2cad841d03d0d743da49c3c18ae7f346e3528
+  data.tar.gz: 5852c870293bd442e2afcf8c624fe21c1695803f4102a065b142d6c64b8639dc793af30852717742571d6d49d89d4753b4df805173a36f895fbc6bbaaa446c8b

data/.github/workflows/test_on_macos.yml

@@ -15,8 +15,8 @@ jobs:
     runs-on: macos-latest
     strategy:
       matrix:
-        ruby: ['3.1.6', '3.2.7', '3.3.7', '3.4.2', 'head']
-        duckdb: ['1.2.1', '1.1.3', '1.1.1']
+        ruby: ['3.2.7', '3.3.8', '3.4.2', 'head']
+        duckdb: ['1.2.2', '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.7', '3.3.7', '3.4.2', 'head']
-        duckdb: ['1.2.1', '1.1.3', '1.1.1']
+        ruby: ['3.2.7', '3.3.8', '3.4.2', 'head']
+        duckdb: ['1.2.2', '1.1.3', '1.1.1']
 
     steps:
     - uses: actions/checkout@v4

data/.github/workflows/test_on_windows.yml

@@ -15,8 +15,9 @@ jobs:
     runs-on: windows-latest
     strategy:
       matrix:
-        ruby: ['3.1.6', '3.2.6', '3.3.6', '3.4.1', 'ucrt', 'mingw', 'mswin', 'head']
-        duckdb: ['1.2.1', '1.1.3', '1.1.1']
+        # ruby: ['3.2.6', '3.3.6', '3.4.1', 'ucrt', 'mingw', 'mswin', 'head']
+        ruby: ['3.2.6', '3.3.6', '3.4.1', 'ucrt', 'mingw', 'mswin']
+        duckdb: ['1.2.2', '1.1.3', '1.1.1']
 
     steps:
     - uses: actions/checkout@v4

data/CHANGELOG.md

@@ -3,6 +3,18 @@
 All notable changes to this project will be documented in this file.
 # Unreleased
 
+# 1.2.2.0 - 2025-05-11
+- drop Ruby 3.1.
+- implement `DuckDB::InstanceCache` class.
+- bump duckdb to 1.2.2 on CI.
+- add `DuckDB::PreparedStatement#bind_uint8`, `DuckDB::PreparedStatement#bind_uint16`,
+  `DuckDB::PreparedStatement#bind_uint32`, `DuckDB::PreparedStatement#bind_uint64`.
+- add `DuckDB::LogicalType` class.
+  - `DuckDB::LogicalType` class is under construction. `DuckDB::LogicalType#internal_type`,
+    `DuckDB::LogicalType#dictionary_size`, `DuckDB::LogicalType#dictionary_value_at`,
+    `DuckDB::LogicalType#each_dictionary_value`, `DuckDB::LogicalType#alias`, and
+    `DuckDB::LogicalType#alias=`are available.
+
 # 1.2.1.0 - 2025-03-30
 - bump duckdb v1.2.1 on CI.
 - drop duckdb v1.0.0.

data/Dockerfile

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

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    duckdb (1.2.1.0)
+    duckdb (1.2.2.0)
       bigdecimal (>= 3.1.4)
 
 GEM
@@ -11,22 +11,22 @@ GEM
     bigdecimal (3.1.9)
     mini_portile2 (2.8.8)
     minitest (5.25.5)
-    nokogiri (1.18.6)
+    nokogiri (1.18.8)
       mini_portile2 (~> 2.8.2)
       racc (~> 1.4)
-    nokogiri (1.18.6-aarch64-linux-gnu)
+    nokogiri (1.18.8-aarch64-linux-gnu)
       racc (~> 1.4)
-    nokogiri (1.18.6-arm-linux-gnu)
+    nokogiri (1.18.8-arm-linux-gnu)
       racc (~> 1.4)
-    nokogiri (1.18.6-arm64-darwin)
+    nokogiri (1.18.8-arm64-darwin)
       racc (~> 1.4)
-    nokogiri (1.18.6-x86_64-darwin)
+    nokogiri (1.18.8-x86_64-darwin)
       racc (~> 1.4)
-    nokogiri (1.18.6-x86_64-linux-gnu)
+    nokogiri (1.18.8-x86_64-linux-gnu)
       racc (~> 1.4)
     racc (1.8.1)
     rake (13.2.1)
-    rake-compiler (1.2.9)
+    rake-compiler (1.3.0)
       rake
     ruby_memcheck (3.0.1)
       nokogiri

data/ext/duckdb/database.c

@@ -118,6 +118,14 @@ static VALUE duckdb_database_close(VALUE self) {
     return self;
 }
 
+VALUE rbduckdb_create_database_obj(duckdb_database db) {
+    VALUE obj = allocate(cDuckDBDatabase);
+    rubyDuckDB *ctx;
+    TypedData_Get_Struct(obj, rubyDuckDB, &database_data_type, ctx);
+    ctx->db = db;
+    return obj;
+}
+
 void rbduckdb_init_duckdb_database(void) {
 #if 0
     VALUE mDuckDB = rb_define_module("DuckDB");

data/ext/duckdb/database.h

@@ -8,6 +8,7 @@ struct _rubyDuckDB {
 typedef struct _rubyDuckDB rubyDuckDB;
 
 rubyDuckDB *rbduckdb_get_struct_database(VALUE obj);
+VALUE rbduckdb_create_database_obj(duckdb_database db);
 void rbduckdb_init_duckdb_database(void);
 
 #endif

data/ext/duckdb/duckdb.c

@@ -39,4 +39,7 @@ Init_duckdb_native(void) {
     rbduckdb_init_duckdb_config();
     rbduckdb_init_duckdb_converter();
     rbduckdb_init_duckdb_extracted_statements();
+#ifdef HAVE_DUCKDB_H_GE_V1_2_0
+    rbduckdb_init_duckdb_instance_cache();
+#endif
 }

data/ext/duckdb/instance_cache.c

@@ -0,0 +1,108 @@
+#include "ruby-duckdb.h"
+
+#ifdef HAVE_DUCKDB_H_GE_V1_2_0
+VALUE cDuckDBInstanceCache;
+
+static void deallocate(void * ctx);
+static VALUE allocate(VALUE klass);
+static size_t memsize(const void *p);
+static VALUE duckdb_instance_cache_initialize(VALUE self);
+static VALUE duckdb_instance_cache_get_or_create(int argc, VALUE *argv, VALUE self);
+static VALUE duckdb_instance_cache_destroy(VALUE self);
+
+static const rb_data_type_t instance_cache_data_type = {
+    "DuckDB/InstanceCache",
+    {NULL, deallocate, memsize,},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static void deallocate(void * ctx) {
+    rubyDuckDBInstanceCache *p = (rubyDuckDBInstanceCache *)ctx;
+
+    if (p->instance_cache) {
+        duckdb_destroy_instance_cache(&(p->instance_cache));
+    }
+    xfree(p);
+}
+
+static size_t memsize(const void *p) {
+    return sizeof(rubyDuckDBInstanceCache);
+}
+
+static VALUE allocate(VALUE klass) {
+    rubyDuckDBInstanceCache *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBInstanceCache));
+    return TypedData_Wrap_Struct(klass, &instance_cache_data_type, ctx);
+}
+
+static VALUE duckdb_instance_cache_initialize(VALUE self) {
+    rubyDuckDBInstanceCache *ctx;
+
+    TypedData_Get_Struct(self, rubyDuckDBInstanceCache, &instance_cache_data_type, ctx);
+
+    ctx->instance_cache = duckdb_create_instance_cache();
+    if (ctx->instance_cache == NULL) {
+        rb_raise(eDuckDBError, "Failed to create instance cache");
+    }
+
+    return self;
+}
+
+/* :nodoc: */
+static VALUE duckdb_instance_cache_get_or_create(int argc, VALUE *argv, VALUE self) {
+    VALUE vpath = Qnil;
+    VALUE vconfig = Qnil;
+    const char *path = NULL;
+    char *error = NULL;
+    duckdb_config config = NULL;
+    duckdb_database db;
+    rubyDuckDBInstanceCache *ctx;
+
+    rb_scan_args(argc, argv, "02", &vpath, &vconfig);
+    if (!NIL_P(vpath)) {
+        path = StringValuePtr(vpath);
+    }
+    if (!NIL_P(vconfig)) {
+        if (!rb_obj_is_kind_of(vconfig, cDuckDBConfig)) {
+            rb_raise(rb_eTypeError, "The second argument must be DuckDB::Config object.");
+        }
+        rubyDuckDBConfig *ctx_config = get_struct_config(vconfig);
+        config = ctx_config->config;
+    }
+
+    TypedData_Get_Struct(self, rubyDuckDBInstanceCache, &instance_cache_data_type, ctx);
+
+    if (duckdb_get_or_create_from_cache(ctx->instance_cache, path, &db, config, &error) == DuckDBError) {
+        if (error) {
+            VALUE message = rb_str_new_cstr(error);
+            duckdb_free(error);
+            rb_raise(eDuckDBError, "%s", StringValuePtr(message));
+        } else {
+            rb_raise(eDuckDBError, "Failed to get or create database from instance cache");
+        }
+    }
+    return rbduckdb_create_database_obj(db);
+}
+
+static VALUE duckdb_instance_cache_destroy(VALUE self) {
+    rubyDuckDBInstanceCache *ctx;
+    TypedData_Get_Struct(self, rubyDuckDBInstanceCache, &instance_cache_data_type, ctx);
+
+    if (ctx->instance_cache) {
+        duckdb_destroy_instance_cache(&(ctx->instance_cache));
+        ctx->instance_cache = NULL;
+    }
+
+    return Qnil;
+}
+
+void rbduckdb_init_duckdb_instance_cache(void) {
+#if 0
+    VALUE mDuckDB = rb_define_module("DuckDB");
+#endif
+    cDuckDBInstanceCache = rb_define_class_under(mDuckDB, "InstanceCache", rb_cObject);
+    rb_define_method(cDuckDBInstanceCache, "initialize", duckdb_instance_cache_initialize, 0);
+    rb_define_method(cDuckDBInstanceCache, "get_or_create", duckdb_instance_cache_get_or_create, -1);
+    rb_define_method(cDuckDBInstanceCache, "destroy", duckdb_instance_cache_destroy, 0);
+    rb_define_alloc_func(cDuckDBInstanceCache, allocate);
+}
+#endif

data/ext/duckdb/instance_cache.h

@@ -0,0 +1,17 @@
+#ifndef RUBY_DUCKDB_INSTANCE_CACHE_H
+#define RUBY_DUCKDB_INSTANCE_CACHE_H
+
+#ifdef HAVE_DUCKDB_H_GE_V1_2_0
+
+struct _rubyDuckDBInstanceCache {
+    duckdb_instance_cache instance_cache;
+};
+
+typedef struct _rubyDuckDBInstanceCache rubyDuckDBInstanceCache;
+
+void rbduckdb_init_duckdb_instance_cache(void);
+
+#endif
+
+#endif
+

data/ext/duckdb/logical_type.c

@@ -18,6 +18,11 @@ 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 VALUE duckdb_logical_type__internal_type(VALUE self);
+static VALUE duckdb_logical_type_dictionary_size(VALUE self);
+static VALUE duckdb_logical_type_dictionary_value_at(VALUE self, VALUE didx);
+static VALUE duckdb_logical_type__get_alias(VALUE self);
+static VALUE duckdb_logical_type__set_alias(VALUE self, VALUE aname);
 
 static const rb_data_type_t logical_type_data_type = {
     "DuckDB/LogicalType",
@@ -288,6 +293,115 @@ static VALUE duckdb_logical_type_member_type_at(VALUE self, VALUE midx) {
     return rbduckdb_create_logical_type(union_member_type);
 }
 
+/*
+ *  call-seq:
+ *    enum_col.logical_type.internal_type -> Symbol
+ *
+ *  Returns the logical type's internal type.
+ *
+ */
+static VALUE duckdb_logical_type__internal_type(VALUE self) {
+    rubyDuckDBLogicalType *ctx;
+    duckdb_type type_id;
+    duckdb_type internal_type_id;
+
+    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_DECIMAL:
+            internal_type_id = duckdb_decimal_internal_type(ctx->logical_type);
+            break;
+        case DUCKDB_TYPE_ENUM:
+            internal_type_id = duckdb_enum_internal_type(ctx->logical_type);
+            break;
+        default:
+            internal_type_id = DUCKDB_TYPE_INVALID;
+    }
+
+    return INT2FIX(internal_type_id);
+}
+
+/*
+ *  call-seq:
+ *    enum_col.logical_type.dictionary_size -> Integer
+ *
+ *  Returns the dictionary size of the enum type.
+ *
+ */
+static VALUE duckdb_logical_type_dictionary_size(VALUE self) {
+    rubyDuckDBLogicalType *ctx;
+    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
+    return INT2FIX(duckdb_enum_dictionary_size(ctx->logical_type));
+}
+
+/*
+ *  call-seq:
+ *    enum_col.logical_type.dictionary_value_at(index) -> String
+ *
+ *  Returns the dictionary value at the specified index.
+ *
+ */
+static VALUE duckdb_logical_type_dictionary_value_at(VALUE self, VALUE didx) {
+    rubyDuckDBLogicalType *ctx;
+    VALUE dvalue;
+    const char *dict_value;
+    idx_t idx = NUM2ULL(didx);
+
+    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
+
+    dict_value = duckdb_enum_dictionary_value(ctx->logical_type, idx);
+    if (dict_value == NULL) {
+        rb_raise(eDuckDBError, "fail to get dictionary value of %llu", (unsigned long long)idx);
+    }
+    dvalue = rb_utf8_str_new_cstr(dict_value);
+    duckdb_free((void *)dict_value);
+    return dvalue;
+}
+
+/*
+ *  call-seq:
+ *    col.logical_type.alias -> String
+ *
+ *  Returns the alias of the logical type.
+ *
+ */
+static VALUE duckdb_logical_type__get_alias(VALUE self) {
+    rubyDuckDBLogicalType *ctx;
+    VALUE alias = Qnil;
+    const char *_alias;
+
+    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
+
+    _alias = duckdb_logical_type_get_alias(ctx->logical_type);
+    if (_alias != NULL) {
+        alias = rb_utf8_str_new_cstr(_alias);
+    }
+    duckdb_free((void *)_alias);
+    return alias;
+}
+
+/*
+ *  call-seq:
+ *    col.logical_type.alias(alias) -> String
+ *
+ *  Return the set alias of the logical type.
+ *
+ */
+static VALUE duckdb_logical_type__set_alias(VALUE self, VALUE aname) {
+    rubyDuckDBLogicalType *ctx;
+    VALUE alias = Qnil;
+    const char *_alias = StringValuePtr(aname);
+
+    TypedData_Get_Struct(self, rubyDuckDBLogicalType, &logical_type_data_type, ctx);
+    duckdb_logical_type_set_alias(ctx->logical_type, _alias);
+    if (_alias != NULL) {
+        alias = rb_utf8_str_new_cstr(_alias);
+    }
+
+    return alias;
+}
+
 VALUE rbduckdb_create_logical_type(duckdb_logical_type logical_type) {
     VALUE obj;
     rubyDuckDBLogicalType *ctx;
@@ -320,4 +434,9 @@ void rbduckdb_init_duckdb_logical_type(void) {
     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);
+    rb_define_method(cDuckDBLogicalType, "_internal_type", duckdb_logical_type__internal_type, 0);
+    rb_define_method(cDuckDBLogicalType, "dictionary_size", duckdb_logical_type_dictionary_size, 0);
+    rb_define_method(cDuckDBLogicalType, "dictionary_value_at", duckdb_logical_type_dictionary_value_at, 1);
+    rb_define_method(cDuckDBLogicalType, "get_alias", duckdb_logical_type__get_alias, 0);
+    rb_define_method(cDuckDBLogicalType, "set_alias", duckdb_logical_type__set_alias, 1);
 }

data/ext/duckdb/prepared_statement.c

@@ -27,6 +27,10 @@ static VALUE duckdb_prepared_statement_bind_blob(VALUE self, VALUE vidx, VALUE b
 static VALUE duckdb_prepared_statement_bind_null(VALUE self, VALUE vidx);
 static VALUE duckdb_prepared_statement__statement_type(VALUE self);
 static VALUE duckdb_prepared_statement__param_type(VALUE self, VALUE vidx);
+static VALUE duckdb_prepared_statement__bind_uint8(VALUE self, VALUE vidx, VALUE val);
+static VALUE duckdb_prepared_statement__bind_uint16(VALUE self, VALUE vidx, VALUE val);
+static VALUE duckdb_prepared_statement__bind_uint32(VALUE self, VALUE vidx, VALUE val);
+static VALUE duckdb_prepared_statement__bind_uint64(VALUE self, VALUE vidx, VALUE val);
 static VALUE duckdb_prepared_statement__bind_date(VALUE self, VALUE vidx, VALUE year, VALUE month, VALUE day);
 static VALUE duckdb_prepared_statement__bind_time(VALUE self, VALUE vidx, VALUE hour, VALUE min, VALUE sec, VALUE micros);
 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);
@@ -244,6 +248,7 @@ static VALUE duckdb_prepared_statement_bind_int8(VALUE self, VALUE vidx, VALUE v
     return self;
 }
 
+
 static VALUE duckdb_prepared_statement_bind_int16(VALUE self, VALUE vidx, VALUE val) {
     rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
@@ -359,6 +364,62 @@ static VALUE duckdb_prepared_statement__param_type(VALUE self, VALUE vidx) {
     return INT2FIX(duckdb_param_type(ctx->prepared_statement, NUM2ULL(vidx)));
 }
 
+/* :nodoc: */
+static VALUE duckdb_prepared_statement__bind_uint8(VALUE self, VALUE vidx, VALUE val) {
+    rubyDuckDBPreparedStatement *ctx;
+    idx_t idx = check_index(vidx);
+    uint8_t ui8val = (uint8_t)NUM2UINT(val);
+
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
+
+    if (duckdb_bind_uint8(ctx->prepared_statement, idx, ui8val) == DuckDBError) {
+        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
+    }
+    return self;
+}
+
+/* :nodoc: */
+static VALUE duckdb_prepared_statement__bind_uint16(VALUE self, VALUE vidx, VALUE val) {
+    rubyDuckDBPreparedStatement *ctx;
+    idx_t idx = check_index(vidx);
+    uint16_t ui16val = (uint16_t)NUM2UINT(val);
+
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
+
+    if (duckdb_bind_uint16(ctx->prepared_statement, idx, ui16val) == DuckDBError) {
+        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
+    }
+    return self;
+}
+
+/* :nodoc: */
+static VALUE duckdb_prepared_statement__bind_uint32(VALUE self, VALUE vidx, VALUE val) {
+    rubyDuckDBPreparedStatement *ctx;
+    idx_t idx = check_index(vidx);
+    uint32_t ui32val = (uint32_t)NUM2UINT(val);
+
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
+
+    if (duckdb_bind_uint32(ctx->prepared_statement, idx, ui32val) == DuckDBError) {
+        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
+    }
+    return self;
+}
+
+/* :nodoc: */
+static VALUE duckdb_prepared_statement__bind_uint64(VALUE self, VALUE vidx, VALUE val) {
+    rubyDuckDBPreparedStatement *ctx;
+    idx_t idx = check_index(vidx);
+    uint64_t ui64val = (uint64_t)NUM2ULL(val);
+
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
+
+    if (duckdb_bind_uint64(ctx->prepared_statement, idx, ui64val) == DuckDBError) {
+        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
+    }
+    return self;
+}
+
 /* :nodoc: */
 static VALUE duckdb_prepared_statement__bind_date(VALUE self, VALUE vidx, VALUE year, VALUE month, VALUE day) {
     rubyDuckDBPreparedStatement *ctx;
@@ -511,6 +572,10 @@ void rbduckdb_init_duckdb_prepared_statement(void) {
     rb_define_method(cDuckDBPreparedStatement, "bind_varchar", duckdb_prepared_statement_bind_varchar, 2);
     rb_define_method(cDuckDBPreparedStatement, "bind_blob", duckdb_prepared_statement_bind_blob, 2);
     rb_define_method(cDuckDBPreparedStatement, "bind_null", duckdb_prepared_statement_bind_null, 1);
+    rb_define_private_method(cDuckDBPreparedStatement, "_bind_uint8", duckdb_prepared_statement__bind_uint8, 2);
+    rb_define_private_method(cDuckDBPreparedStatement, "_bind_uint16", duckdb_prepared_statement__bind_uint16, 2);
+    rb_define_private_method(cDuckDBPreparedStatement, "_bind_uint32", duckdb_prepared_statement__bind_uint32, 2);
+    rb_define_private_method(cDuckDBPreparedStatement, "_bind_uint64", duckdb_prepared_statement__bind_uint64, 2);
     rb_define_private_method(cDuckDBPreparedStatement, "_statement_type", duckdb_prepared_statement__statement_type, 0);
     rb_define_private_method(cDuckDBPreparedStatement, "_param_type", duckdb_prepared_statement__param_type, 1);
     rb_define_private_method(cDuckDBPreparedStatement, "_bind_date", duckdb_prepared_statement__bind_date, 4);

data/ext/duckdb/ruby-duckdb.h

@@ -32,6 +32,10 @@
 #include "./appender.h"
 #include "./config.h"
 
+#ifdef HAVE_DUCKDB_H_GE_V1_2_0
+#include "./instance_cache.h"
+#endif
+
 extern VALUE mDuckDB;
 extern VALUE cDuckDBDatabase;
 extern VALUE cDuckDBConnection;
@@ -43,4 +47,8 @@ extern VALUE cDuckDBPreparedStatement;
 extern VALUE PositiveInfinity;
 extern VALUE NegativeInfinity;
 
+#ifdef HAVE_DUCKDB_H_GE_V1_2_0
+extern VALUE cDuckDBInstanceCache;
+#endif
+
 #endif

data/lib/duckdb/instance_cache.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+if defined?(DuckDB::InstanceCache)
+
+module DuckDB
+  # The DuckDB::InstanceCache is necessary if a client/program (re)opens
+  # multiple databases to the same file within the same statement.
+  #
+  #   require 'duckdb'
+  #   cache = DuckDB::InstanceCache.new
+  #   db1 = cache.get(path: 'db.duckdb')
+  #   db2 = cache.get(path: 'db.duckdb')
+  class InstanceCache
+    # :call-seq:
+    #   instance_cache.get(path:, config:) -> self
+    #
+    # Returns a DuckDB::Database object for the given path and config.
+    #   db1 = cache.get(path: 'db.duckdb')
+    #   db2 = cache.get(path: 'db.duckdb')
+    def get(path: nil, config: nil)
+      get_or_create(path, config)
+    end
+  end
+end
+
+end

data/lib/duckdb/logical_type.rb

@@ -2,6 +2,9 @@
 
 module DuckDB
   class LogicalType
+    alias :alias get_alias
+    alias :alias= set_alias
+
     # returns logical type's type symbol
     # `:unknown` means that the logical type's type is unknown/unsupported by ruby-duckdb.
     # `:invalid` means that the logical type's type is invalid in duckdb.
@@ -19,6 +22,24 @@ module DuckDB
       DuckDB::Converter::IntToSym.type_to_sym(type_id)
     end
 
+    # returns logical type's internal type symbol for Decimal or Enum types
+    # `:unknown` means that the logical type's type is unknown/unsupported by ruby-duckdb.
+    # `:invalid` means that the logical type's type is invalid in duckdb.
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open
+    #   con = db.connect
+    #   con.query("CREATE TYPE mood AS ENUM ('happy', 'sad')")
+    #   con.query("CREATE TABLE emotions (id INTEGER, enum_col mood)")
+    #
+    #   users = con.query('SELECT * FROM emotions')
+    #   ernum_col = users.columns.find { |col| col.name == 'enum_col' }
+    #   enum_col.logical_type.internal_type #=> :utinyint
+    def internal_type
+      type_id = _internal_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
@@ -106,5 +127,27 @@ module DuckDB
         yield child_type_at(i)
       end
     end
+
+    # Iterates over each enum dictionary value.
+    #
+    # When a block is provided, this method yields each enum dictionary value
+    # in order. It also returns the total number of dictionary values yielded.
+    #
+    #   enum_logical_type.each_value do |value|
+    #     puts "Enum value: #{value}"
+    #   end
+    #
+    # If no block is given, an Enumerator is returned, which can be used to
+    # retrieve all enum dictionary values.
+    #
+    #   values = enum_logical_type.each_value.to_a
+    #   # => ["happy", "sad"]
+    def each_dictionary_value
+      return to_enum(__method__) {dictionary_size} unless block_given?
+
+      dictionary_size.times do |i|
+        yield dictionary_value_at(i)
+      end
+    end
   end
 end

data/lib/duckdb/prepared_statement.rb

@@ -105,6 +105,46 @@ module DuckDB
       end
     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 is to expected Integer value between 0 to 255.
+    def bind_uint8(index, val)
+      return _bind_uint8(index, val) if val.between?(0, 255)
+
+      raise DuckDB::Error, "can't bind uint8(bind_uint8) to `#{val}`. The `#{val}` is out of range 0..255."
+    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 is to expected Integer value between 0 to 65535.
+    def bind_uint16(index, val)
+      return _bind_uint16(index, val) if val.between?(0, 65_535)
+
+      raise DuckDB::Error, "can't bind uint16(bind_uint16) to `#{val}`. The `#{val}` is out of range 0..65535."
+    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 is to expected Integer value between 0 to 4294967295.
+    def bind_uint32(index, val)
+      return _bind_uint32(index, val) if val.between?(0, 4_294_967_295)
+
+      raise DuckDB::Error, "can't bind uint32(bind_uint32) to `#{val}`. The `#{val}` is out of range 0..4294967295."
+    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 is to expected Integer value between 0 to 18446744073709551615.
+    def bind_uint64(index, val)
+      return _bind_uint64(index, val) if val.between?(0, 18_446_744_073_709_551_615)
+
+      raise DuckDB::Error, "can't bind uint64(bind_uint64) to `#{val}`. The `#{val}` is out of range 0..18446744073709551615."
+    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.1.0'
+  VERSION = '1.2.2.0'
 end

data/lib/duckdb.rb

@@ -15,6 +15,7 @@ require 'duckdb/config'
 require 'duckdb/column'
 require 'duckdb/logical_type'
 require 'duckdb/infinity'
+require 'duckdb/instance_cache'
 
 # DuckDB provides Ruby interface of DuckDB.
 module DuckDB

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: duckdb
 version: !ruby/object:Gem::Version
-  version: 1.2.1.0
+  version: 1.2.2.0
 platform: ruby
 authors:
 - Masaki Suketa
 bindir: bin
 cert_chain: []
-date: 2025-03-29 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -132,6 +132,8 @@ files:
 - ext/duckdb/extconf.rb
 - ext/duckdb/extracted_statements.c
 - ext/duckdb/extracted_statements.h
+- ext/duckdb/instance_cache.c
+- ext/duckdb/instance_cache.h
 - ext/duckdb/logical_type.c
 - ext/duckdb/logical_type.h
 - ext/duckdb/pending_result.c
@@ -154,6 +156,7 @@ files:
 - lib/duckdb/database.rb
 - lib/duckdb/extracted_statements.rb
 - lib/duckdb/infinity.rb
+- lib/duckdb/instance_cache.rb
 - lib/duckdb/interval.rb
 - lib/duckdb/library_version.rb
 - lib/duckdb/logical_type.rb
@@ -185,7 +188,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.7
 specification_version: 4
 summary: This module is Ruby binding for DuckDB database engine.
 test_files: []