duckdb 1.0.0.0 → 1.0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ded07680dcaaa7309ed8578e6bd5d0a1e217b0c803f8527679e62e254aaea412
-  data.tar.gz: d2ff3d9a66b1487d867a95129a5c4fff3b4c01ed90198772d2a62b299c88bfca
+  metadata.gz: 2a632e159017449943e06edae0808189967be14845c29b479cb77a0d9e6b9da7
+  data.tar.gz: ec7b9c0f6d34aa943436e9525e914759dbd775d8c9a02b1eff991e2a03ade249
 SHA512:
-  metadata.gz: 253d068a5c17894a482346897f499e06a79ed9741250367e76d306d3828bfdce385379bd091528ae119fa5b1d0c7a83378cb84043477f1d6d21d86d09c00cd88
-  data.tar.gz: 2c554bdd675fea28561ed291dc28e5b660ef85a7d737d6cd69450832aa3af6a84eb94ad6a55a922828841ee9c9f802a4f86734692afd35b3a2bde4c2d6edb7e7
+  metadata.gz: e50c031a4d9f38a87eb77996c90f90a36c4c5f840694bad4a7ce79dcf3d2e439b30fee8e41a21522285ff7db5293e6fa059186c958f7fbed99089455b4ea04db
+  data.tar.gz: 65b7187a73f43b89a8ec8997edcce562af456e3b89f697b4e25c23ae114ed712916643d39c81ef323a1b47b6ac4783e384c53477d177a9d73271859e31c0f970

data/.github/workflows/test_on_macos.yml

@@ -15,7 +15,7 @@ jobs:
     runs-on: macos-latest
     strategy:
       matrix:
