duckdb 1.2.1.0 → 1.3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d8003b16f724b8a5c4863dbc507476601992e002767aa3cf7cfd7d87583265bc
-  data.tar.gz: a82ef0f5617349c568dd2be3cb8ad1deb5bdee8796483e376eaabc266232f280
+  metadata.gz: 419a694a8223198ebddb3470cddc96c164fa684ebde604edf5d0df401376c0d5
+  data.tar.gz: c832f287dc1fa48532d2b69dc49c0de13f5d9f2811a49cf3dcd5ba23f985be71
 SHA512:
-  metadata.gz: 8220ad5939d4c60819636488a783118ba8040429348ad157515ea1801fe9462ad20e2fff12440ce3e1ffae642f3d6fca0a02b43b4ed8958a105cfd079f85de47
-  data.tar.gz: f221a85106b80b654750faeb855c51ff760d82082cb86d7c77834c20194ab71b21feff55d883f1d2d13b1dac699bb50ff6fc5473a04db0e50f4dbbfcb1cd5d22
+  metadata.gz: e48b21a62da9e1dff74bc2b2ecc775e93c1fbd01691bed443fd04686875e6b5285a4f4d61ea7befb961bbc2c98c610caa0da712fdbd339b3b5efe83d07c4bfc3
+  data.tar.gz: 06f7a29029833de5f912343432c8391cecb3404c0069b14d190617291634f790ea55433f5178d9114bd6f7e4a2c7729ce9b808343c48d820842f96fa771bbe22

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', '3.5.0-preview1']
+        duckdb: ['1.2.2', '1.1.3', '1.1.1', '1.3.0']
 
     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', '3.5.0-preview1']
+        duckdb: ['1.2.2', '1.1.3', '1.1.1', '1.3.0']
 
     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.8', '3.4.1', 'ucrt', 'mingw', 'mswin', 'head']
+        ruby: ['3.2.6', '3.3.8', '3.4.1', 'ucrt', 'mingw', 'mswin']
+        duckdb: ['1.2.2', '1.1.3', '1.1.1', '1.3.0']
 
     steps:
     - uses: actions/checkout@v4

data/CHANGELOG.md

@@ -1,8 +1,33 @@
 # Changelog
 
 All notable changes to this project will be documented in this file.
+
 # Unreleased
 
+# 1.3.0.0 - 2025-05-31
+- bump duckdb to 1.3.0 on CI.
+
+## Breaking changes
+- `DuckDB::Result#streaming?` is deprecated.
+- The second argument of `DuckDB::PendingResult.new` is now meaningless. The result is the same when it is set to true.
+- `DuckDB::PreparedStatement#pending_prepared` behaves the same as `DuckDB::PreparedStatement#pending_prepared_stream`.
+  - `DuckDB::PreparedStatement#pending_prepared_stream` will be depreacted. Use `pending_prepared` instead.
+- `DuckDB::Connection#async_query` behaves the same as `DuckDB::Connection#async_query_stream`.
+  - `DuckDB::Connection#async_query_stream` will be deprecated. Use `async_query` instead.
+- `DuckDB::Result#chunk_each`, `DuckDB::Result.use_chunk_each`, `DuckDB::Result.use_chunk_each?` are deprecated.
+
+# 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,11 +1,12 @@
-ARG RUBY_VERSION=3.4.2
+ARG RUBY_VERSION=3.4.4
 FROM ruby:${RUBY_VERSION}
 
-ARG DUCKDB_VERSION=1.2.1
+ARG DUCKDB_VERSION=1.3.0
 ARG VALGRIND_VERSION=3.21.0
 
-RUN apt update -qq && \
-    apt install -y build-essential curl git wget libc6-dbg
+RUN apt-get update -qq && \
+    apt-get install -y --no-install-recommends build-essential curl git wget libc6-dbg && \
+    apt-get clean
 
 COPY getduckdb.sh .
 RUN ./getduckdb.sh

data/Gemfile.lock

@@ -1,32 +1,32 @@
 PATH
   remote: .
   specs:
-    duckdb (1.2.1.0)
+    duckdb (1.3.0.0)
       bigdecimal (>= 3.1.4)
 
 GEM
   remote: https://rubygems.org/
   specs:
     benchmark-ips (2.14.0)
-    bigdecimal (3.1.9)
-    mini_portile2 (2.8.8)
+    bigdecimal (3.2.0)
+    mini_portile2 (2.8.9)
     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 (13.3.0)
+    rake-compiler (1.3.0)
       rake
     ruby_memcheck (3.0.1)
       nokogiri

data/README.md

