duckdb 0.8.0 → 0.8.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e8040d795ad975b4472fe439aa2cfb403ad5f24f9c602bca7dbdf6103c37b65
-  data.tar.gz: 82cd61d78fec67f62be8ad0280305b224ae605ffd2ea453855168dcaa77f4d32
+  metadata.gz: a81125e254f14fe183bff2a5e471274ed995f22dcb7b3b62470c222bc4e69568
+  data.tar.gz: 2c84267e72092bde6c2948a3b02d1eeb7ae5ad7a941bdf7b134b4ecc2076415f
 SHA512:
-  metadata.gz: b54b53aa6ec96ef9e8607bea7f96b8ef9fc7c4e2189675e575eeabdfaa2d608320c02ac86dc8ca7453cd9d314ceb943241a0a858689c85b8221374ff5dc6e00e
-  data.tar.gz: 86936495132694846dd8931998c9f716d405571dd34842f6f8563ad531f2e0b8fb678f4477cff9ec33a1c0d3affc615884a4dd8063909f57cb8e4a1da2a0434f
+  metadata.gz: af45ace99bfb16d3d880a47236ee95c6ba8dea03c32f734f1b0491f4f996b862578570501ebc70a00d9fa24c18180883f4961839f7df43b077b7cc2ea1c5bff3
+  data.tar.gz: d0307462d6e9be514087c6eb31750557896f792b4eaa0aa6d2558162eacbbd3ffc7d7289fcf392e11246e0dd55daa2a3c50f534f917749a92a038547d4453d64

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,40 @@
 # ChangeLog
 
+# 0.8.1.1
+- DuckDB::Result#chunk_each supports:
+  - UTINYINT
+  - USMALLINT
+  - UINTEGER
+  - UBIGINT
+- fix memory leak of:
+  - `DuckDB::Result#_enum_dictionary_value`
+  - `DuckDB::Result#_enum_dictionary_size`
+  - `DuckDB::Result#_enum_internal_type`
+
+# 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

@@ -7,3 +7,7 @@ if /(linux|darwin)/ =~ RUBY_PLATFORM
   gem 'benchmark-ips'
   gem 'stackprof'
 end
+
+if /linux/ =~ RUBY_PLATFORM
+  gem 'ruby_memcheck'
+end

data/Gemfile.lock

@@ -1,17 +1,26 @@
 PATH
   remote: .
   specs:
-    duckdb (0.8.0)
+    duckdb (0.8.1.1)
 
 GEM
   remote: https://rubygems.org/
   specs:
     benchmark-ips (2.12.0)
-    minitest (5.18.0)
+    mini_portile2 (2.8.2)
+    minitest (5.18.1)
+    nokogiri (1.15.2)
+      mini_portile2 (~> 2.8.2)
+      racc (~> 1.4)
+    nokogiri (1.15.2-x86_64-linux)
+      racc (~> 1.4)
+    racc (1.7.1)
     rake (13.0.6)
-    rake-compiler (1.2.1)
+    rake-compiler (1.2.3)
       rake
-    stackprof (0.2.24)
+    ruby_memcheck (1.3.2)
+      nokogiri
+    stackprof (0.2.25)
 
 PLATFORMS
   ruby
@@ -24,7 +33,8 @@ DEPENDENCIES
   minitest (~> 5.0)
   rake (~> 13.0)
   rake-compiler
+  ruby_memcheck
   stackprof
 
 BUNDLED WITH
-   2.4.9
+   2.4.10

data/Rakefile

@@ -1,19 +1,41 @@
-require "bundler/gem_tasks"
-require "rake/testtask"
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+ruby_memcheck_avaiable = begin
+                           require 'ruby_memcheck'
+                           true
+                         rescue LoadError
+                           false
+                         end
 
-Rake::TestTask.new(:test) do |t|
-  t.libs << "test"
-  t.libs << "lib"
-  t.test_files = FileList["test/**/*_test.rb"]
+
+if ruby_memcheck_avaiable
+  RubyMemcheck.config(
+    binary_name: 'duckdb/duckdb_native',
+    valgrind_options: ['--max-threads=1000']
+  )
+end
+
+test_config = lambda do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+Rake::TestTask.new(test: :compile, &test_config)
+
+if ruby_memcheck_avaiable
+  namespace :test do
+    RubyMemcheck::TestTask.new(valgrind: :compile, &test_config)
+  end
 end
 
-require "rake/extensiontask"
+require 'rake/extensiontask'
 
-task :build => :compile
+task build: :compile
 
-Rake::ExtensionTask.new("duckdb_native") do |ext|
+Rake::ExtensionTask.new('duckdb_native') do |ext|
   ext.ext_dir = 'ext/duckdb'
-  ext.lib_dir = "lib/duckdb"
+  ext.lib_dir = 'lib/duckdb'
 end
 
-task :default => [:clobber, :compile, :test]
+task default: %i[clobber compile test]

data/benchmark/get_converter_module_ips.rb

