duckdb 0.10.3.0 → 1.0.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 907d156955f2d1845a4a3646f7fe08148bd04cb1a7b01bb9ae7d4a959a74658f
-  data.tar.gz: b512a86a31e8d050306487bd321e2f54686e451b9609d74baa1319ac403d3250
+  metadata.gz: 4ec35034af422ec8f64f8474e95321a72a635925227fa8b5c26b3a430a4283a6
+  data.tar.gz: 52fb59085c80865dd6c51a5f7cb93b0e3eb2940245b4df580040753d364bd989
 SHA512:
-  metadata.gz: f0c927abf5c9361ba7ad8a2e56e83b27ae4199a4c8a179864b9e6361f5842aa1f148a6c56a5eb1bd9254e93da9063b46bb9ec5b3c79aca54f3dedcebfe4170ff
-  data.tar.gz: b9974d9f85cbac42a9c71a8e1e12cedd74378e7d91907cb3b80919c744b72f596bc2c7f6450b49e249c92b587535a56d45ffc0eac3550ddf1f77df0c2e6fd466
+  metadata.gz: 00d69fe6df1f7acdb1fac1e8bce26b17d9d7f06802fb8a8ddb287f25831858a69576c0d3558f6e5a48d0761226aae46a9f92d541b9e2547ae7f81f8b65a67441
+  data.tar.gz: dd8734f7a005a0007336faf58b6b032e6a2dbcf668859483cc9c713eef50ca585df9e564257b6890c9af3c394e82de8e0bd7a42790d3e1c033ffedeb41702e2c

data/.github/workflows/test_on_macos.yml

@@ -15,8 +15,8 @@ jobs:
     runs-on: macos-latest
     strategy:
       matrix:
-        ruby: ['3.0.7', '3.1.5', '3.2.4', '3.3.1', '3.4.0-preview1', 'head']
-        duckdb: ['0.9.2', '0.10.3']
+        ruby: ['3.0.7', '3.1.6', '3.2.4', '3.3.3', '3.4.0-preview1', 'head']
+        duckdb: ['1.0.0', '0.10.3']
 
     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.0.7', '3.1.5', '3.2.4', '3.3.1', '3.4.0-preview1', 'head']
-        duckdb: ['0.9.2', '0.10.3']
+        ruby: ['3.0.7', '3.1.6', '3.2.4', '3.3.3', '3.4.0-preview1', 'head']
+        duckdb: ['1.0.0', '0.10.3']
 
     steps:
     - uses: actions/checkout@v4

data/.github/workflows/test_on_windows.yml

@@ -15,8 +15,8 @@ jobs:
     runs-on: windows-latest
     strategy:
       matrix:
-        ruby: ['3.0.7', '3.1.5', '3.2.4', '3.3.1', 'ucrt', 'mingw', 'mswin', 'head']
-        duckdb: ['0.9.2', '0.10.3']
+        ruby: ['3.0.7', '3.1.5', '3.2.4', '3.3.2', 'ucrt', 'mingw', 'mswin', 'head']
+        duckdb: ['1.0.0', '0.10.3']
 
     steps:
     - uses: actions/checkout@v4

data/CHANGELOG.md

@@ -4,6 +4,46 @@ All notable changes to this project will be documented in this file.
 
 ## Unreleased
 
+# 1.0.0.1 - 2024-06-16
+- support fetch the value from UHUGEINT type column.
+- add `DuckDB::Appender#append_uhugeint`.
+- DuckDB::Result supports ARRAY column type (only when DuckDB::Result.use_chunk_each is true).
+- DuckDB::Result supports LIST column type (only when DuckDB::Result.use_chunk_each is true).
+  Thanks to stephenprater.
+
+# 1.0.0.0 - 2024-06-08
+- bump duckdb to 1.0.0.
+- add `DuckDB::ExtractedStatements` class.
+- add `DuckDB::ExtractedStatements#size`.
+- add `DuckDB::ExtractedStatements#prepared_statement`.
+- raise error when `DuckDB::ExtractedStatements#new` is called with invalid SQL.
+- The following public/private methods will be deprecated.
+  - `DuckDB::Result#streaming?`
+  - `DuckDB::Result#_null?`
+  - `DuckDB::Result#_to_boolean`
+  - `DuckDB::Result#_to_smallint`
+  - `DuckDB::Result#_to_utinyint`
+  - `DuckDB::Result#_to_integer`
+  - `DuckDB::Result#_to_bigint`
+  - `DuckDB::Result#_to_hugeint`
+  - `DuckDB::Result#_to_hugeint_internal`
+  - `DuckDB::Result#__to_hugeint_internal`
+  - `DuckDB::Result#_to_decimal`
+  - `DuckDB::Result#_to_decimal_internal`
+  - `DuckDB::Result#__to_decimal_internal`
+  - `DuckDB::Result#_to_float`
+  - `DuckDB::Result#_to_double`
+  - `DuckDB::Result#_to_string`
+  - `DuckDB::Result#_to_string_internal`
+  - `DuckDB::Result#_to_blob`
+  - `DuckDB::Result.use_chunk_each=`
+  - `DuckDB::Result#use_chunk_each?`
+
+## Breaking changes
+- DuckDB::Result.use_chunk_each is true by default.
+  If you want to use the old behavior, set `DuckDB::Result.use_chunk_each = false`.
+  But the old behavior will be removed in the future release.
+
 # 0.10.3.0 - 2024-05-25
 - bump to duckdb v0.10.3.
 

data/Dockerfile

@@ -1,7 +1,7 @@
-ARG RUBY_VERSION=3.2.2
+ARG RUBY_VERSION=3.3.2
 FROM ruby:${RUBY_VERSION}
 
-ARG DUCKDB_VERSION=0.10.3
+ARG DUCKDB_VERSION=1.0.0
 
 RUN apt update -qq && \
     apt install -y build-essential curl git wget

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    duckdb (0.10.3.0)
+    duckdb (1.0.0.1)
       bigdecimal (>= 3.1.4)
 
 GEM