@@ -146,7 +146,7 @@ result = con.prepare('SELECT * FROM users WHERE name = $name AND email = $email'
 You can use async query.
 
 ```ruby
-pending_result = con.async_query_stream('SLOW QUERY')
+pending_result = con.async_query('SLOW QUERY')
 pending_result.execute_task while pending_result.state == :not_ready
 
 result = pending_result.execute_pending

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/extconf.rb

@@ -64,6 +64,9 @@ have_func('duckdb_result_error_type', 'duckdb.h')
 # check duckdb >= 1.2.0
 have_func('duckdb_create_instance_cache', 'duckdb.h')
 
+# check duckdb >= 1.3.0
+have_func('duckdb_get_table_names', '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/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/pending_result.c

@@ -40,13 +40,9 @@ static VALUE duckdb_pending_result_initialize(int argc, VALUE *argv, VALUE self)
     VALUE streaming_p = Qfalse;
     duckdb_state state;
 
-    /*
-     * FIXME: The 2nd argument is deprecated and will be removed in the future.
-     * The behavior will be same as streaming.
     if (argc == 2) {
-        rb_warn("The 2nd argument is deprecated and will be removed in the future.");
+        rb_warn("The second argument of `DuckDB::PendingResult#new` is now meaningless. The result is the same when it is set to true.");
     }