@@ -0,0 +1,26 @@
+# 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_val HUGEINT)')
+con.query('INSERT INTO hugeints VALUES (1234567890123456789012345678901234)')
+result = con.query('SELECT hugeint_val FROM hugeints')
+
+Benchmark.ips do |x|
+  x.report('hugeint_convert') { result.each.to_a[0][0] }
+end
+
+__END__
+
+## before
+```
+✦ ❯ ruby benchmark/get_converter_module_ips.rb
+Warming up --------------------------------------
+     hugeint_convert    45.376k i/100ms
+Calculating -------------------------------------
+     hugeint_convert    552.127k (± 0.7%) i/s -      2.768M in   5.013483s
+```

data/ext/duckdb/converter.h

@@ -0,0 +1,6 @@
+#ifndef RUBY_DUCKDB_CONVERTER_H
+#define RUBY_DUCKDB_CONVERTER_H
+
+void init_duckdb_converter(void);
+
+#endif

data/ext/duckdb/conveter.c

@@ -0,0 +1,7 @@
+#include "ruby-duckdb.h"
+
+VALUE mDuckDBConverter;
+
+void init_duckdb_converter(void) {
+    mDuckDBConverter = rb_define_module_under(mDuckDB, "Converter");
+}

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,5 @@ Init_duckdb_native(void) {
     init_duckdb_blob();
     init_duckdb_appender();
     init_duckdb_config();
-
+    init_duckdb_converter();
 }

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;
@@ -365,6 +362,7 @@ static VALUE duckdb_result__enum_internal_type(VALUE oDuckDBResult, VALUE col_id
     if (logical_type) {
         type = LL2NUM(duckdb_enum_internal_type(logical_type));
     }
+    duckdb_destroy_logical_type(&logical_type);
     return type;
 }
 
@@ -378,6 +376,7 @@ static VALUE duckdb_result__enum_dictionary_size(VALUE oDuckDBResult, VALUE col_
     if (logical_type) {
         size = UINT2NUM(duckdb_enum_dictionary_size(logical_type));
     }
+    duckdb_destroy_logical_type(&logical_type);
     return size;
 }
 
@@ -396,6 +395,7 @@ static VALUE duckdb_result__enum_dictionary_value(VALUE oDuckDBResult, VALUE col
             duckdb_free(p);
         }
     }
+    duckdb_destroy_logical_type(&logical_type);
     return value;
 }
 
@@ -403,6 +403,324 @@ 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]);
+
+    return rb_funcall(mDuckDBConverter, 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]);
+    return rb_funcall(mDuckDBConverter, 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];
+    return rb_funcall(mDuckDBConverter, 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];
+    return rb_funcall(mDuckDBConverter, 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);
+    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(mDuckDBConverter, 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];
+    return rb_funcall(mDuckDBConverter, 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_UTINYINT:
+            obj = INT2FIX(((uint8_t *) vector_data)[row_idx]);
+            break;
+        case DUCKDB_TYPE_USMALLINT:
+            obj = INT2FIX(((uint16_t *) vector_data)[row_idx]);
+            break;
+        case DUCKDB_TYPE_UINTEGER:
+            obj = UINT2NUM(((uint32_t *) vector_data)[row_idx]);
+            break;
+        case DUCKDB_TYPE_UBIGINT:
+            obj = ULL2NUM(((uint64_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 +746,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"
@@ -19,6 +19,7 @@
 #include "./column.h"
 #include "./prepared_statement.h"
 #include "./util.h"
+#include "./converter.h"
 
 #include "./blob.h"
 #include "./appender.h"
@@ -30,5 +31,6 @@ extern VALUE cDuckDBConnection;
 extern VALUE cDuckDBBlob;
 extern VALUE cDuckDBConfig;
 extern VALUE eDuckDBError;
+extern VALUE mDuckDBConverter;
 
 #endif

data/lib/duckdb/appender.rb

@@ -2,7 +2,7 @@
 
 require 'date'
 require 'time'
-require_relative './converter'
+require_relative 'converter'
 
 module DuckDB
   # The DuckDB::Appender encapsulates DuckDB Appender.
@@ -194,17 +194,9 @@ module DuckDB
       when TrueClass, FalseClass
         append_bool(value)
       when Time
-        if respond_to?(:append_timestamp)
-          append_timestamp(value)
-        else
-          append_varchar(value.strftime('%Y-%m-%d %H:%M:%S.%N'))
-        end
+        append_timestamp(value)
       when Date
-        if respond_to?(:append_date)
-          append_date(value)
-        else
-          append_varchar(value.strftime('%Y-%m-%d'))
-        end
+        append_date(value)
       else
         raise(DuckDB::Error, "not supported type #{value} (#{value.class})")
       end

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.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.1
 platform: ruby
 authors:
 - Masaki Suketa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-05-20 00:00:00.000000000 Z
+date: 2023-07-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -87,6 +87,7 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- benchmark/get_converter_module_ips.rb
 - benchmark/to_bigdecimal_ips.rb
 - benchmark/to_hugeint_ips.rb
 - benchmark/to_hugeint_profile.rb
@@ -104,6 +105,8 @@ files:
 - ext/duckdb/config.h
 - ext/duckdb/connection.c
 - ext/duckdb/connection.h
+- ext/duckdb/converter.h
+- ext/duckdb/conveter.c
 - ext/duckdb/database.c
 - ext/duckdb/database.h
 - ext/duckdb/duckdb.c