duckdb 1.0.0.1 → 1.0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ec35034af422ec8f64f8474e95321a72a635925227fa8b5c26b3a430a4283a6
-  data.tar.gz: 52fb59085c80865dd6c51a5f7cb93b0e3eb2940245b4df580040753d364bd989
+  metadata.gz: 2a632e159017449943e06edae0808189967be14845c29b479cb77a0d9e6b9da7
+  data.tar.gz: ec7b9c0f6d34aa943436e9525e914759dbd775d8c9a02b1eff991e2a03ade249
 SHA512:
-  metadata.gz: 00d69fe6df1f7acdb1fac1e8bce26b17d9d7f06802fb8a8ddb287f25831858a69576c0d3558f6e5a48d0761226aae46a9f92d541b9e2547ae7f81f8b65a67441
-  data.tar.gz: dd8734f7a005a0007336faf58b6b032e6a2dbcf668859483cc9c713eef50ca585df9e564257b6890c9af3c394e82de8e0bd7a42790d3e1c033ffedeb41702e2c
+  metadata.gz: e50c031a4d9f38a87eb77996c90f90a36c4c5f840694bad4a7ce79dcf3d2e439b30fee8e41a21522285ff7db5293e6fa059186c958f7fbed99089455b4ea04db
+  data.tar.gz: 65b7187a73f43b89a8ec8997edcce562af456e3b89f697b4e25c23ae114ed712916643d39c81ef323a1b47b6ac4783e384c53477d177a9d73271859e31c0f970

data/.github/workflows/test_on_macos.yml

@@ -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

@@ -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/CHANGELOG.md

@@ -4,6 +4,18 @@ 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`.

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.1)
+    duckdb (1.0.0.2)
       bigdecimal (>= 3.1.4)
 
 GEM
@@ -10,7 +10,7 @@ GEM
     benchmark-ips (2.13.0)
     bigdecimal (3.1.8)
     mini_portile2 (2.8.7)
-    minitest (5.23.1)
+    minitest (5.24.0)
     nokogiri (1.16.6)
       mini_portile2 (~> 2.8.2)
       racc (~> 1.4)

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);
@@ -64,12 +69,19 @@ 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_array(duckdb_logical_type ty, duckdb_vector vector, idx_t row_idx);
-static VALUE vector_array_value_at(duckdb_vector array, duckdb_logical_type element_type, idx_t index);
+static VALUE vector_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, 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);
 
@@ -711,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;
@@ -744,7 +777,7 @@ static VALUE vector_array(duckdb_logical_type ty, duckdb_vector vector, idx_t ro
 
     ary = rb_ary_new2(size);
     for (idx_t i = bgn; i < end; ++i) {
-        value = vector_array_value_at(child, child_logical_type, i);
+        value = vector_value_at(child, child_logical_type, i);
         rb_ary_store(ary, i - bgn, value);
     }
 
@@ -752,19 +785,19 @@ static VALUE vector_array(duckdb_logical_type ty, duckdb_vector vector, idx_t ro
     return ary;
 }
 
-static VALUE vector_array_value_at(duckdb_vector array, duckdb_logical_type element_type, idx_t index) {
+static VALUE vector_value_at(duckdb_vector vector, duckdb_logical_type element_type, idx_t index) {
     uint64_t *validity;
     duckdb_type type_id;
     void* vector_data;
     VALUE obj = Qnil;
 
-    validity = duckdb_vector_get_validity(array);
+    validity = duckdb_vector_get_validity(vector);
     if (!duckdb_validity_row_is_valid(validity, index)) {
         return Qnil;
     }
 
     type_id = duckdb_get_type_id(element_type);
-    vector_data = duckdb_vector_get_data(array);
+    vector_data = duckdb_vector_get_data(vector);
 
     switch(type_id) {
         case DUCKDB_TYPE_INVALID:
@@ -797,30 +830,30 @@ static VALUE vector_array_value_at(duckdb_vector array, duckdb_logical_type elem
         case DUCKDB_TYPE_UBIGINT:
             obj = ULL2NUM(((uint64_t *) vector_data)[index]);
             break;
-        case DUCKDB_TYPE_HUGEINT:
-            obj = vector_hugeint(vector_data, index);
-            break;
-        case DUCKDB_TYPE_UHUGEINT:
-            obj = vector_uhugeint(vector_data, index);
-            break;
         case DUCKDB_TYPE_FLOAT:
             obj = DBL2NUM((((float *) vector_data)[index]));
             break;
         case DUCKDB_TYPE_DOUBLE:
             obj = DBL2NUM((((double *) vector_data)[index]));
             break;
-        case DUCKDB_TYPE_DATE:
-            obj = vector_date(vector_data, index);
-            break;
         case DUCKDB_TYPE_TIMESTAMP:
             obj = vector_timestamp(vector_data, index);
             break;
+        case DUCKDB_TYPE_DATE:
+            obj = vector_date(vector_data, index);
+            break;
         case DUCKDB_TYPE_TIME:
             obj = vector_time(vector_data, index);
             break;
         case DUCKDB_TYPE_INTERVAL:
             obj = vector_interval(vector_data, index);
             break;
+        case DUCKDB_TYPE_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, index);
             break;
@@ -830,24 +863,45 @@ static VALUE vector_array_value_at(duckdb_vector array, duckdb_logical_type elem
         case DUCKDB_TYPE_DECIMAL:
             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(element_type, vector_data, index);
             break;
-        case DUCKDB_TYPE_ARRAY:
-            obj = vector_array(element_type, array, index);
-            break;
         case DUCKDB_TYPE_LIST:
-            obj = vector_list(element_type, array, vector_data, index);
+            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(element_type, vector_data, index);
+            obj = vector_map(element_type, vector, vector_data, index);
             break;
-        case DUCKDB_TYPE_STRUCT:
-            obj = vector_struct(element_type, vector_data, index);
+        case DUCKDB_TYPE_ARRAY:
+            obj = vector_array(element_type, vector, index);
             break;
         case DUCKDB_TYPE_UUID:
             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;
@@ -871,26 +925,36 @@ static VALUE vector_list(duckdb_logical_type ty, duckdb_vector vector, void * ve
     duckdb_vector child = duckdb_list_vector_get_child(vector);
 
     for (i = bgn; i < end; ++i) {
-        value = vector_array_value_at(child, child_logical_type, i);
+        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, idx_t row_idx) {
+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_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_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;
@@ -900,6 +964,8 @@ static VALUE vector_struct(duckdb_logical_type ty, duckdb_vector vector, idx_t r
     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);
@@ -907,13 +973,12 @@ static VALUE vector_struct(duckdb_logical_type ty, duckdb_vector vector, idx_t r
     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);
+            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);
         }
     }
@@ -921,6 +986,85 @@ static VALUE vector_struct(duckdb_logical_type ty, duckdb_vector vector, idx_t r
     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,
@@ -930,107 +1074,12 @@ static VALUE vector_uuid(void* vector_data, idx_t row_idx) {
 }
 
 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_UHUGEINT:
-            obj = vector_uhugeint(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_TIME:
-            obj = vector_time(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_ARRAY:
-            obj = vector_array(ty, vector, row_idx);
-            break;
-        case DUCKDB_TYPE_LIST:
-            obj = vector_list(ty, vector, 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;
-    }
+    obj = vector_value_at(vector, ty, row_idx);
 
     duckdb_destroy_logical_type(&ty);
     return obj;
@@ -1045,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/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.1'
+  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.1
+  version: 1.0.0.2
 platform: ruby
 authors:
 - Masaki Suketa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-06-15 00:00:00.000000000 Z
+date: 2024-06-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal