duckdb 0.7.1 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 469588c48fb9f9d16254cd6f78f3fd4ceb1e6886e3fc859a507d635542ba50fa
-  data.tar.gz: 1ccee32eb696806c13da87d5c8825965575575e83c45e466712a69bfa107547e
+  metadata.gz: dab5e8d5f3beafce29f2d545b736b34b3502f2f31120d1d7d0714fdb83512457
+  data.tar.gz: a73a7438ec5762af143b8590923b0fd3c54ec99926aa48b485346e943fe66916
 SHA512:
-  metadata.gz: ebd03d8e45cb57530924a62c94e02df312b6d93624c303a1f05fb1a886b9c92aaae208feaa4419774dc325ba4078c3d90b281819dbc695f0d5a37139c787a481
-  data.tar.gz: 6096e668ea12bd32950cea838844537ea3ed872398d944e88473f4efc9f9088320dc8f565cd62e9c48522596062a2034d3c89456afc4b2952df42d57492b0b2a
+  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.7', '3.0.5', '3.1.3', '3.2.1', 'head']
-        duckdb: ['0.7.1', '0.6.1']
+        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
@@ -52,11 +52,14 @@ jobs:
         cp duckdb-v$DUCKDB_VERSION/src/include/*.h /usr/local/include
         cp duckdb-v$DUCKDB_VERSION/build/release/src/*.dylib /usr/local/lib
 
-    - name: Build and test with Rake with Ruby ${{ matrix.ruby }}
+    - name: Build with Ruby ${{ matrix.ruby }}
       run: |
-        ruby -v
         bundle install --jobs 4 --retry 3
-        bundle exec rake
+        rake build
+
+    - name: run test with Ruby ${{ matrix.ruby }}
+      run: |
+        rake test
 
   post-test:
     name: All tests passed on macos

data/.github/workflows/test_on_ubuntu.yml

@@ -15,8 +15,8 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby: ['2.7.7', '3.0.5', '3.1.3', '3.2.1', 'head']
-        duckdb: ['0.7.1', '0.6.1']
+        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
@@ -45,13 +45,19 @@ jobs:
         cp -rip duckdb-tmp-v$DUCKDB_VERSION/build/release/src/*.so duckdb-v$DUCKDB_VERSION/build/release/src
         cp -rip duckdb-tmp-v$DUCKDB_VERSION/src/include duckdb-v$DUCKDB_VERSION/src/
 
-    - name: Build and test with Rake with Ruby ${{ matrix.ruby }}
+    - name: Build with Ruby ${{ matrix.ruby }}
       env:
         DUCKDB_VERSION: ${{ matrix.duckdb }}
       run: |
         gem install bundler
         bundle install --jobs 4 --retry 3
-        bundle exec rake -- --with-duckdb-include=${GITHUB_WORKSPACE}/duckdb-v${DUCKDB_VERSION}/src/include --with-duckdb-lib=${GITHUB_WORKSPACE}/duckdb-v${DUCKDB_VERSION}/build/release/src/
+        bundle exec rake build -- --with-duckdb-include=${GITHUB_WORKSPACE}/duckdb-v${DUCKDB_VERSION}/src/include --with-duckdb-lib=${GITHUB_WORKSPACE}/duckdb-v${DUCKDB_VERSION}/build/release/src/
+
+    - name: test with Ruby ${{ matrix.ruby }}
+      env:
+        DUCKDB_VERSION: ${{ matrix.duckdb }}
+      run: |
+        rake test
 
   post-test:
     name: All tests passed on Ubuntu

data/.github/workflows/test_on_windows.yml

@@ -15,8 +15,8 @@ jobs:
     runs-on: windows-latest
     strategy:
       matrix:
-        ruby: ['2.7.7', '3.0.5', '3.1.3', '3.2.1', 'ucrt', 'mingw', 'mswin', 'head']
-        duckdb: ['0.7.1', '0.6.1']
+        ruby: ['2.7.8', '3.0.6', '3.1.4', '3.2.2', 'ucrt', 'mingw', 'mswin', 'head']
+        duckdb: ['0.7.1', '0.8.1']
 
     steps:
     - uses: actions/checkout@v3

data/CHANGELOG.md

@@ -1,5 +1,38 @@
 # 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
+- add DuckDB::Result#_to_hugeint_internal
+
+## Breaking Change
+- DuckDB::Result returns BigDecimal object instead of String object if the column type is DECIMAL.
+
+# 0.7.1
 - bump duckdb to 0.7.1
 - fix docker build error on M1 Mac
 

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

@@ -2,3 +2,8 @@ source "https://rubygems.org"
 
 # Specify your gem's dependencies in duckdb.gemspec
 gemspec
+
+if /(linux|darwin)/ =~ RUBY_PLATFORM
+  gem 'benchmark-ips'
+  gem 'stackprof'
+end

data/Gemfile.lock

@@ -1,23 +1,30 @@
 PATH
   remote: .
   specs:
-    duckdb (0.7.1)
+    duckdb (0.8.1)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    minitest (5.17.0)
+    benchmark-ips (2.12.0)
+    minitest (5.18.1)
     rake (13.0.6)
-    rake-compiler (1.2.1)
+    rake-compiler (1.2.3)
       rake
+    stackprof (0.2.25)
 
 PLATFORMS
   ruby
   x86_64-linux
 
 DEPENDENCIES
+  benchmark-ips
   bundler (~> 2.3)
   duckdb!
   minitest (~> 5.0)
   rake (~> 13.0)
   rake-compiler
+  stackprof
+
+BUNDLED WITH
+   2.4.10

data/benchmark/to_bigdecimal_ips.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'duckdb'
+require 'benchmark/ips'
+
+db = DuckDB::Database.open
+con = db.connect
+con.query('CREATE TABLE decimals (decimal_value DECIMAL(38, 3))')
+con.query('INSERT INTO decimals VALUES (1234567890123.456)')
+result = con.query('SELECT decimal_value FROM decimals')
+
+Benchmark.ips do |x|
+  x.report('_to_decimal') { result.send(:_to_decimal, 0, 0) }
+  x.report('_to_decimal_internal') { result.send(:_to_decimal_internal, 0, 0) }
+end

data/benchmark/to_hugeint_ips.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'duckdb'
+require 'benchmark/ips'
+
+db = DuckDB::Database.open
+con = db.connect
+con.query('CREATE TABLE hugeints (hugeint_value HUGEINT)')
+con.query('INSERT INTO hugeints VALUES (123456789012345678901234567890123456789)')
+result = con.query('SELECT hugeint_value FROM hugeints')
+
+Benchmark.ips do |x|
+  x.report('_to_hugeint') { result.send(:_to_hugeint, 0, 0) }
+  x.report('_to_hugeint_internal') { result.send(:_to_hugeint_internal, 0, 0) }
+end

data/benchmark/to_hugeint_profile.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'duckdb'
+require 'stackprof'
+
+db = DuckDB::Database.open
+con = db.connect
+con.query('CREATE TABLE hugeints (hugeint_value HUGEINT)')
+con.query('INSERT INTO hugeints VALUES (123456789012345678901234567890123456789)')
+result = con.query('SELECT hugeint_value FROM hugeints')
+
+def profile(name, &block)
+  profile = StackProf.run(mode: :wall, interval: 1_000) do
+    2_000_000.times(&block)
+  end
+
+  result = StackProf::Report.new(profile)
+  puts
+  puts "=== #{name} ==="
+  result.print_text
+  puts
+end
+
+profile(:_to_hugeint) { result.send(:_to_hugeint, 0, 0) }
+profile(:_to_hugeint_internal) { result.send(:_to_hugeint_internal, 0, 0) }

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

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

data/lib/duckdb/column.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DuckDB
   class Column
     #

data/lib/duckdb/config.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DuckDB
   if defined?(DuckDB::Config)
     # The DuckDB::Config encapsulates DuckDB Configuration.

data/lib/duckdb/connection.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DuckDB
   # The DuckDB::Connection encapsulates connection with DuckDB database.
   #

data/lib/duckdb/converter.rb

@@ -1,6 +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/database.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DuckDB
   # The Database class encapsulates a DuckDB database.
   #

data/lib/duckdb/prepared_statement.rb

@@ -1,4 +1,5 @@
 require 'date'
+require 'bigdecimal'
 require_relative './converter'
 
 module DuckDB
@@ -192,6 +193,8 @@ module DuckDB
         bind_varchar(i, value.strftime('%Y-%m-%d %H:%M:%S.%N'))
       when Date
         bind_varchar(i, value.strftime('%Y-%m-%d'))
+      when BigDecimal
+        bind_varchar(i, value.to_s('F'))
       else
         raise(DuckDB::Error, "not supported type `#{value}` (#{value.class})")
       end

data/lib/duckdb/result.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+
 module DuckDB
   # The Result class encapsulates a execute result of DuckDB database.
   #
@@ -28,8 +32,9 @@ module DuckDB
       5 => :_to_bigint,
       10 => :_to_float,
       11 => :_to_double,
-      16 => :_to_hugeint,
+      16 => :_to_hugeint_internal,
       18 => :_to_blob,
+      19 => :_to_decimal_internal
     }
 
     ToRuby.default = :_to_string
@@ -37,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?
 
-      row_count.times do |row_index|
-        yield row(row_index)
+        chunk_each { |row| yield row }
+      else
+        return to_enum { row_size } unless block_given?
+
+        row_count.times do |row_index|
+          yield row(row_index)
+        end
       end
     end
 
@@ -70,5 +91,21 @@ module DuckDB
     def _to_hugeint(row, col)
       _to_string(row, col).to_i
     end
+
+    def _to_hugeint_internal(row, col)
+      lower, upper = __to_hugeint_internal(row, col)
+      upper * Converter::HALF_HUGEINT + lower
+    end
+
+    def _to_decimal(row, col)
+      BigDecimal(_to_string(row, col))
+    end
+
+    def _to_decimal_internal(row, col)
+      lower, upper, _width, scale = __to_decimal_internal(row, col)
+      v = (upper * Converter::HALF_HUGEINT + lower).to_s
+      v[-scale, 0] = '.'
+      BigDecimal(v)
+    end
   end
 end

data/lib/duckdb/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module DuckDB
   # The version string of ruby-duckdb.
   # Currently, ruby-duckdb is NOT semantic versioning.
-  VERSION = '0.7.1'.freeze
+  VERSION = '0.8.1'
 end

data/lib/duckdb.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'duckdb/duckdb_native'
 require 'duckdb/library_version'
 require 'duckdb/version'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: duckdb
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.8.1
 platform: ruby
 authors:
 - Masaki Suketa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-03-05 00:00:00.000000000 Z
+date: 2023-06-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -87,6 +87,9 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- benchmark/to_bigdecimal_ips.rb
+- benchmark/to_hugeint_ips.rb
+- benchmark/to_hugeint_profile.rb
 - bin/console
 - bin/setup
 - docker-compose.yml
@@ -148,7 +151,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.6
+rubygems_version: 3.4.10
 signing_key: 
 specification_version: 4
 summary: This module is Ruby binding for DuckDB database engine.