-        ruby: ['3.0.7', '3.1.6', '3.2.4', '3.3.2', '3.4.0-preview1', 'head']
+        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:
@@ -45,11 +45,23 @@ jobs:
         cp -rip duckdb-tmp-v$DUCKDB_VERSION/build/release/src/*.dylib duckdb-v$DUCKDB_VERSION/build/release/src
         cp -rip duckdb-tmp-v$DUCKDB_VERSION/src/include duckdb-v$DUCKDB_VERSION/src/
 
-    - name: Build with Ruby ${{ matrix.ruby }}
+    - name: bundle install with Ruby ${{ matrix.ruby }}
       env:
         DUCKDB_VERSION: ${{ matrix.duckdb }}
       run: |
         bundle install --jobs 4 --retry 3
+
+    - name: Build test with DUCKDB_API_NO_DEPRECATED and Ruby ${{ matrix.ruby }}
+      env:
+        DUCKDB_VERSION: ${{ matrix.duckdb }}
+      run: |
+        env DUCKDB_API_NO_DEPRECATED=1 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/
+        bundle exec rake clean
+
+    - name: Build with Ruby ${{ matrix.ruby }}
+      env:
+        DUCKDB_VERSION: ${{ matrix.duckdb }}
+      run: |
         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 }}

data/.github/workflows/test_on_ubuntu.yml

@@ -15,7 +15,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby: ['3.0.7', '3.1.6', '3.2.4', '3.3.2', '3.4.0-preview1', 'head']
+        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:
@@ -45,11 +45,23 @@ 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 with Ruby ${{ matrix.ruby }}
+    - name: bundle install with Ruby ${{ matrix.ruby }}
       env:
         DUCKDB_VERSION: ${{ matrix.duckdb }}
       run: |
         bundle install --jobs 4 --retry 3
+
+    - name: Build test with DUCKDB_API_NO_DEPRECATED and Ruby ${{ matrix.ruby }}
+      env:
+        DUCKDB_VERSION: ${{ matrix.duckdb }}
+      run: |
+        env DUCKDB_API_NO_DEPRECATED=1 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/
+        bundle exec rake clean
+
+    - name: Build with Ruby ${{ matrix.ruby }}
+      env:
+        DUCKDB_VERSION: ${{ matrix.duckdb }}
+      run: |
         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 }}

data/.github/workflows/test_on_windows.yml

@@ -15,7 +15,7 @@ jobs:
     runs-on: windows-latest
     strategy:
       matrix:
-        ruby: ['3.0.7', '3.1.5', '3.2.4', '3.3.1', 'ucrt', 'mingw', 'mswin', 'head']
+        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:

data/CHANGELOG.md

@@ -4,6 +4,25 @@ All notable changes to this project will be documented in this file.
 
 ## Unreleased
 
+# 1.0.0.2 - 2024-06-23
+- DuckDB::Result supports TIMESTAMPTZ column type (only when DuckDB::Result.use_chunk_each is true).
+  - Supporting TIMESTAMPTZ is experimental.
+- DuckDB::Result supports TIMETZ column type (only when DuckDB::Result.use_chunk_each is true).
+- DuckDB::Result supports TIMESTAMP_NS column type (only when DuckDB::Result.use_chunk_each is true).
+- DuckDB::Result supports TIMESTAMP_MS column type (only when DuckDB::Result.use_chunk_each is true).
+- DuckDB::Result supports TIMESTAMP_S column type (only when DuckDB::Result.use_chunk_each is true).
+- DuckDB::Result supports STRUCT column type (only when DuckDB::Result.use_chunk_each is true).
+- DuckDB::Result supports MAP column type (only when DuckDB::Result.use_chunk_each is true).
+- DuckDB::Result supports UNION column type (only when DuckDB::Result.use_chunk_each is true).
+- DuckDB::Result supports BIT column type (only when DuckDB::Result.use_chunk_each is true).
+
+# 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.

data/Dockerfile

@@ -1,4 +1,4 @@
-ARG RUBY_VERSION=3.3.2
+ARG RUBY_VERSION=3.3.3
 FROM ruby:${RUBY_VERSION}
 
 ARG DUCKDB_VERSION=1.0.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    duckdb (1.0.0.0)
+    duckdb (1.0.0.2)
       bigdecimal (>= 3.1.4)
 
 GEM
@@ -10,11 +10,11 @@ GEM
     benchmark-ips (2.13.0)
     bigdecimal (3.1.8)
     mini_portile2 (2.8.7)
-    minitest (5.23.1)
-    nokogiri (1.16.5)
+    minitest (5.24.0)
+    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/extconf.rb

@@ -70,4 +70,6 @@ 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')
 
+$CFLAGS << ' -DDUCKDB_API_NO_DEPRECATED' if ENV['DUCKDB_API_NO_DEPRECATED']
+
 create_makefile('duckdb/duckdb_native')

data/ext/duckdb/result.c

@@ -13,6 +13,11 @@ static ID id__to_interval_from_vector;
 static ID id__to_hugeint_from_vector;
 static ID id__to_decimal_from_hugeint;
 static ID id__to_uuid_from_vector;
+static ID id__to_time_from_duckdb_timestamp_s;
+static ID id__to_time_from_duckdb_timestamp_ms;
+static ID id__to_time_from_duckdb_timestamp_ns;
+static ID id__to_time_from_duckdb_time_tz;
+static ID id__to_time_from_duckdb_timestamp_tz;
 
 static void deallocate(void *ctx);
 static VALUE allocate(VALUE klass);
@@ -62,11 +67,21 @@ 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_timestamp_s(void* vector_data, idx_t row_idx);
+static VALUE vector_timestamp_ms(void* vector_data, idx_t row_idx);
+static VALUE vector_timestamp_ns(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_array(duckdb_logical_type ty, duckdb_vector vector, idx_t row_idx);
+static VALUE vector_value_at(duckdb_vector vector, 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, void* vector_data, idx_t row_idx);
 static VALUE vector_struct(duckdb_logical_type ty, duckdb_vector vector, idx_t row_idx);
+static VALUE vector_union(duckdb_logical_type ty, duckdb_vector vector, void* vector_data, idx_t row_idx);
+static VALUE vector_bit(void* vector_data, idx_t row_idx);
+static VALUE vector_time_tz(void* vector_data, idx_t row_idx);
+static VALUE vector_timestamp_tz(void* vector_data, 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);
 
@@ -662,6 +677,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));
@@ -700,6 +723,27 @@ static VALUE vector_decimal(duckdb_logical_type ty, void* vector_data, idx_t row
                       );
 }
 
+static VALUE vector_timestamp_s(void* vector_data, idx_t row_idx) {
+    duckdb_timestamp data = ((duckdb_timestamp *)vector_data)[row_idx];
+    return rb_funcall(mDuckDBConverter, id__to_time_from_duckdb_timestamp_s, 1,
+                      LL2NUM(data.micros)
+                      );
+}
+
+static VALUE vector_timestamp_ms(void* vector_data, idx_t row_idx) {
+    duckdb_timestamp data = ((duckdb_timestamp *)vector_data)[row_idx];
+    return rb_funcall(mDuckDBConverter, id__to_time_from_duckdb_timestamp_ms, 1,
+                      LL2NUM(data.micros)
+                      );
+}
+
+static VALUE vector_timestamp_ns(void* vector_data, idx_t row_idx) {
+    duckdb_timestamp data = ((duckdb_timestamp *)vector_data)[row_idx];
+    return rb_funcall(mDuckDBConverter, id__to_time_from_duckdb_timestamp_ns, 1,
+                      LL2NUM(data.micros)
+                      );
+}
+
 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;
@@ -721,97 +765,38 @@ 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 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);
+    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);
 
-    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);
-        }
+    ary = rb_ary_new2(size);
+    for (idx_t i = bgn; i < end; ++i) {
+        value = vector_value_at(child, child_logical_type, i);
+        rb_ary_store(ary, i - bgn, value);
     }
 
-    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, id__to_uuid_from_vector, 2,
-                      ULL2NUM(hugeint.lower),
-                      LL2NUM(hugeint.upper)
-                      );
+    duckdb_destroy_logical_type(&child_logical_type);
+    return ary;
 }
 
-static VALUE vector_value(duckdb_vector vector, idx_t row_idx) {
+static VALUE vector_value_at(duckdb_vector vector, duckdb_logical_type element_type, idx_t index) {
     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)) {
+    if (!duckdb_validity_row_is_valid(validity, index)) {
         return Qnil;
     }
 
-    ty = duckdb_vector_get_column_type(vector);
-    type_id = duckdb_get_type_id(ty);
+    type_id = duckdb_get_type_id(element_type);
     vector_data = duckdb_vector_get_data(vector);
 
     switch(type_id) {
@@ -819,82 +804,283 @@ static VALUE vector_value(duckdb_vector vector, idx_t row_idx) {
             obj = Qnil;
             break;
         case DUCKDB_TYPE_BOOLEAN:
-            obj = (((bool*) vector_data)[row_idx]) ? Qtrue : Qfalse;
+            obj = (((bool*) vector_data)[index]) ? Qtrue : Qfalse;
             break;
         case DUCKDB_TYPE_TINYINT:
-            obj = INT2FIX(((int8_t *) vector_data)[row_idx]);
+            obj = INT2FIX(((int8_t *) vector_data)[index]);
             break;
         case DUCKDB_TYPE_SMALLINT:
-            obj = INT2FIX(((int16_t *) vector_data)[row_idx]);
+            obj = INT2FIX(((int16_t *) vector_data)[index]);
             break;
         case DUCKDB_TYPE_INTEGER:
-            obj = INT2NUM(((int32_t *) vector_data)[row_idx]);
+            obj = INT2NUM(((int32_t *) vector_data)[index]);
             break;
         case DUCKDB_TYPE_BIGINT:
-            obj = LL2NUM(((int64_t *) vector_data)[row_idx]);
+            obj = LL2NUM(((int64_t *) vector_data)[index]);
             break;
         case DUCKDB_TYPE_UTINYINT:
-            obj = INT2FIX(((uint8_t *) vector_data)[row_idx]);
+            obj = INT2FIX(((uint8_t *) vector_data)[index]);
             break;
         case DUCKDB_TYPE_USMALLINT:
-            obj = INT2FIX(((uint16_t *) vector_data)[row_idx]);
+            obj = INT2FIX(((uint16_t *) vector_data)[index]);
             break;
         case DUCKDB_TYPE_UINTEGER:
-            obj = UINT2NUM(((uint32_t *) vector_data)[row_idx]);
+            obj = UINT2NUM(((uint32_t *) vector_data)[index]);
             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);
+            obj = ULL2NUM(((uint64_t *) vector_data)[index]);
             break;
         case DUCKDB_TYPE_FLOAT:
-            obj = DBL2NUM((((float *) vector_data)[row_idx]));
+            obj = DBL2NUM((((float *) vector_data)[index]));
             break;
         case DUCKDB_TYPE_DOUBLE:
-            obj = DBL2NUM((((double *) vector_data)[row_idx]));
-            break;
-        case DUCKDB_TYPE_DATE:
-            obj = vector_date(vector_data, row_idx);
+            obj = DBL2NUM((((double *) vector_data)[index]));
             break;
         case DUCKDB_TYPE_TIMESTAMP:
-            obj = vector_timestamp(vector_data, row_idx);
+            obj = vector_timestamp(vector_data, index);
+            break;
+        case DUCKDB_TYPE_DATE:
+            obj = vector_date(vector_data, index);
             break;
         case DUCKDB_TYPE_TIME:
-            obj = vector_time(vector_data, row_idx);
+            obj = vector_time(vector_data, index);
             break;
         case DUCKDB_TYPE_INTERVAL:
-            obj = vector_interval(vector_data, row_idx);
+            obj = vector_interval(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_VARCHAR:
-            obj = vector_varchar(vector_data, row_idx);
+            obj = vector_varchar(vector_data, index);
             break;
         case DUCKDB_TYPE_BLOB:
-            obj = vector_blob(vector_data, row_idx);
+            obj = vector_blob(vector_data, index);
             break;
         case DUCKDB_TYPE_DECIMAL:
-            obj = vector_decimal(ty, vector_data, row_idx);
+            obj = vector_decimal(element_type, vector_data, index);
+            break;
+        case DUCKDB_TYPE_TIMESTAMP_S:
+            obj = vector_timestamp_s(vector_data, index);
+            break;
+        case DUCKDB_TYPE_TIMESTAMP_MS:
+            obj = vector_timestamp_ms(vector_data, index);
+            break;
+        case DUCKDB_TYPE_TIMESTAMP_NS:
+            obj = vector_timestamp_ns(vector_data, index);
             break;
         case DUCKDB_TYPE_ENUM:
-            obj = vector_enum(ty, vector_data, row_idx);
+            obj = vector_enum(element_type, vector_data, index);
             break;
         case DUCKDB_TYPE_LIST:
-            obj = vector_list(ty, vector_data, row_idx);
+            obj = vector_list(element_type, vector, vector_data, index);
+            break;
+        case DUCKDB_TYPE_STRUCT:
+            obj = vector_struct(element_type, vector, index);
             break;
         case DUCKDB_TYPE_MAP:
-            obj = vector_map(ty, vector_data, row_idx);
+            obj = vector_map(element_type, vector, vector_data, index);
             break;
-        case DUCKDB_TYPE_STRUCT:
-            obj = vector_struct(ty, vector_data, row_idx);
+        case DUCKDB_TYPE_ARRAY:
+            obj = vector_array(element_type, vector, index);
             break;
         case DUCKDB_TYPE_UUID:
-            obj = vector_uuid(vector_data, row_idx);
+            obj = vector_uuid(vector_data, index);
+            break;
+        case DUCKDB_TYPE_UNION:
+            obj = vector_union(element_type, vector, vector_data, index);
+            break;
+        case DUCKDB_TYPE_BIT:
+            obj = vector_bit(vector_data, index);
+            break;
+        case DUCKDB_TYPE_TIME_TZ:
+            obj = vector_time_tz(vector_data, index);
+            break;
+        case DUCKDB_TYPE_TIMESTAMP_TZ:
+            obj = vector_timestamp_tz(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 value = Qnil;
+    idx_t i;
+
+    duckdb_logical_type child_logical_type = duckdb_list_type_child_type(ty);
+
+    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);
+
+    duckdb_vector child = duckdb_list_vector_get_child(vector);
+
+    for (i = bgn; i < end; ++i) {
+        value = vector_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_map(duckdb_logical_type ty, duckdb_vector vector, void* vector_data, idx_t row_idx) {
+    VALUE hash = rb_hash_new();
+    VALUE key = Qnil;
+    VALUE value = Qnil;
+
+    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_list_entry list_entry = ((duckdb_list_entry *)vector_data)[row_idx];
+
+    idx_t bgn = list_entry.offset;
+    idx_t end = bgn + list_entry.length;
+
+    duckdb_vector child = duckdb_list_vector_get_child(vector);
+    duckdb_vector key_vector = duckdb_struct_vector_get_child(child, 0);
+    duckdb_vector value_vector = duckdb_struct_vector_get_child(child, 1);
+
+    for (idx_t i = bgn; i < end; ++i) {
+        key = vector_value_at(key_vector, key_logical_type, i);
+        value = vector_value_at(value_vector, value_logical_type, i);
+        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;
+    duckdb_vector child;
+    duckdb_logical_type child_type;
+    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 = ID2SYM(rb_intern_const(p));
+            child = duckdb_struct_vector_get_child(vector, i);
+            child_type = duckdb_struct_type_child_type(ty, i);
+            value = vector_value_at(child, child_type, row_idx);
+            rb_hash_aset(hash, key, value);
+            duckdb_destroy_logical_type(&child_type);
+            duckdb_free(p);
+        }
+    }
+
+    return hash;
+}
+
+static VALUE vector_union(duckdb_logical_type ty, duckdb_vector vector, void* vector_data, idx_t row_idx){
+    VALUE value = Qnil;
+    duckdb_vector type_vector = duckdb_struct_vector_get_child(vector, 0);
+    void *data = duckdb_vector_get_data(type_vector);
+    uint8_t index = ((int8_t *)data)[row_idx];
+
+    duckdb_logical_type  child_type = duckdb_union_type_member_type(ty, index);
+
+    duckdb_vector vector_value = duckdb_struct_vector_get_child(vector, index + 1);
+    value = vector_value_at(vector_value, child_type, row_idx);
+    duckdb_destroy_logical_type(&child_type);
+    return value;
+}
+
+static VALUE str_concat_byte(VALUE str, unsigned char byte, int offset) {
+    char x[8];
+    char *p = x;
+    for (int j = 7; j >=0; j--) {
+        if (byte % 2 == 1) {
+            x[j] = '1';
+        } else {
+            x[j] = '0';
+        }
+        byte = (byte >> 1);
+    }
+    if (offset > 0 && offset < 8) {
+        p = x + offset;
+    }
+    return rb_str_cat(str, p, 8 - offset);
+}
+
+static VALUE bytes_to_string(char *bytes, uint32_t length, int offset) {
+    VALUE str = rb_str_new_literal("");
+    str = str_concat_byte(str, bytes[0], offset);
+    for (uint32_t i = 1; i < length; i++) {
+        str = str_concat_byte(str, bytes[i], 0);
+    }
+    return str;
+}
+
+static VALUE vector_bit(void* vector_data, idx_t row_idx) {
+    duckdb_string_t s = (((duckdb_string_t *)vector_data)[row_idx]);
+    char *p;
+    int offset;
+    uint32_t length;
+    VALUE str = Qnil;
+
+    if(duckdb_string_is_inlined(s)) {
+        length = s.value.inlined.length - 1;
+        p = &s.value.inlined.inlined[1];
+        offset = s.value.inlined.inlined[0];
+        str = bytes_to_string(p, length, offset);
+    } else {
+        length = s.value.pointer.length - 1;
+        p = &s.value.pointer.ptr[1];
+        offset = s.value.pointer.ptr[0];
+        str = bytes_to_string(p, length, offset);
+    }
+    return str;
+}
+
+static VALUE vector_time_tz(void* vector_data, idx_t row_idx) {
+    duckdb_time_tz_struct data = duckdb_from_time_tz(((duckdb_time_tz *)vector_data)[row_idx]);
+    return rb_funcall(mDuckDBConverter, id__to_time_from_duckdb_time_tz, 5,
+                      INT2FIX(data.time.hour),
+                      INT2FIX(data.time.min),
+                      INT2FIX(data.time.sec),
+                      INT2NUM(data.time.micros),
+                      INT2NUM(data.offset)
+                      );
+}
+
+static VALUE vector_timestamp_tz(void* vector_data, idx_t row_idx) {
+    duckdb_time_tz data = ((duckdb_time_tz *)vector_data)[row_idx];
+    return rb_funcall(mDuckDBConverter, id__to_time_from_duckdb_timestamp_tz, 1,
+                      ULL2NUM(data.bits)
+                      );
+}
+
+static VALUE vector_uuid(void* vector_data, idx_t row_idx) {
+    duckdb_hugeint hugeint = ((duckdb_hugeint *)vector_data)[row_idx];
+    return rb_funcall(mDuckDBConverter, id__to_uuid_from_vector, 2,
+                      ULL2NUM(hugeint.lower),
+                      LL2NUM(hugeint.upper)
+                      );
+}
+
+static VALUE vector_value(duckdb_vector vector, idx_t row_idx) {
+    duckdb_logical_type ty;
+    VALUE obj = Qnil;
+
+    ty = duckdb_vector_get_column_type(vector);
+
+    obj = vector_value_at(vector, ty, row_idx);
+
     duckdb_destroy_logical_type(&ty);
     return obj;
 }
@@ -908,6 +1094,11 @@ void rbduckdb_init_duckdb_result(void) {
     id__to_hugeint_from_vector = rb_intern("_to_hugeint_from_vector");
     id__to_decimal_from_hugeint = rb_intern("_to_decimal_from_hugeint");
     id__to_uuid_from_vector = rb_intern("_to_uuid_from_vector");
+    id__to_time_from_duckdb_timestamp_s = rb_intern("_to_time_from_duckdb_timestamp_s");
+    id__to_time_from_duckdb_timestamp_ms = rb_intern("_to_time_from_duckdb_timestamp_ms");
+    id__to_time_from_duckdb_timestamp_ns = rb_intern("_to_time_from_duckdb_timestamp_ns");
+    id__to_time_from_duckdb_time_tz = rb_intern("_to_time_from_duckdb_time_tz");
+    id__to_time_from_duckdb_timestamp_tz = rb_intern("_to_time_from_duckdb_timestamp_tz");
 
     rb_define_alloc_func(cDuckDBResult, allocate);
 

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

@@ -10,6 +10,8 @@ module DuckDB
     HALF_HUGEINT_BIT = 64
     HALF_HUGEINT = 1 << HALF_HUGEINT_BIT
     FLIP_HUGEINT = 1 << 63
+    EPOCH = Time.local(1970, 1, 1)
+    EPOCH_UTC = Time.new(1970, 1, 1, 0, 0, 0, 0)
 
     module_function
 
@@ -33,6 +35,63 @@ module DuckDB
       )
     end
 
+    def _to_time_from_duckdb_timestamp_s(time)
+      EPOCH + time
+    end
+
+    def _to_time_from_duckdb_timestamp_ms(time)
+      tm = EPOCH + (time / 1000)
+      Time.local(tm.year, tm.month, tm.day, tm.hour, tm.min, tm.sec, time % 1000 * 1000)
+    end
+
+    def _to_time_from_duckdb_timestamp_ns(time)
+      tm = EPOCH + (time / 1_000_000_000)
+      Time.local(tm.year, tm.month, tm.day, tm.hour, tm.min, tm.sec, time % 1_000_000_000 / 1000)
+    end
+
+    def _to_time_from_duckdb_time_tz(hour, min, sec, micro, timezone)
+      sign = '+'
+      if timezone.negative?
+        timezone = -timezone
+        sign = '-'
+      end
+
+      tzhour = timezone / 3600
+      tzmin = (timezone % 3600) / 60
+
+      Time.parse(
+        format(
+          '%<hour>02d:%<min>02d:%<sec>02d.%<micro>06d%<sign>s%<tzhour>02d:%<tzmin>02d',
+          hour: hour,
+          min: min,
+          sec: sec,
+          micro: micro,
+          sign: sign,
+          tzhour: tzhour,
+          tzmin: tzmin
+        )
+      )
+    end
+
+    def _to_time_from_duckdb_timestamp_tz(bits)
+      micro = bits % 1_000_000
+      sec = (bits / 1_000_000)
+      time = EPOCH_UTC + sec
+
+      Time.parse(
+        format(
+          '%<year>04d-%<mon>02d-%<day>02d %<hour>02d:%<min>02d:%<sec>02d.%<micro>06d +0000',
+          year: time.year,
+          mon: time.month,
+          day: time.day,
+          hour: time.hour,
+          min: time.min,
+          sec: time.sec,
+          micro: micro
+        )
+      )
+    end
+
     def _to_hugeint_from_vector(lower, upper)
       (upper << HALF_HUGEINT_BIT) + 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 = '1.0.0.0'
+  VERSION = '1.0.0.2'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: duckdb
 version: !ruby/object:Gem::Version
-  version: 1.0.0.0
+  version: 1.0.0.2
 platform: ruby
 authors:
 - Masaki Suketa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-06-08 00:00:00.000000000 Z
+date: 2024-06-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -181,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.