@@ -9,12 +9,12 @@ GEM
   specs:
     benchmark-ips (2.13.0)
     bigdecimal (3.1.8)
-    mini_portile2 (2.8.6)
+    mini_portile2 (2.8.7)
     minitest (5.23.1)
-    nokogiri (1.16.5)
+    nokogiri (1.16.6)
       mini_portile2 (~> 2.8.2)
       racc (~> 1.4)
-    nokogiri (1.16.5-x86_64-linux)
+    nokogiri (1.16.6-x86_64-linux)
       racc (~> 1.4)
     racc (1.8.0)
     rake (13.2.1)

data/ext/duckdb/appender.c

@@ -28,6 +28,7 @@ static VALUE appender__append_interval(VALUE self, VALUE months, VALUE days, VAL
 static VALUE appender__append_time(VALUE self, VALUE hour, VALUE min, VALUE sec, VALUE micros);
 static VALUE appender__append_timestamp(VALUE self, VALUE year, VALUE month, VALUE day, VALUE hour, VALUE min, VALUE sec, VALUE micros);
 static VALUE appender__append_hugeint(VALUE self, VALUE lower, VALUE upper);
+static VALUE appender__append_uhugeint(VALUE self, VALUE lower, VALUE upper);
 static VALUE appender_flush(VALUE self);
 static VALUE appender_close(VALUE self);
 
@@ -349,6 +350,21 @@ static VALUE appender__append_hugeint(VALUE self, VALUE lower, VALUE upper) {
     return self;
 }
 
+static VALUE appender__append_uhugeint(VALUE self, VALUE lower, VALUE upper) {
+    duckdb_uhugeint uhugeint;
+
+    uhugeint.lower = NUM2ULL(lower);
+    uhugeint.upper = NUM2ULL(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;
+}
+
 static VALUE appender_flush(VALUE self) {
     rubyDuckDBAppender *ctx;
     TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
@@ -395,6 +411,7 @@ void rbduckdb_init_duckdb_appender(void) {
     rb_define_private_method(cDuckDBAppender, "_append_time", appender__append_time, 4);
     rb_define_private_method(cDuckDBAppender, "_append_timestamp", appender__append_timestamp, 7);
     rb_define_private_method(cDuckDBAppender, "_append_hugeint", appender__append_hugeint, 2);
+    rb_define_private_method(cDuckDBAppender, "_append_uhugeint", appender__append_uhugeint, 2);
     rb_define_method(cDuckDBAppender, "flush", appender_flush, 0);
     rb_define_method(cDuckDBAppender, "close", appender_close, 0);
 }

data/ext/duckdb/duckdb.c

@@ -33,4 +33,5 @@ Init_duckdb_native(void) {
     rbduckdb_init_duckdb_appender();
     rbduckdb_init_duckdb_config();
     rbduckdb_init_duckdb_converter();
+    rbduckdb_init_duckdb_extracted_statements();
 }

data/ext/duckdb/extconf.rb

@@ -29,6 +29,10 @@ def check_duckdb_library(library, func, version)
   have_func(func, 'duckdb.h')
   return if found
 
+  raise_not_found_library(library, version)
+end
+
+def raise_not_found_library(library, version)
   library_name = duckdb_library_name(library)
   msg = "#{library_name} is not found. Install #{library_name} of duckdb >= #{version}."
   print_message(msg)
@@ -36,7 +40,7 @@ def check_duckdb_library(library, func, version)
 end
 
 def duckdb_library_name(library)
-  "lib#{library}.(so|dylib|dll)"
+  "lib#{library}.#{RbConfig::CONFIG['DLEXT']}"
 end
 
 def print_message(msg)
@@ -60,7 +64,10 @@ have_func('duckdb_bind_parameter_index', 'duckdb.h')
 # check duckdb >= 0.10.0
 have_func('duckdb_appender_column_count', 'duckdb.h')
 
-# duckdb_parameter_name is not found on Windows.
+# check duckdb >= 1.0.0
+have_func('duckdb_fetch_chunk', 'duckdb.h')
+
+# duckdb_parameter_name in duckdb <= 0.9.1 is not found on Windows.
 have_func('duckdb_parameter_name', 'duckdb.h')
 
 create_makefile('duckdb/duckdb_native')

data/ext/duckdb/extracted_statements.c

@@ -0,0 +1,94 @@
+#include "ruby-duckdb.h"
+
+static VALUE cDuckDBExtractedStatements;
+
+static void deallocate(void *ctx);
+static VALUE allocate(VALUE klass);
+static size_t memsize(const void *p);
+
+static const rb_data_type_t extract_statements_data_type = {
+    "DuckDB/ExtractedStatements",
+    {NULL, deallocate, memsize,},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static void deallocate(void *ctx);
+static VALUE allocate(VALUE klass);
+static size_t memsize(const void *p);
+
+static VALUE duckdb_extracted_statements_initialize(VALUE self, VALUE con, VALUE query);
+static VALUE duckdb_extracted_statements_size(VALUE self);
+static VALUE duckdb_extracted_statements_prepared_statement(VALUE self, VALUE con, VALUE index);
+
+static void deallocate(void *ctx) {
+    rubyDuckDBExtractedStatements *p = (rubyDuckDBExtractedStatements *)ctx;
+
+    duckdb_destroy_extracted(&(p->extracted_statements));
+    xfree(p);
+}
+
+static VALUE allocate(VALUE klass) {
+    rubyDuckDBExtractedStatements *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBExtractedStatements));
+    ctx->num_statements = 0;
+
+    return TypedData_Wrap_Struct(klass, &extract_statements_data_type, ctx);
+}
+
+static size_t memsize(const void *p) {
+    return sizeof(rubyDuckDBExtractedStatements);
+}
+
+static VALUE duckdb_extracted_statements_initialize(VALUE self, VALUE con, VALUE query) {
+    rubyDuckDBConnection *pcon;
+    rubyDuckDBExtractedStatements *ctx;
+    char *pquery;
+    const char *error;
+
+    if (rb_obj_is_kind_of(con, cDuckDBConnection) != Qtrue) {
+        rb_raise(rb_eTypeError, "1st argument must be DuckDB::Connection");
+    }
+
+    pquery = StringValuePtr(query);
+    pcon = get_struct_connection(con);
+    TypedData_Get_Struct(self, rubyDuckDBExtractedStatements, &extract_statements_data_type, ctx);
+
+    ctx->num_statements = duckdb_extract_statements(pcon->con, pquery, &(ctx->extracted_statements));
+
+    if (ctx->num_statements == 0) {
+        error = duckdb_extract_statements_error(ctx->extracted_statements);
+        rb_raise(eDuckDBError, "%s", error);
+    }
+
+    return self;
+}
+
+static VALUE duckdb_extracted_statements_size(VALUE self) {
+    rubyDuckDBExtractedStatements *ctx;
+
+    TypedData_Get_Struct(self, rubyDuckDBExtractedStatements, &extract_statements_data_type, ctx);
+
+    return ULL2NUM(ctx->num_statements);
+}
+
+
+static VALUE duckdb_extracted_statements_prepared_statement(VALUE self, VALUE con, VALUE index) {
+    rubyDuckDBConnection *pcon;
+    rubyDuckDBExtractedStatements *ctx;
+
+    if (rb_obj_is_kind_of(con, cDuckDBConnection) != Qtrue) {
+        rb_raise(rb_eTypeError, "1st argument must be DuckDB::Connection");
+    }
+    pcon = get_struct_connection(con);
+    TypedData_Get_Struct(self, rubyDuckDBExtractedStatements, &extract_statements_data_type, ctx);
+
+    return rbduckdb_prepared_statement_new(pcon->con, ctx->extracted_statements, NUM2ULL(index));
+}
+
+void rbduckdb_init_duckdb_extracted_statements(void) {
+    cDuckDBExtractedStatements = rb_define_class_under(mDuckDB, "ExtractedStatements", rb_cObject);
+
+    rb_define_alloc_func(cDuckDBExtractedStatements, allocate);
+    rb_define_method(cDuckDBExtractedStatements, "initialize", duckdb_extracted_statements_initialize, 2);
+    rb_define_method(cDuckDBExtractedStatements, "size", duckdb_extracted_statements_size, 0);
+    rb_define_method(cDuckDBExtractedStatements, "prepared_statement", duckdb_extracted_statements_prepared_statement, 2);
+}

data/ext/duckdb/extracted_statements.h

@@ -0,0 +1,12 @@
+#ifndef RUBY_DUCKDB_EXTRACTED_STATEMENTS_H
+#define RUBY_DUCKDB_EXTRACTED_STATEMENTS_H
+
+struct _rubyDuckDBExtractedStatements {
+    duckdb_extracted_statements extracted_statements;
+    idx_t num_statements;
+};
+
+typedef struct _rubyDuckDBExtractedStatements rubyDuckDBExtractedStatements;
+
+void rbduckdb_init_duckdb_extracted_statements(void);
+#endif

data/ext/duckdb/pending_result.c

@@ -39,6 +39,13 @@ 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_scan_args(argc, argv, "11", &oDuckDBPreparedStatement, &streaming_p);
 
     if (rb_obj_is_kind_of(oDuckDBPreparedStatement, cDuckDBPreparedStatement) != Qtrue) {
@@ -48,11 +55,20 @@ 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

@@ -53,6 +53,20 @@ static size_t memsize(const void *p) {
     return sizeof(rubyDuckDBPreparedStatement);
 }
 
+VALUE rbduckdb_prepared_statement_new(duckdb_connection con, duckdb_extracted_statements extracted_statements, idx_t index) {
+    VALUE obj;
+    rubyDuckDBPreparedStatement *ctx;
+
+    obj = allocate(cDuckDBPreparedStatement);
+
+    TypedData_Get_Struct(obj, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
+
+    if (duckdb_prepare_extracted_statement(con, extracted_statements, index, &(ctx->prepared_statement)) == DuckDBError) {
+        rb_raise(eDuckDBError, "Fail to get DuckDB::PreparedStatement object from ExtractedStatements object");
+    }
+    return obj;
+}
+
 static VALUE duckdb_prepared_statement_initialize(VALUE self, VALUE con, VALUE query) {
     rubyDuckDBConnection *ctxcon;
     rubyDuckDBPreparedStatement *ctx;

data/ext/duckdb/prepared_statement.h

@@ -8,6 +8,7 @@ struct _rubyDuckDBPreparedStatement {
 
 typedef struct _rubyDuckDBPreparedStatement rubyDuckDBPreparedStatement;
 
+VALUE rbduckdb_prepared_statement_new(duckdb_connection con, duckdb_extracted_statements extracted_statements, idx_t index);
 rubyDuckDBPreparedStatement *get_struct_prepared_statement(VALUE self);
 void rbduckdb_init_duckdb_prepared_statement(void);
 

data/ext/duckdb/result.c

@@ -1,5 +1,10 @@
 #include "ruby-duckdb.h"
 
+struct chunk_arg {
+    duckdb_data_chunk chunk;
+    idx_t col_count;
+};
+
 static VALUE cDuckDBResult;
 static ID id__to_date;
 static ID id__to_time;
@@ -27,10 +32,11 @@ static VALUE duckdb_result_row_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 void yield_rows(duckdb_data_chunk chunk, idx_t col_count);
+static VALUE yield_rows(VALUE arg);
 static VALUE duckdb_result__column_type(VALUE oDuckDBResult, VALUE col_idx);
 static VALUE duckdb_result__is_null(VALUE oDuckDBResult, VALUE row_idx, VALUE col_idx);
 static VALUE duckdb_result__to_boolean(VALUE oDuckDBResult, VALUE row_idx, VALUE col_idx);
@@ -56,9 +62,12 @@ static VALUE vector_interval(void* vector_data, idx_t row_idx);
 static VALUE vector_blob(void* vector_data, idx_t row_idx);
 static VALUE vector_varchar(void* vector_data, idx_t row_idx);
 static VALUE vector_hugeint(void* vector_data, idx_t row_idx);
+static VALUE vector_uhugeint(void* vector_data, idx_t row_idx);
 static VALUE vector_decimal(duckdb_logical_type ty, void* vector_data, idx_t row_idx);
 static VALUE vector_enum(duckdb_logical_type ty, void* vector_data, idx_t row_idx);
-static VALUE vector_list(duckdb_logical_type ty, duckdb_vector vector, idx_t row_idx);
+static VALUE vector_array(duckdb_logical_type ty, duckdb_vector vector, idx_t row_idx);
+static VALUE vector_array_value_at(duckdb_vector array, duckdb_logical_type element_type, idx_t index);
+static VALUE vector_list(duckdb_logical_type ty, duckdb_vector vector, void* vector_data, idx_t row_idx);
 static VALUE vector_map(duckdb_logical_type ty, duckdb_vector vector, idx_t row_idx);
 static VALUE vector_struct(duckdb_logical_type ty, duckdb_vector vector, idx_t row_idx);
 static VALUE vector_uuid(void* vector_data, idx_t row_idx);
@@ -93,52 +102,102 @@ rubyDuckDBResult *get_struct_result(VALUE obj) {
 }
 
 static VALUE to_ruby_obj_boolean(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
+#ifdef DUCKDB_API_NO_DEPRECATED
+    return Qnil;
+#else
+    rb_warn("private method `_to_boolean` will be deprecated in the future. Set DuckDB::Result#use_chunk_each to true.");
     bool bval = duckdb_value_boolean(result, col_idx, row_idx);
     return bval ? Qtrue : Qfalse;
+#endif
 }
 
 static VALUE to_ruby_obj_smallint(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
+#ifdef DUCKDB_API_NO_DEPRECATED
+    return Qnil;
+#else
+    rb_warn("private method `_to_smallint` will be deprecated in the future. Set DuckDB::Result#use_chunk_each to true.");
     int16_t i16val = duckdb_value_int16(result, col_idx, row_idx);
     return INT2FIX(i16val);
+#endif
 }
 
 static VALUE to_ruby_obj_utinyint(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
+#ifdef DUCKDB_API_NO_DEPRECATED
+    return Qnil;
+#else
+    rb_warn("private method `_to_utinyint` will be deprecated in the future. Set DuckDB::Result#use_chunk_each to true.");
     uint8_t ui8val = duckdb_value_uint8(result, col_idx, row_idx);
     return UINT2NUM(ui8val);
+#endif
 }
 
 static VALUE to_ruby_obj_integer(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
+#ifdef DUCKDB_API_NO_DEPRECATED
+    return Qnil;
+#else
+    rb_warn("private method `_to_integer` will be deprecated in the future. Set DuckDB::Result#use_chunk_each to true.");
     int32_t i32val = duckdb_value_int32(result, col_idx, row_idx);
     return INT2NUM(i32val);
+#endif
 }
 
 static VALUE to_ruby_obj_bigint(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
+#ifdef DUCKDB_API_NO_DEPRECATED
+    return Qnil;
+#else
+    rb_warn("private method `_to_bigint` will be deprecated in the future. Set DuckDB::Result#use_chunk_each to true.");
     int64_t i64val = duckdb_value_int64(result, col_idx, row_idx);
     return LL2NUM(i64val);
+#endif
 }
 
 static VALUE to_ruby_obj_hugeint(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
+#ifdef DUCKDB_API_NO_DEPRECATED
+    return Qnil;
+#else
+    rb_warn("private method `__to_hugeint_internal` will be deprecated in the future. Set DuckDB::Result#use_chunk_each to true.");
     duckdb_hugeint hugeint = duckdb_value_hugeint(result, col_idx, row_idx);
     return rb_ary_new3(2, ULL2NUM(hugeint.lower), LL2NUM(hugeint.upper));
+#endif
 }
 
 static VALUE to_ruby_obj_decimal(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
+#ifdef DUCKDB_API_NO_DEPRECATED
+    return Qnil;
+#else
+    rb_warn("private method `__to_decimal_internal` will be deprecated in the future. Set DuckDB::Result#use_chunk_each to true.");
     duckdb_decimal decimal = duckdb_value_decimal(result, col_idx, row_idx);
     return rb_ary_new3(4, ULL2NUM(decimal.value.lower), LL2NUM(decimal.value.upper), UINT2NUM(decimal.width), UINT2NUM(decimal.scale));
+#endif
 }
 
 static VALUE to_ruby_obj_float(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
+#ifdef DUCKDB_API_NO_DEPRECATED
+    return Qnil;
+#else
+    rb_warn("private method `_to_float` will be deprecated in the future. Set DuckDB::Result#use_chunk_each to true.");
     float fval = duckdb_value_float(result, col_idx, row_idx);
     return DBL2NUM(fval);
+#endif
 }
 
 static VALUE to_ruby_obj_double(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
+#ifdef DUCKDB_API_NO_DEPRECATED
+    return Qnil;
+#else
+    rb_warn("private method `_to_double` will be deprecated in the future. Set DuckDB::Result#use_chunk_each to true.");
     double dval = duckdb_value_double(result, col_idx, row_idx);
     return DBL2NUM(dval);
+#endif
 }
 
 static VALUE to_ruby_obj_blob(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
+
+#ifdef DUCKDB_API_NO_DEPRECATED
+    return Qnil;
+#else
     VALUE str;
+    rb_warn("private method `_to_blob` will be deprecated in the future. Set DuckDB::Result#use_chunk_each to true.");
     duckdb_blob bval = duckdb_value_blob(result, col_idx, row_idx);
     str = rb_str_new(bval.data, bval.size);
 
@@ -147,6 +206,7 @@ static VALUE to_ruby_obj_blob(duckdb_result *result, idx_t col_idx, idx_t row_id
     }
 
     return str;
+#endif
 }
 
 /*
@@ -220,9 +280,15 @@ static VALUE duckdb_result_column_count(VALUE oDuckDBResult) {
  *
  */
 static VALUE duckdb_result_row_count(VALUE oDuckDBResult) {
+
+#ifdef DUCKDB_API_NO_DEPRECATED
+    return Qnil;
+#else
     rubyDuckDBResult *ctx;
+    rb_warn("`row_count` will be deprecated in the future.");
     TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
     return LL2NUM(duckdb_row_count(&(ctx->result)));
+#endif
 }
 
 /*
@@ -256,51 +322,77 @@ static VALUE duckdb_result_columns(VALUE oDuckDBResult) {
  */
 static VALUE duckdb_result_streaming_p(VALUE oDuckDBResult) {
     rubyDuckDBResult *ctx;
+
+#ifdef DUCKDB_API_NO_DEPRECATED
+    return Qtrue;
+#else
+    /* 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;
 }
 
 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;
-    idx_t col_count;
+    struct chunk_arg arg;
     idx_t chunk_count;
     idx_t chunk_idx;
-    duckdb_data_chunk chunk;
 
+#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);
 
-    col_count = duckdb_column_count(&(ctx->result));
+    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++) {
-        chunk = duckdb_result_get_chunk(ctx->result, chunk_idx);
-        yield_rows(chunk, col_count);
-        duckdb_destroy_data_chunk(&chunk);
+        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
+*/
 }
 
 static VALUE duckdb_result__chunk_stream(VALUE oDuckDBResult) {
     rubyDuckDBResult *ctx;
-    duckdb_data_chunk chunk;
-    idx_t col_count;
+    struct chunk_arg arg;
 
     TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
 
     RETURN_ENUMERATOR(oDuckDBResult, 0, 0);
 
-    col_count = duckdb_column_count(&(ctx->result));
+    arg.col_count = duckdb_column_count(&(ctx->result));
 
-    while((chunk = duckdb_stream_fetch_chunk(ctx->result)) != NULL) {
-        yield_rows(chunk, col_count);
-        duckdb_destroy_data_chunk(&chunk);
+#ifdef HAVE_DUCKDB_H_GE_V1_0_0
+    while((arg.chunk = duckdb_fetch_chunk(ctx->result)) != NULL) {
+#else
+    while((arg.chunk = duckdb_stream_fetch_chunk(ctx->result)) != NULL) {
+#endif
+        rb_ensure(yield_rows, (VALUE)&arg, destroy_data_chunk, (VALUE)&arg);
     }
     return Qnil;
 }
 
-static void yield_rows(duckdb_data_chunk chunk, idx_t col_count) {
+static VALUE yield_rows(VALUE arg) {
     idx_t row_count;
     idx_t row_idx;
     idx_t col_idx;
@@ -308,16 +400,19 @@ static void yield_rows(duckdb_data_chunk chunk, idx_t col_count) {
     VALUE row;
     VALUE val;
 
-    row_count = duckdb_data_chunk_get_size(chunk);
+    struct chunk_arg *p = (struct chunk_arg *)arg;
+
+    row_count = duckdb_data_chunk_get_size(p->chunk);
     for (row_idx = 0; row_idx < row_count; row_idx++) {
-        row = rb_ary_new2(col_count);
-        for (col_idx = 0; col_idx < col_count; col_idx++) {
-            vector = duckdb_data_chunk_get_vector(chunk, col_idx);
+        row = rb_ary_new2(p->col_count);
+        for (col_idx = 0; col_idx < p->col_count; col_idx++) {
+            vector = duckdb_data_chunk_get_vector(p->chunk, col_idx);
             val = vector_value(vector, row_idx);
             rb_ary_store(row, col_idx, val);
         }
         rb_yield(row);
     }
+    return Qnil;
 }
 
 static VALUE duckdb_result__column_type(VALUE oDuckDBResult, VALUE col_idx) {
@@ -329,10 +424,15 @@ static VALUE duckdb_result__column_type(VALUE oDuckDBResult, VALUE col_idx) {
 static VALUE duckdb_result__is_null(VALUE oDuckDBResult, VALUE row_idx, VALUE col_idx) {
     rubyDuckDBResult *ctx;
     bool is_null;
+#ifdef DUCKDB_API_NO_DEPRECATED
+    return Qfalse;
+#else
+    rb_warn("private method `_null?` will be deprecated in the future. Set DuckDB::Result#use_chunk_each to true.");
     TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
 
     is_null = duckdb_value_is_null(&(ctx->result), NUM2LL(col_idx), NUM2LL(row_idx));
     return is_null ? Qtrue : Qfalse;
+#endif
 }
 
 static VALUE duckdb_result__to_boolean(VALUE oDuckDBResult, VALUE row_idx, VALUE col_idx) {
@@ -403,6 +503,10 @@ static VALUE duckdb_result__to_string(VALUE oDuckDBResult, VALUE row_idx, VALUE
     duckdb_string p;
     VALUE obj;
 
+#ifdef DUCKDB_API_NO_DEPRECATED
+    return Qnil;
+#else
+    rb_warn("private method `_to_string` will be deprecated in the future. Set DuckDB::Result#use_chunk_each to true.");
     TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
 
     p = duckdb_value_string(&(ctx->result), NUM2LL(col_idx), NUM2LL(row_idx));
@@ -411,6 +515,7 @@ static VALUE duckdb_result__to_string(VALUE oDuckDBResult, VALUE row_idx, VALUE
         duckdb_free(p.data);
         return obj;
     }
+#endif
     return Qnil;
 }
 
@@ -418,6 +523,10 @@ static VALUE duckdb_result__to_string_internal(VALUE oDuckDBResult, VALUE row_id
     rubyDuckDBResult *ctx;
     duckdb_string p;
     VALUE obj;
+#ifdef DUCKDB_API_NO_DEPRECATED
+    // duckdb_value_string_internal will be deprecated in the future.
+#else
+    rb_warn("private method `_to_string_internal` will be deprecated in the future. Set DuckDB::Result#use_chunk_each to true.");
     TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
 
     p = duckdb_value_string_internal(&(ctx->result), NUM2LL(col_idx), NUM2LL(row_idx));
@@ -425,6 +534,7 @@ static VALUE duckdb_result__to_string_internal(VALUE oDuckDBResult, VALUE row_id
         obj = rb_utf8_str_new(p.data, p.size);
         return obj;
     }
+#endif
     return Qnil;
 }
 
@@ -555,6 +665,14 @@ static VALUE vector_hugeint(void* vector_data, idx_t row_idx) {
                       );
 }
 
+static VALUE vector_uhugeint(void* vector_data, idx_t row_idx) {
+    duckdb_uhugeint uhugeint = ((duckdb_uhugeint *)vector_data)[row_idx];
+    return rb_funcall(mDuckDBConverter, id__to_hugeint_from_vector, 2,
+                      ULL2NUM(uhugeint.lower),
+                      ULL2NUM(uhugeint.upper)
+                      );
+}
+
 static VALUE vector_decimal(duckdb_logical_type ty, void* vector_data, idx_t row_idx) {
     VALUE width = INT2FIX(duckdb_decimal_width(ty));
     VALUE scale = INT2FIX(duckdb_decimal_scale(ty));
@@ -614,27 +732,147 @@ static VALUE vector_enum(duckdb_logical_type ty, void* vector_data, idx_t row_id
     return value;
 }
 
-static VALUE vector_list(duckdb_logical_type ty, duckdb_vector vector, idx_t row_idx) {
-    // Lists are stored as vectors within vectors
+static VALUE vector_array(duckdb_logical_type ty, duckdb_vector vector, idx_t row_idx) {
+    VALUE ary = Qnil;
+    VALUE value = Qnil;
+
+    duckdb_logical_type child_logical_type = duckdb_array_type_child_type(ty);
+    idx_t size = duckdb_array_type_array_size(ty);
+    idx_t bgn = row_idx * size;
+    idx_t end = bgn + size;
+	duckdb_vector child = duckdb_array_vector_get_child(vector);
+
+    ary = rb_ary_new2(size);
+    for (idx_t i = bgn; i < end; ++i) {
+        value = vector_array_value_at(child, child_logical_type, i);
+        rb_ary_store(ary, i - bgn, value);
+    }
+
+    duckdb_destroy_logical_type(&child_logical_type);
+    return ary;
+}
+
+static VALUE vector_array_value_at(duckdb_vector array, duckdb_logical_type element_type, idx_t index) {
+    uint64_t *validity;
+    duckdb_type type_id;
+    void* vector_data;
+    VALUE obj = Qnil;
+
+    validity = duckdb_vector_get_validity(array);
+    if (!duckdb_validity_row_is_valid(validity, index)) {
+        return Qnil;
+    }
+
+    type_id = duckdb_get_type_id(element_type);
+    vector_data = duckdb_vector_get_data(array);
+
+    switch(type_id) {
+        case DUCKDB_TYPE_INVALID:
+            obj = Qnil;
+            break;
+        case DUCKDB_TYPE_BOOLEAN:
+            obj = (((bool*) vector_data)[index]) ? Qtrue : Qfalse;
+            break;
+        case DUCKDB_TYPE_TINYINT:
+            obj = INT2FIX(((int8_t *) vector_data)[index]);
+            break;
+        case DUCKDB_TYPE_SMALLINT:
+            obj = INT2FIX(((int16_t *) vector_data)[index]);
+            break;
+        case DUCKDB_TYPE_INTEGER:
+            obj = INT2NUM(((int32_t *) vector_data)[index]);
+            break;
+        case DUCKDB_TYPE_BIGINT:
+            obj = LL2NUM(((int64_t *) vector_data)[index]);
+            break;
+        case DUCKDB_TYPE_UTINYINT:
+            obj = INT2FIX(((uint8_t *) vector_data)[index]);
+            break;
+        case DUCKDB_TYPE_USMALLINT:
+            obj = INT2FIX(((uint16_t *) vector_data)[index]);
+            break;
+        case DUCKDB_TYPE_UINTEGER:
+            obj = UINT2NUM(((uint32_t *) vector_data)[index]);
+            break;
+        case DUCKDB_TYPE_UBIGINT:
+            obj = ULL2NUM(((uint64_t *) vector_data)[index]);
+            break;
+        case DUCKDB_TYPE_HUGEINT:
+            obj = vector_hugeint(vector_data, index);
+            break;
+        case DUCKDB_TYPE_UHUGEINT:
+            obj = vector_uhugeint(vector_data, index);
+            break;
+        case DUCKDB_TYPE_FLOAT:
+            obj = DBL2NUM((((float *) vector_data)[index]));
+            break;
+        case DUCKDB_TYPE_DOUBLE:
+            obj = DBL2NUM((((double *) vector_data)[index]));
+            break;
+        case DUCKDB_TYPE_DATE:
+            obj = vector_date(vector_data, index);
+            break;
+        case DUCKDB_TYPE_TIMESTAMP:
+            obj = vector_timestamp(vector_data, index);
+            break;
+        case DUCKDB_TYPE_TIME:
+            obj = vector_time(vector_data, index);
+            break;
+        case DUCKDB_TYPE_INTERVAL:
+            obj = vector_interval(vector_data, index);
+            break;
+        case DUCKDB_TYPE_VARCHAR:
+            obj = vector_varchar(vector_data, index);
+            break;
+        case DUCKDB_TYPE_BLOB:
+            obj = vector_blob(vector_data, index);
+            break;
+        case DUCKDB_TYPE_DECIMAL:
+            obj = vector_decimal(element_type, vector_data, index);
+            break;
+        case DUCKDB_TYPE_ENUM:
+            obj = vector_enum(element_type, vector_data, index);
+            break;
+        case DUCKDB_TYPE_ARRAY:
+            obj = vector_array(element_type, array, index);
+            break;
+        case DUCKDB_TYPE_LIST:
+            obj = vector_list(element_type, array, vector_data, index);
+            break;
+        case DUCKDB_TYPE_MAP:
+            obj = vector_map(element_type, vector_data, index);
+            break;
+        case DUCKDB_TYPE_STRUCT:
+            obj = vector_struct(element_type, vector_data, index);
+            break;
+        case DUCKDB_TYPE_UUID:
+            obj = vector_uuid(vector_data, index);
+            break;
+        default:
+            rb_warn("Unknown type %d", type_id);
+            obj = Qnil;
+    }
+
+    return obj;
+}
 
+static VALUE vector_list(duckdb_logical_type ty, duckdb_vector vector, void * vector_data, idx_t row_idx) {
     VALUE ary = Qnil;
-    VALUE element = Qnil;
+    VALUE value = Qnil;
     idx_t i;
 
-    // rb_warn("ruby-duckdb does not support List yet");
-
     duckdb_logical_type child_logical_type = duckdb_list_type_child_type(ty);
-    // duckdb_type child_type = duckdb_get_type_id(child_logical_type);
 
-    duckdb_list_entry list_entry = ((duckdb_list_entry *)vector)[row_idx];
+    duckdb_list_entry list_entry = ((duckdb_list_entry *)vector_data)[row_idx];
+    idx_t bgn = list_entry.offset;
+    idx_t end = bgn + list_entry.length;
     ary = rb_ary_new2(list_entry.length);
 
-    for (i = list_entry.offset; i < list_entry.offset + list_entry.length; ++i) {
-        /*
-         * FIXME: How to get the child element?
-         */
-        // element = ???
-        rb_ary_store(ary, i - list_entry.offset, element);
+    duckdb_vector child = duckdb_list_vector_get_child(vector);
+
+    for (i = bgn; i < end; ++i) {
+        value = vector_array_value_at(child, child_logical_type, i);
+        rb_ary_store(ary, i - bgn, value);
     }
     duckdb_destroy_logical_type(&child_logical_type);
     return ary;
@@ -741,6 +979,9 @@ static VALUE vector_value(duckdb_vector vector, idx_t row_idx) {
         case DUCKDB_TYPE_HUGEINT:
             obj = vector_hugeint(vector_data, row_idx);
             break;
+        case DUCKDB_TYPE_UHUGEINT:
+            obj = vector_uhugeint(vector_data, row_idx);
+            break;
         case DUCKDB_TYPE_FLOAT:
             obj = DBL2NUM((((float *) vector_data)[row_idx]));
             break;
@@ -771,8 +1012,11 @@ static VALUE vector_value(duckdb_vector vector, idx_t row_idx) {
         case DUCKDB_TYPE_ENUM:
             obj = vector_enum(ty, vector_data, row_idx);
             break;
+        case DUCKDB_TYPE_ARRAY:
+            obj = vector_array(ty, vector, row_idx);
+            break;
         case DUCKDB_TYPE_LIST:
-            obj = vector_list(ty, vector_data, row_idx);
+            obj = vector_list(ty, vector, vector_data, row_idx);
             break;
         case DUCKDB_TYPE_MAP:
             obj = vector_map(ty, vector_data, row_idx);
@@ -805,26 +1049,27 @@ void rbduckdb_init_duckdb_result(void) {
     rb_define_alloc_func(cDuckDBResult, allocate);
 
     rb_define_method(cDuckDBResult, "column_count", duckdb_result_column_count, 0);
-    rb_define_method(cDuckDBResult, "row_count", duckdb_result_row_count, 0);
+    rb_define_method(cDuckDBResult, "row_count", duckdb_result_row_count, 0); /* deprecated */
     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_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, "_null?", duckdb_result__is_null, 2);
-    rb_define_private_method(cDuckDBResult, "_to_boolean", duckdb_result__to_boolean, 2);
-    rb_define_private_method(cDuckDBResult, "_to_smallint", duckdb_result__to_smallint, 2);
-    rb_define_private_method(cDuckDBResult, "_to_utinyint", duckdb_result__to_utinyint, 2);
-    rb_define_private_method(cDuckDBResult, "_to_integer", duckdb_result__to_integer, 2);
-    rb_define_private_method(cDuckDBResult, "_to_bigint", duckdb_result__to_bigint, 2);
-    rb_define_private_method(cDuckDBResult, "__to_hugeint_internal", duckdb_result___to_hugeint_internal, 2);
-    rb_define_private_method(cDuckDBResult, "__to_decimal_internal", duckdb_result___to_decimal_internal, 2);
-    rb_define_private_method(cDuckDBResult, "_to_float", duckdb_result__to_float, 2);
-    rb_define_private_method(cDuckDBResult, "_to_double", duckdb_result__to_double, 2);
-    rb_define_private_method(cDuckDBResult, "_to_string", duckdb_result__to_string, 2);
-    rb_define_private_method(cDuckDBResult, "_to_string_internal", duckdb_result__to_string_internal, 2);
-    rb_define_private_method(cDuckDBResult, "_to_blob", duckdb_result__to_blob, 2);
+
+    rb_define_private_method(cDuckDBResult, "_null?", duckdb_result__is_null, 2); /* deprecated */
+    rb_define_private_method(cDuckDBResult, "_to_boolean", duckdb_result__to_boolean, 2); /* deprecated */
+    rb_define_private_method(cDuckDBResult, "_to_smallint", duckdb_result__to_smallint, 2); /* deprecated */
+    rb_define_private_method(cDuckDBResult, "_to_utinyint", duckdb_result__to_utinyint, 2); /* deprecated */
+    rb_define_private_method(cDuckDBResult, "_to_integer", duckdb_result__to_integer, 2); /* deprecated */
+    rb_define_private_method(cDuckDBResult, "_to_bigint", duckdb_result__to_bigint, 2); /* deprecated */
+    rb_define_private_method(cDuckDBResult, "__to_hugeint_internal", duckdb_result___to_hugeint_internal, 2); /* deprecated */
+    rb_define_private_method(cDuckDBResult, "__to_decimal_internal", duckdb_result___to_decimal_internal, 2); /* deprecated */
+    rb_define_private_method(cDuckDBResult, "_to_float", duckdb_result__to_float, 2); /* deprecated */
+    rb_define_private_method(cDuckDBResult, "_to_double", duckdb_result__to_double, 2); /* deprecated */
+    rb_define_private_method(cDuckDBResult, "_to_string", duckdb_result__to_string, 2); /* deprecated */
+    rb_define_private_method(cDuckDBResult, "_to_string_internal", duckdb_result__to_string_internal, 2); /* deprecated */
+    rb_define_private_method(cDuckDBResult, "_to_blob", duckdb_result__to_blob, 2); /* deprecated */
     rb_define_private_method(cDuckDBResult, "_enum_internal_type", duckdb_result__enum_internal_type, 1);
     rb_define_private_method(cDuckDBResult, "_enum_dictionary_size", duckdb_result__enum_dictionary_size, 1);
     rb_define_private_method(cDuckDBResult, "_enum_dictionary_value", duckdb_result__enum_dictionary_value, 2);

data/ext/duckdb/ruby-duckdb.h

@@ -1,6 +1,9 @@
 #ifndef RUBY_DUCKDB_H
 #define RUBY_DUCKDB_H
 
+// #define DUCKDB_API_NO_DEPRECATED
+#define DUCKDB_NO_EXTENSION_FUNCTIONS // disable extension C-functions
+
 #include "ruby.h"
 #include <duckdb.h>
 
@@ -8,12 +11,17 @@
 #define HAVE_DUCKDB_H_GE_V0_10_0 1
 #endif
 
+#ifdef HAVE_DUCKDB_FETCH_CHUNK
+#define HAVE_DUCKDB_H_GE_V1_0_0 1
+#endif
+
 #include "./error.h"
 #include "./database.h"
 #include "./connection.h"
 #include "./result.h"
 #include "./column.h"
 #include "./prepared_statement.h"
+#include "./extracted_statements.h"
 #include "./pending_result.h"
 #include "./util.h"
 #include "./converter.h"

data/lib/duckdb/appender.rb

@@ -39,6 +39,24 @@ module DuckDB
       _append_hugeint(lower, upper)
     end
 
+    #
+    # appends unsigned huge int value.
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open
+    #   con = db.connect
+    #   con.query('CREATE TABLE numbers (num UHUGEINT)')
+    #   appender = con.appender('numbers')
+    #   appender
+    #     .begin_row
+    #     .append_hugeint(340_282_366_920_938_463_463_374_607_431_768_211_455)
+    #     .end_row
+    #
+    def append_uhugeint(value)
+      lower, upper = integer_to_hugeint(value)
+      _append_uhugeint(lower, upper)
+    end
+
     #
     # appends date value.
     #

data/lib/duckdb/library_version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DuckDB
   LIBRARY_VERSION = library_version[1..]
 end

data/lib/duckdb/pending_result.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DuckDB
   # The DuckDB::PendingResult encapsulates connection with DuckDB pending
   # result.

data/lib/duckdb/prepared_statement.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'date'
 require 'bigdecimal'
 require_relative 'converter'

data/lib/duckdb/result.rb

@@ -53,15 +53,17 @@ module DuckDB
     alias column_size column_count
     alias row_size row_count
 
+    @use_chunk_each = true
+
     class << self
       def new
         raise DuckDB::Error, 'DuckDB::Result cannot be instantiated directly.'
       end
 
-      def use_chunk_each=(val)
-        raise DuckDB::Error, 'chunk_each is not available. Install duckdb >= 0.8.0 and rerun `gem install duckdb`.' unless instance_methods.include?(:chunk_each)
+      def use_chunk_each=(value)
+        warn('`changing DuckDB::Result.use_chunk_each to false` will be deprecated.') if value == false
 
-        @use_chunk_each = val
+        @use_chunk_each = value
       end
 
       def use_chunk_each?
@@ -91,6 +93,7 @@ module DuckDB
     end
 
     def row(row_index)
+      warn("#{self.class}##{__method__} will be deprecated. set `DuckDB::Result.use_chunk_each = true`.")
       row = []
       column_count.times do |col_index|
         row << (_null?(row_index, col_index) ? nil : to_value(row_index, col_index))
@@ -99,6 +102,7 @@ module DuckDB
     end
 
     def to_value(row_index, col_index)
+      warn("#{self.class}##{__method__} will be deprecated. set `DuckDB::Result.use_chunk_each = true`.")
       send(TO_METHODS[_column_type(col_index)], row_index, col_index)
     end
 
@@ -113,19 +117,23 @@ module DuckDB
     private
 
     def _to_hugeint(row, col)
+      warn("#{self.class}##{__method__} will be deprecated.")
       _to_string(row, col).to_i
     end
 
     def _to_hugeint_internal(row, col)
+      warn("#{self.class}##{__method__} will be deprecated.")
       lower, upper = __to_hugeint_internal(row, col)
       Converter._to_hugeint_from_vector(lower, upper)
     end
 
     def _to_decimal(row, col)
+      warn("#{self.class}##{__method__} will be deprecated.")
       BigDecimal(_to_string(row, col))
     end
 
     def _to_decimal_internal(row, col)
+      warn("#{self.class}##{__method__} will be deprecated.")
       lower, upper, width, scale = __to_decimal_internal(row, col)
       Converter._to_decimal_from_hugeint(width, scale, upper, lower)
     end

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 = '0.10.3.0'
+  VERSION = '1.0.0.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: duckdb
 version: !ruby/object:Gem::Version
-  version: 0.10.3.0
+  version: 1.0.0.1
 platform: ruby
 authors:
 - Masaki Suketa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-05-24 00:00:00.000000000 Z
+date: 2024-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -132,6 +132,8 @@ files:
 - ext/duckdb/error.c
 - ext/duckdb/error.h
 - ext/duckdb/extconf.rb
+- ext/duckdb/extracted_statements.c
+- ext/duckdb/extracted_statements.h
 - ext/duckdb/pending_result.c
 - ext/duckdb/pending_result.h
 - ext/duckdb/prepared_statement.c
@@ -179,7 +181,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.9
+rubygems_version: 3.5.11
 signing_key: 
 specification_version: 4
 summary: This module is Ruby binding for DuckDB database engine.