-    */
     rb_scan_args(argc, argv, "11", &oDuckDBPreparedStatement, &streaming_p);
 
     if (rb_obj_is_kind_of(oDuckDBPreparedStatement, cDuckDBPreparedStatement) != Qtrue) {
@@ -56,20 +52,7 @@ static VALUE duckdb_pending_result_initialize(int argc, VALUE *argv, VALUE self)
     rubyDuckDBPendingResult *ctx = get_struct_pending_result(self);
     rubyDuckDBPreparedStatement *stmt = get_struct_prepared_statement(oDuckDBPreparedStatement);
 
-#ifdef DUCKDB_API_NO_DEPRECATED
     state = duckdb_pending_prepared(stmt->prepared_statement, &(ctx->pending_result));
-#else
-    /*
-     * FIXME: streaming_p check will be removed in the future.
-     *
-     * state = duckdb_pending_prepared(stmt->prepared_statement, &(ctx->pending_result));
-     */
-    if (!NIL_P(streaming_p) && streaming_p == Qtrue) {
-        state = duckdb_pending_prepared_streaming(stmt->prepared_statement, &(ctx->pending_result));
-    } else {
-        state = duckdb_pending_prepared(stmt->prepared_statement, &(ctx->pending_result));
-    }
-#endif
 
     if (state == DuckDBError) {
         rb_raise(eDuckDBError, "%s", duckdb_pending_error(ctx->pending_result));

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/result.c

@@ -26,9 +26,7 @@ static size_t memsize(const void *p);
 static VALUE duckdb_result_column_count(VALUE oDuckDBResult);
 static VALUE duckdb_result_rows_changed(VALUE oDuckDBResult);
 static VALUE duckdb_result_columns(VALUE oDuckDBResult);
-static VALUE duckdb_result_streaming_p(VALUE oDuckDBResult);
 static VALUE destroy_data_chunk(VALUE arg);
-static VALUE duckdb_result__chunk_each(VALUE oDuckDBResult);
 
 static VALUE duckdb_result__chunk_stream(VALUE oDuckDBResult);
 static VALUE yield_rows(VALUE arg);
@@ -168,63 +166,12 @@ static VALUE duckdb_result_columns(VALUE oDuckDBResult) {
     return ary;
 }
 
-/*
- * :nodoc:
- */
-static VALUE duckdb_result_streaming_p(VALUE oDuckDBResult) {
-    rubyDuckDBResult *ctx;
-
-#ifdef DUCKDB_API_NO_DEPRECATED
-    return Qtrue;
-#else
-    rb_warn("`DuckDB::Result#streaming?` will be deprecated in the future.");
-    /* FIXME streaming is allways true. so this method is not useful and deprecated. */
-    TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
-    return duckdb_result_is_streaming(ctx->result) ? Qtrue : Qfalse;
-#endif
-}
-
 static VALUE destroy_data_chunk(VALUE arg) {
     struct chunk_arg *p = (struct chunk_arg *)arg;
     duckdb_destroy_data_chunk(&(p->chunk));
     return Qnil;
 }
 
-/* :nodoc: */
-static VALUE duckdb_result__chunk_each(VALUE oDuckDBResult) {
-/*
-#ifdef HAVE_DUCKDB_H_GE_V1_0_0
-    return duckdb_result__chunk_stream(oDuckDBResult);
-#else
-*/
-    rubyDuckDBResult *ctx;
-    struct chunk_arg arg;
-    idx_t chunk_count;
-    idx_t chunk_idx;
-
-#ifdef DUCKDB_API_NO_DEPRECATED
-    //TODO: use duckdb_fetch_chunk instead of duckdb_result_chunk_count and duckdb_result_get_chunk.
-    // duckdb_result_chunk_count will be deprecated in the future.
-    // duckdb_result_get_chunk will be deprecated in the future.
-#else
-    TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
-
-    arg.col_count = duckdb_column_count(&(ctx->result));
-    chunk_count = duckdb_result_chunk_count(ctx->result);
-
-    RETURN_ENUMERATOR(oDuckDBResult, 0, 0);
-
-    for (chunk_idx = 0; chunk_idx < chunk_count; chunk_idx++) {
-        arg.chunk = duckdb_result_get_chunk(ctx->result, chunk_idx);
-        rb_ensure(yield_rows, (VALUE)&arg, destroy_data_chunk, (VALUE)&arg);
-    }
-#endif
-    return Qnil;
-/*
-#endif
-*/
-}
-
 /* :nodoc: */
 static VALUE duckdb_result__chunk_stream(VALUE oDuckDBResult) {
     rubyDuckDBResult *ctx;
@@ -877,8 +824,6 @@ void rbduckdb_init_duckdb_result(void) {
     rb_define_method(cDuckDBResult, "column_count", duckdb_result_column_count, 0);
     rb_define_method(cDuckDBResult, "rows_changed", duckdb_result_rows_changed, 0);
     rb_define_method(cDuckDBResult, "columns", duckdb_result_columns, 0);
-    rb_define_method(cDuckDBResult, "streaming?", duckdb_result_streaming_p, 0);
-    rb_define_private_method(cDuckDBResult, "_chunk_each", duckdb_result__chunk_each, 0);
     rb_define_private_method(cDuckDBResult, "_chunk_stream", duckdb_result__chunk_stream, 0);
     rb_define_private_method(cDuckDBResult, "_column_type", duckdb_result__column_type, 1);
     rb_define_private_method(cDuckDBResult, "_return_type", duckdb_result__return_type, 0);

data/ext/duckdb/ruby-duckdb.h

@@ -16,6 +16,10 @@
 #define HAVE_DUCKDB_H_GE_V1_2_0 1
 #endif
 
+#ifdef HAVE_DUCKDB_GET_TABLE_NAMES
+#define HAVE_DUCKDB_H_GE_V1_3_0 1
+#endif
+
 #include "./error.h"
 #include "./database.h"
 #include "./connection.h"
@@ -32,6 +36,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 +51,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/connection.rb

@@ -81,10 +81,9 @@ module DuckDB
     #   result = pending_result.execute_pending
     #   result.each.first
     def async_query_stream(sql, *args, **kwargs)
-      prepare(sql) do |stmt|
-        stmt.bind_args(*args, **kwargs)
-        stmt.pending_prepared_stream
-      end
+      warn("`#{self.class}#{__method__}` will be deprecated. Use `#{self.class}#async_query` instead.")
+
+      async_query(sql, *args, **kwargs)
     end
 
     # connects DuckDB database

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

@@ -52,7 +52,8 @@ module DuckDB
     end
 
     def pending_prepared_stream
-      PendingResult.new(self, true)
+      warn("`#{self.class}##{__method__}` will be deprecated. use `#{self.class}#pending_prepared` instead")
+      pending_prepared
     end
 
     # returns statement type. The return value is one of the following symbols:
@@ -105,6 +106,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/result.rb

@@ -28,36 +28,16 @@ module DuckDB
 
     alias column_size column_count
 
-    @use_chunk_each = false
-
     class << self
       def new
         raise DuckDB::Error, 'DuckDB::Result cannot be instantiated directly.'
       end
-
-      attr_writer :use_chunk_each
-
-      def use_chunk_each?
-        @use_chunk_each
-      end
     end
 
     def each(&)
-      if self.class.use_chunk_each?
-        return chunk_each unless block_given?
-
-        chunk_each(&)
-      else
-        return _chunk_stream unless block_given?
-
-        _chunk_stream(&)
-      end
-    end
+      return _chunk_stream unless block_given?
 
-    # :nodoc:
-    def chunk_each(&)
-      warn 'DuckDB::Result#chunk_each will be deprecated.'
-      _chunk_each(&)
+      _chunk_stream(&)
     end
 
     # returns return type. The return value is one of the following symbols:

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.3.0.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.3.0.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: []