duckdb 0.8.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e8040d795ad975b4472fe439aa2cfb403ad5f24f9c602bca7dbdf6103c37b65
-  data.tar.gz: 82cd61d78fec67f62be8ad0280305b224ae605ffd2ea453855168dcaa77f4d32
+  metadata.gz: dab5e8d5f3beafce29f2d545b736b34b3502f2f31120d1d7d0714fdb83512457
+  data.tar.gz: a73a7438ec5762af143b8590923b0fd3c54ec99926aa48b485346e943fe66916
 SHA512:
-  metadata.gz: b54b53aa6ec96ef9e8607bea7f96b8ef9fc7c4e2189675e575eeabdfaa2d608320c02ac86dc8ca7453cd9d314ceb943241a0a858689c85b8221374ff5dc6e00e
-  data.tar.gz: 86936495132694846dd8931998c9f716d405571dd34842f6f8563ad531f2e0b8fb678f4477cff9ec33a1c0d3affc615884a4dd8063909f57cb8e4a1da2a0434f
+  metadata.gz: de0988a48ae0e9652d8411ce52265835e6d63c30f53c181cc25066d7fbae26ff9a54290e014c66aa44f6a3f87b9e5da7fa3acee6f0051c1b886cb6ea5e68d4bb
+  data.tar.gz: 0edd9bfe15f0e47da50e860732acecc897a9cbba716218da5de80188be7bf43df5f1300d3419e501532a7d26cc42a1c79d76835cb3a1a956e7b06d7842b40c20

data/.github/workflows/test_on_macos.yml

@@ -15,8 +15,8 @@ jobs:
     runs-on: macos-latest
     strategy:
       matrix:
-        ruby: ['2.7.8', '3.0.6', '3.1.4', '3.2.2', 'head']
-        duckdb: ['0.7.1', '0.8.0']
+        ruby: ['2.7.8', '3.0.6', '3.1.4', '3.2.2', '3.3.0-preview1', 'head']
+        duckdb: ['0.7.1', '0.8.1']
 
     steps:
     - uses: actions/checkout@v3

data/.github/workflows/test_on_ubuntu.yml

@@ -15,8 +15,8 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby: ['2.7.8', '3.0.6', '3.1.4', '3.2.2', 'head']
-        duckdb: ['0.7.1', '0.8.0']
+        ruby: ['2.7.8', '3.0.6', '3.1.4', '3.2.2', '3.3.0-preview1', 'head']
+        duckdb: ['0.7.1', '0.8.1']
 
     steps:
     - uses: actions/checkout@v3

data/.github/workflows/test_on_windows.yml

@@ -16,7 +16,7 @@ jobs:
     strategy:
       matrix:
         ruby: ['2.7.8', '3.0.6', '3.1.4', '3.2.2', 'ucrt', 'mingw', 'mswin', 'head']
-        duckdb: ['0.7.1', '0.8.0']
+        duckdb: ['0.7.1', '0.8.1']
 
     steps:
     - uses: actions/checkout@v3

data/CHANGELOG.md

@@ -1,5 +1,29 @@
 # ChangeLog
 
+# 0.8.1
+- bump duckdb to 0.8.1
+- add `DuckDB::Result#chunk_each`, `DuckDB::Result.use_chunk_each=`, `DuckDB::Result#use_chunk_each?`
+  The current behavior of `DuckDB::Result#each` is same as older version.
+  But `DuckDB::Result#each` behavior will be changed like as `DuckDB::Result#chunk_each` in near future release.
+  And there are some breaking changes.
+  Write `DuckdDB::Result.use_chunk_each = true` if you want to try new behavior.
+    ```
+    DuckDB::Result.use_chunk_each = true
+
+    result = con.query('SELECT ....')
+    result.each do |record| # <= each method behavior is same as DuckDB::Result#chunk_each
+      ...
+    end
+    ```
+  Thanks to @stephenprater.
+- support enum type in DuckDB::Result#chunk_each.
+- support uuid type in DuckDB::Result#chunk_each.
+
+## Breaking Change
+
+- DuckDB::Config.set_config does not raise exception when invalid key specified.
+  Instead, DuckDB::Database.open raises DuckDB::Error with invalid key configuration.
+
 # 0.8.0
 - bump duckdb to 0.8.0
 - add DuckDB::Result#_to_decimal_internal

