duckdb 1.2.0.0 → 1.2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ed07310471afbddcd5b4facd1720eeae0868af7d2682754a30361bafdf45b5a
-  data.tar.gz: 984fd1ac1d47a72c0d20a2b1225656baf8838a47c70c3edc54d58bde0490cf25
+  metadata.gz: 9dc90028f52da778feed9afafb7e1bddfa8128120dea8c798fec4c21317cc8e1
+  data.tar.gz: 5cb1ae0ae04c712c0edcd5dc61ac7a05c12e6ee59c7c72a113f8ea3a8012aa2e
 SHA512:
-  metadata.gz: 5e85e65243f72ac9d1d8bab1ec44a18b7ac31dccba3cfd12dc81c075f44ea79592b7357dde7f30b4276fda2eee769aa93986ca216061ea2aa497a7e7038872df
-  data.tar.gz: ee8db3baf4385b71e4c4d4765200baacef1df273702281e33809d2b4037bc25b4bae008e0501c178f615ba22f5a1b99021a22d15d5982054dbe675a769ca1cd8
+  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.6', '3.3.6', '3.4.2', 'head']
-        duckdb: ['1.2.0', '1.1.3', '1.1.1', '1.0.0']
+        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.6', '3.3.6', '3.4.2', 'head']
-        duckdb: ['1.2.0', '1.1.3', '1.1.1', '1.0.0']
+        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.0', '1.1.3', '1.1.1', '1.0.0']
+        # 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,36 @@
 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.
+- 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.2
 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.2.0)
       bigdecimal (>= 3.1.4)
 
 GEM
@@ -10,23 +10,23 @@ 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.8)
       mini_portile2 (~> 2.8.2)
       racc (~> 1.4)
-    nokogiri (1.18.3-aarch64-linux-gnu)
+    nokogiri (1.18.8-aarch64-linux-gnu)
       racc (~> 1.4)
-    nokogiri (1.18.3-arm-linux-gnu)
+    nokogiri (1.18.8-arm-linux-gnu)
       racc (~> 1.4)
-    nokogiri (1.18.3-arm64-darwin)
+    nokogiri (1.18.8-arm64-darwin)
       racc (~> 1.4)
-    nokogiri (1.18.3-x86_64-darwin)
+    nokogiri (1.18.8-x86_64-darwin)
       racc (~> 1.4)
-    nokogiri (1.18.3-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/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/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

@@ -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/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
+