data/Dockerfile

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

data/Gemfile.lock

@@ -1,17 +1,17 @@
 PATH
   remote: .
   specs:
-    duckdb (0.8.0)
+    duckdb (0.8.1)
 
 GEM
   remote: https://rubygems.org/
   specs:
     benchmark-ips (2.12.0)
-    minitest (5.18.0)
+    minitest (5.18.1)
     rake (13.0.6)
-    rake-compiler (1.2.1)
+    rake-compiler (1.2.3)
       rake
-    stackprof (0.2.24)
+    stackprof (0.2.25)
 
 PLATFORMS
   ruby
@@ -27,4 +27,4 @@ DEPENDENCIES
   stackprof
 
 BUNDLED WITH
-   2.4.9
+   2.4.10

data/ext/duckdb/duckdb.c

@@ -2,23 +2,17 @@
 
 VALUE mDuckDB;
 
-#ifdef HAVE_DUCKDB_H_GE_V060
 static VALUE duckdb_s_library_version(VALUE self);
-#endif
 
-#ifdef HAVE_DUCKDB_H_GE_V060
 static VALUE duckdb_s_library_version(VALUE self) {
   return rb_str_new2(duckdb_library_version());
 }
-#endif
 
 void
 Init_duckdb_native(void) {
     mDuckDB = rb_define_module("DuckDB");
 
-#ifdef HAVE_DUCKDB_H_GE_V060
     rb_define_singleton_method(mDuckDB, "library_version", duckdb_s_library_version, 0);
-#endif
 
     init_duckdb_error();
     init_duckdb_database();
@@ -29,5 +23,4 @@ Init_duckdb_native(void) {
     init_duckdb_blob();
     init_duckdb_appender();
     init_duckdb_config();
-
 }

data/ext/duckdb/extconf.rb

@@ -20,12 +20,12 @@ end
 
 dir_config('duckdb')
 
-check_duckdb_library('duckdb_pending_prepared', '0.5.0')
-
-# check duckdb >= 0.6.0
-have_func('duckdb_value_string', 'duckdb.h')
+check_duckdb_library('duckdb_extract_statements', '0.7.0')
 
 # check duckdb >= 0.7.0
 have_func('duckdb_extract_statements', 'duckdb.h')
 
+# check duckdb >= 0.8.0
+have_func('duckdb_string_is_inlined', 'duckdb.h')
+
 create_makefile('duckdb/duckdb_native')

data/ext/duckdb/result.c

@@ -37,6 +37,23 @@ static VALUE duckdb_result__enum_internal_type(VALUE oDuckDBResult, VALUE col_id
 static VALUE duckdb_result__enum_dictionary_size(VALUE oDuckDBResult, VALUE col_idx);
 static VALUE duckdb_result__enum_dictionary_value(VALUE oDuckDBResult, VALUE col_idx, VALUE idx);
 
+#ifdef HAVE_DUCKDB_H_GE_V080
+static VALUE vector_date(void *vector_data, idx_t row_idx);
+static VALUE vector_timestamp(void* vector_data, idx_t row_idx);
+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_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_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);
+static VALUE vector_value(duckdb_vector vector, idx_t row_idx);
+static VALUE duckdb_result_chunk_each(VALUE oDuckDBResult);
+#endif
+
 static const rb_data_type_t result_data_type = {
     "DuckDB/Result",
     {NULL, deallocate, memsize,},
@@ -300,25 +317,15 @@ static VALUE duckdb_result__to_double(VALUE oDuckDBResult, VALUE row_idx, VALUE
 
 static VALUE duckdb_result__to_string(VALUE oDuckDBResult, VALUE row_idx, VALUE col_idx) {
     rubyDuckDBResult *ctx;
-#ifdef HAVE_DUCKDB_H_GE_V060
     duckdb_string p;
-#else
-    char *p;
-#endif
     VALUE obj;
+
     TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
 
-#ifdef HAVE_DUCKDB_H_GE_V060
     p = duckdb_value_string(&(ctx->result), NUM2LL(col_idx), NUM2LL(row_idx));
     if (p.data) {
         obj = rb_utf8_str_new(p.data, p.size);
         duckdb_free(p.data);
-#else
-    p = duckdb_value_varchar(&(ctx->result), NUM2LL(col_idx), NUM2LL(row_idx));
-    if (p) {
-        obj = rb_utf8_str_new_cstr(p);
-        duckdb_free(p);
-#endif
         return obj;
     }
     return Qnil;
@@ -326,23 +333,13 @@ static VALUE duckdb_result__to_string(VALUE oDuckDBResult, VALUE row_idx, VALUE
 
 static VALUE duckdb_result__to_string_internal(VALUE oDuckDBResult, VALUE row_idx, VALUE col_idx) {
     rubyDuckDBResult *ctx;
-#ifdef HAVE_DUCKDB_H_GE_V060
     duckdb_string p;
-#else
-    char *p;
-#endif
     VALUE obj;
     TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
 
-#ifdef HAVE_DUCKDB_H_GE_V060
     p = duckdb_value_string_internal(&(ctx->result), NUM2LL(col_idx), NUM2LL(row_idx));
     if (p.data) {
         obj = rb_utf8_str_new(p.data, p.size);
-#else
-    p = duckdb_value_varchar_internal(&(ctx->result), NUM2LL(col_idx), NUM2LL(row_idx));
-    if (p) {
-        obj = rb_utf8_str_new_cstr(p);
-#endif
         return obj;
     }
     return Qnil;
@@ -403,6 +400,318 @@ VALUE create_result(void) {
     return allocate(cDuckDBResult);
 }
 
+#ifdef HAVE_DUCKDB_H_GE_V080
+static VALUE vector_date(void *vector_data, idx_t row_idx) {
+    duckdb_date_struct date = duckdb_from_date(((duckdb_date *) vector_data)[row_idx]);
+    VALUE mConverter = rb_const_get(mDuckDB, rb_intern("Converter"));
+
+    return rb_funcall(mConverter, rb_intern("_to_date"), 3,
+            INT2FIX(date.year),
+            INT2FIX(date.month),
+            INT2FIX(date.day)
+            );
+}
+
+static VALUE vector_timestamp(void* vector_data, idx_t row_idx) {
+    duckdb_timestamp_struct data = duckdb_from_timestamp(((duckdb_timestamp *)vector_data)[row_idx]);
+    VALUE mConverter = rb_const_get(mDuckDB, rb_intern("Converter"));
+    return rb_funcall(mConverter, rb_intern("_to_time"), 7,
+            INT2FIX(data.date.year),
+            INT2FIX(data.date.month),
+            INT2FIX(data.date.day),
+            INT2FIX(data.time.hour),
+            INT2FIX(data.time.min),
+            INT2FIX(data.time.sec),
+            INT2NUM(data.time.micros)
+            );
+}
+
+static VALUE vector_interval(void* vector_data, idx_t row_idx) {
+    duckdb_interval data = ((duckdb_interval *)vector_data)[row_idx];
+    VALUE mConverter = rb_const_get(mDuckDB, rb_intern("Converter"));
+    return rb_funcall(mConverter, rb_intern("_to_interval_from_vector"), 3,
+            INT2NUM(data.months),
+            INT2NUM(data.days),
+            LL2NUM(data.micros)
+            );
+}
+
+static VALUE vector_blob(void* vector_data, idx_t row_idx) {
+    duckdb_string_t s = (((duckdb_string_t *)vector_data)[row_idx]);
+    if(duckdb_string_is_inlined(s)) {
+        return rb_str_new(s.value.inlined.inlined, s.value.inlined.length);
+    } else {
+        return rb_str_new(s.value.pointer.ptr, s.value.pointer.length);
+    }
+}
+
+static VALUE vector_varchar(void* vector_data, idx_t row_idx) {
+    duckdb_string_t s = (((duckdb_string_t *)vector_data)[row_idx]);
+    if(duckdb_string_is_inlined(s)) {
+        return rb_utf8_str_new(s.value.inlined.inlined, s.value.inlined.length);
+    } else {
+        return rb_utf8_str_new(s.value.pointer.ptr, s.value.pointer.length);
+    }
+}
+
+static VALUE vector_hugeint(void* vector_data, idx_t row_idx) {
+    duckdb_hugeint hugeint = ((duckdb_hugeint *)vector_data)[row_idx];
+    VALUE mConverter = rb_const_get(mDuckDB, rb_intern("Converter"));
+    return rb_funcall(mConverter, rb_intern("_to_hugeint_from_vector"), 2,
+            ULL2NUM(hugeint.lower),
+            LL2NUM(hugeint.upper)
+            );
+}
+
+static VALUE vector_decimal(duckdb_logical_type ty, void* vector_data, idx_t row_idx) {
+    uint8_t width = duckdb_decimal_width(ty);
+    uint8_t scale = duckdb_decimal_scale(ty);
+    VALUE mConverter = rb_const_get(mDuckDB, rb_intern("Converter"));
+    duckdb_type type = duckdb_decimal_internal_type(ty);
+    duckdb_hugeint value;
+
+    value.upper = 0;
+    value.lower = 0;
+
+    switch(duckdb_decimal_internal_type(ty)) {
+        case DUCKDB_TYPE_HUGEINT:
+            value = ((duckdb_hugeint *) vector_data)[row_idx];
+            break;
+        default:
+            rb_warn("Unknown decimal internal type %d", type);
+    }
+
+    return rb_funcall(mConverter, rb_intern("_to_decimal_from_vector"), 4,
+            INT2FIX(width),
+            INT2FIX(scale),
+            ULL2NUM(value.lower),
+            LL2NUM(value.upper)
+            );
+}
+
+static VALUE vector_enum(duckdb_logical_type ty, void* vector_data, idx_t row_idx) {
+    duckdb_type type = duckdb_enum_internal_type(ty);
+    uint8_t index;
+    char *p;
+    VALUE value = Qnil;
+
+    switch(type) {
+        case DUCKDB_TYPE_UTINYINT:
+            index = ((uint8_t *) vector_data)[row_idx];
+            p = duckdb_enum_dictionary_value(ty, index);
+            if (p) {
+                value = rb_utf8_str_new_cstr(p);
+                duckdb_free(p);
+            }
+            break;
+        default:
+            rb_warn("Unknown enum internal type %d", type);
+    }
+    return value;
+}
+
+static VALUE vector_list(duckdb_logical_type ty, duckdb_vector vector, idx_t row_idx) {
+    // Lists are stored as vectors within vectors
+
+    VALUE ary = Qnil;
+    VALUE element = 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];
+    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_destroy_logical_type(&child_logical_type);
+    return ary;
+}
+
+static VALUE vector_map(duckdb_logical_type ty, duckdb_vector vector, idx_t row_idx) {
+    VALUE hash = rb_hash_new();
+
+    duckdb_logical_type key_logical_type = duckdb_map_type_key_type(ty);
+    duckdb_logical_type value_logical_type = duckdb_map_type_value_type(ty);
+    // duckdb_type key_type = duckdb_get_type_id(key_logical_type);
+    // duckdb_type value_type = duckdb_get_type_id(value_logical_type);
+
+    /*
+     * FIXME: How to get key and value?
+     *
+     * rb_hash_aset(hash, key, value);
+     */
+    duckdb_destroy_logical_type(&key_logical_type);
+    duckdb_destroy_logical_type(&value_logical_type);
+    return hash;
+}
+
+static VALUE vector_struct(duckdb_logical_type ty, duckdb_vector vector, idx_t row_idx) {
+    VALUE hash = rb_hash_new();
+    VALUE value = Qnil;
+    VALUE key = Qnil;
+    char *p;
+
+    idx_t child_count = duckdb_struct_type_child_count(ty);
+
+    for (idx_t i = 0; i < child_count; ++i) {
+        p = duckdb_struct_type_child_name(ty, i);
+        if (p) {
+            key = rb_str_new2(p);
+            // FIXME
+            // How to get Struct values?
+            // value = ???
+            // duckdb_vector child_vector = duckdb_struct_vector_get_child(vector, i);
+            // VALUE value = vector_value(child_vector, i);
+            rb_hash_aset(hash, key, value);
+            duckdb_free(p);
+        }
+    }
+
+    return hash;
+}
+
+static VALUE vector_uuid(void* vector_data, idx_t row_idx) {
+    duckdb_hugeint hugeint = ((duckdb_hugeint *)vector_data)[row_idx];
+    VALUE mConverter = rb_const_get(mDuckDB, rb_intern("Converter"));
+    return rb_funcall(mConverter, rb_intern("_to_uuid_from_vector"), 2,
+            ULL2NUM(hugeint.lower),
+            LL2NUM(hugeint.upper)
+            );
+}
+
+static VALUE vector_value(duckdb_vector vector, idx_t row_idx) {
+    uint64_t *validity;
+    duckdb_logical_type ty;
+    duckdb_type type_id;
+    void* vector_data;
+    VALUE obj = Qnil;
+
+    validity = duckdb_vector_get_validity(vector);
+    if (!duckdb_validity_row_is_valid(validity, row_idx)) {
+        return Qnil;
+    }
+
+    ty = duckdb_vector_get_column_type(vector);
+    type_id = duckdb_get_type_id(ty);
+    vector_data = duckdb_vector_get_data(vector);
+
+    switch(type_id) {
+        case DUCKDB_TYPE_INVALID:
+            obj = Qnil;
+            break;
+        case DUCKDB_TYPE_BOOLEAN:
+            obj = (((bool*) vector_data)[row_idx]) ? Qtrue : Qfalse;
+            break;
+        case DUCKDB_TYPE_TINYINT:
+            obj = INT2FIX(((int8_t *) vector_data)[row_idx]);
+            break;
+        case DUCKDB_TYPE_SMALLINT:
+            obj = INT2FIX(((int16_t *) vector_data)[row_idx]);
+            break;
+        case DUCKDB_TYPE_INTEGER:
+            obj = INT2NUM(((int32_t *) vector_data)[row_idx]);
+            break;
+        case DUCKDB_TYPE_BIGINT:
+            obj = LL2NUM(((int64_t *) vector_data)[row_idx]);
+            break;
+        case DUCKDB_TYPE_HUGEINT:
+            obj = vector_hugeint(vector_data, row_idx);
+            break;
+        case DUCKDB_TYPE_FLOAT:
+            obj = DBL2NUM((((float *) vector_data)[row_idx]));
+            break;
+        case DUCKDB_TYPE_DOUBLE:
+            obj = DBL2NUM((((double *) vector_data)[row_idx]));
+            break;
+        case DUCKDB_TYPE_DATE:
+            obj = vector_date(vector_data, row_idx);
+            break;
+        case DUCKDB_TYPE_TIMESTAMP:
+            obj = vector_timestamp(vector_data, row_idx);
+            break;
+        case DUCKDB_TYPE_INTERVAL:
+            obj = vector_interval(vector_data, row_idx);
+            break;
+        case DUCKDB_TYPE_VARCHAR:
+            obj = vector_varchar(vector_data, row_idx);
+            break;
+        case DUCKDB_TYPE_BLOB:
+            obj = vector_blob(vector_data, row_idx);
+            break;
+        case DUCKDB_TYPE_DECIMAL:
+            obj = vector_decimal(ty, vector_data, row_idx);
+            break;
+        case DUCKDB_TYPE_ENUM:
+            obj = vector_enum(ty, vector_data, row_idx);
+            break;
+        case DUCKDB_TYPE_LIST:
+            obj = vector_list(ty, vector_data, row_idx);
+            break;
+        case DUCKDB_TYPE_MAP:
+            obj = vector_map(ty, vector_data, row_idx);
+            break;
+        case DUCKDB_TYPE_STRUCT:
+            obj = vector_struct(ty, vector_data, row_idx);
+            break;
+        case DUCKDB_TYPE_UUID:
+            obj = vector_uuid(vector_data, row_idx);
+            break;
+        default:
+            rb_warn("Unknown type %d", type_id);
+            obj = Qnil;
+    }
+
+    duckdb_destroy_logical_type(&ty);
+    return obj;
+}
+
+static VALUE duckdb_result_chunk_each(VALUE oDuckDBResult) {
+    rubyDuckDBResult *ctx;
+    VALUE row;
+    idx_t col_count;
+    idx_t row_count;
+    idx_t chunk_count;
+    idx_t col_idx;
+    idx_t row_idx;
+    idx_t chunk_idx;
+    duckdb_data_chunk chunk;
+    duckdb_vector vector;
+    VALUE val;
+
+    TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
+
+    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);
+        row_count = duckdb_data_chunk_get_size(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);
+                val = vector_value(vector, row_idx);
+                rb_ary_store(row, col_idx, val);
+            }
+            rb_yield(row);
+        }
+        duckdb_destroy_data_chunk(&chunk);
+    }
+    return Qnil;
+}
+#endif
+
 void init_duckdb_result(void) {
     cDuckDBResult = rb_define_class_under(mDuckDB, "Result", rb_cObject);
     rb_define_alloc_func(cDuckDBResult, allocate);
@@ -428,4 +737,7 @@ void init_duckdb_result(void) {
     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);
+#ifdef HAVE_DUCKDB_H_GE_V080
+    rb_define_method(cDuckDBResult, "chunk_each", duckdb_result_chunk_each, 0);
+#endif
 }

data/ext/duckdb/ruby-duckdb.h

@@ -4,14 +4,14 @@
 #include "ruby.h"
 #include <duckdb.h>
 
-#ifdef HAVE_DUCKDB_VALUE_STRING
-#define HAVE_DUCKDB_H_GE_V060 1
-#endif
-
 #ifdef HAVE_DUCKDB_EXTRACT_STATEMENTS
 #define HAVE_DUCKDB_H_GE_V070 1
 #endif
 
+#ifdef HAVE_DUCKDB_STRING_IS_INLINED
+#define HAVE_DUCKDB_H_GE_V080 1
+#endif
+
 #include "./error.h"
 #include "./database.h"
 #include "./connection.h"

data/lib/duckdb/converter.rb

@@ -1,8 +1,51 @@
 # frozen_string_literal: true
 
+require 'date'
+
 module DuckDB
   module Converter
     HALF_HUGEINT = 1 << 64
+    FLIP_HUGEINT = 1 << 63
+
+    module_function
+
+    def _to_date(year, month, day)
+      Date.new(year, month, day)
+    end
+
+    def _to_time(year, month, day, hour, minute, second, microsecond)
+      Time.local(year, month, day, hour, minute, second, microsecond)
+    end
+
+    def _to_hugeint_from_vector(lower, upper)
+      (upper * HALF_HUGEINT) + lower
+    end
+
+    def _to_decimal_from_vector(_width, scale, lower, upper)
+      v = _to_hugeint_from_vector(lower, upper).to_s
+      v[-scale, 0] = '.'
+      BigDecimal(v)
+    end
+
+    def _to_interval_from_vector(months, days, micros)
+      hash = { year: 0, month: 0, day: 0, hour: 0, min: 0, sec: 0, usec: 0 }
+      hash[:year] = months / 12
+      hash[:month] = months % 12
+      hash[:day] = days
+      hash[:hour] = micros / 3_600_000_000
+      hash[:min] = (micros % 3_600_000_000) / 60_000_000
+      hash[:sec] = (micros % 60_000_000) / 1_000_000
+      hash[:usec] = micros % 1_000_000
+      hash
+    end
+
+    def _to_uuid_from_vector(lower, upper)
+      upper = upper ^ FLIP_HUGEINT
+      upper += HALF_HUGEINT if upper.negative?
+
+      str = _to_hugeint_from_vector(lower, upper).to_s(16).rjust(32, '0')
+      "#{str[0, 8]}-#{str[8, 4]}-#{str[12, 4]}-#{str[16, 4]}-#{str[20, 12]}"
+    end
 
     private
 

data/lib/duckdb/result.rb

@@ -42,11 +42,27 @@ module DuckDB
     alias column_size column_count
     alias row_size row_count
 
+    def self.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)
+
+      @use_chunk_each = val
+    end
+
+    def self.use_chunk_each?
+      !!@use_chunk_each
+    end
+
     def each
-      return to_enum { row_size } unless block_given?
+      if self.class.use_chunk_each?
+        return chunk_each unless block_given?
+
+        chunk_each { |row| yield row }
+      else
+        return to_enum { row_size } unless block_given?
 
-      row_count.times do |row_index|
-        yield row(row_index)
+        row_count.times do |row_index|
+          yield row(row_index)
+        end
       end
     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.8.0'.freeze
+  VERSION = '0.8.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: duckdb
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.8.1
 platform: ruby
 authors:
 - Masaki Suketa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-05-20 00:00:00.000000000 Z
+date: 2023-06-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler