duckdb 1.0.0.1 → 1.1.0.0

data/ext/duckdb/result.c

@@ -13,20 +13,16 @@ 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 ID id__to_infinity;
 
 static void deallocate(void *ctx);
 static VALUE allocate(VALUE klass);
 static size_t memsize(const void *p);
-static VALUE to_ruby_obj_boolean(duckdb_result *result, idx_t col_idx, idx_t row_idx);
-static VALUE to_ruby_obj_smallint(duckdb_result *result, idx_t col_idx, idx_t row_idx);
-static VALUE to_ruby_obj_utinyint(duckdb_result *result, idx_t col_idx, idx_t row_idx);
-static VALUE to_ruby_obj_integer(duckdb_result *result, idx_t col_idx, idx_t row_idx);
-static VALUE to_ruby_obj_bigint(duckdb_result *result, idx_t col_idx, idx_t row_idx);
-static VALUE to_ruby_obj_hugeint(duckdb_result *result, idx_t col_idx, idx_t row_idx);
-static VALUE to_ruby_obj_decimal(duckdb_result *result, idx_t col_idx, idx_t row_idx);
-static VALUE to_ruby_obj_float(duckdb_result *result, idx_t col_idx, idx_t row_idx);
-static VALUE to_ruby_obj_double(duckdb_result *result, idx_t col_idx, idx_t row_idx);
-static VALUE to_ruby_obj_blob(duckdb_result *result, idx_t col_idx, idx_t row_idx);
 static VALUE duckdb_result_column_count(VALUE oDuckDBResult);
 static VALUE duckdb_result_row_count(VALUE oDuckDBResult);
 static VALUE duckdb_result_rows_changed(VALUE oDuckDBResult);
@@ -38,23 +34,13 @@ static VALUE duckdb_result_chunk_each(VALUE oDuckDBResult);
 static VALUE duckdb_result__chunk_stream(VALUE oDuckDBResult);
 static VALUE yield_rows(VALUE arg);
 static VALUE duckdb_result__column_type(VALUE oDuckDBResult, VALUE col_idx);
-static VALUE duckdb_result__is_null(VALUE oDuckDBResult, VALUE row_idx, VALUE col_idx);
-static VALUE duckdb_result__to_boolean(VALUE oDuckDBResult, VALUE row_idx, VALUE col_idx);
-static VALUE duckdb_result__to_smallint(VALUE oDuckDBResult, VALUE row_idx, VALUE col_idx);
-static VALUE duckdb_result__to_utinyint(VALUE oDuckDBResult, VALUE row_idx, VALUE col_idx);
-static VALUE duckdb_result__to_integer(VALUE oDuckDBResult, VALUE row_idx, VALUE col_idx);
-static VALUE duckdb_result__to_bigint(VALUE oDuckDBResult, VALUE row_idx, VALUE col_idx);
-static VALUE duckdb_result___to_hugeint_internal(VALUE oDuckDBResult, VALUE row_idx, VALUE col_idx);
-static VALUE duckdb_result___to_decimal_internal(VALUE oDuckDBResult, VALUE row_idx, VALUE col_idx);
-static VALUE duckdb_result__to_float(VALUE oDuckDBResult, VALUE row_idx, VALUE col_idx);
-static VALUE duckdb_result__to_double(VALUE oDuckDBResult, VALUE row_idx, VALUE col_idx);
-static VALUE duckdb_result__to_string(VALUE oDuckDBResult, VALUE row_idx, VALUE col_idx);
-static VALUE duckdb_result__to_string_internal(VALUE oDuckDBResult, VALUE row_idx, VALUE col_idx);
-static VALUE duckdb_result__to_blob(VALUE oDuckDBResult, VALUE row_idx, VALUE col_idx);
+static VALUE duckdb_result__return_type(VALUE oDuckDBResult);
+static VALUE duckdb_result__statement_type(VALUE oDuckDBResult);
 static VALUE duckdb_result__enum_internal_type(VALUE oDuckDBResult, VALUE col_idx);
 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);
 
+static VALUE infinite_date_value(duckdb_date date);
 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_time(void* vector_data, idx_t row_idx);
@@ -64,12 +50,20 @@ 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 infinite_timestamp_value(duckdb_timestamp timestamp);
+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);
 
@@ -101,114 +95,6 @@ rubyDuckDBResult *get_struct_result(VALUE obj) {
     return ctx;
 }
 
-static VALUE to_ruby_obj_boolean(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
-#ifdef DUCKDB_API_NO_DEPRECATED
-    return Qnil;
-#else
-    rb_warn("private method `_to_boolean` will be deprecated in the future. Set DuckDB::Result#use_chunk_each to true.");
-    bool bval = duckdb_value_boolean(result, col_idx, row_idx);
-    return bval ? Qtrue : Qfalse;
-#endif
-}
-
-static VALUE to_ruby_obj_smallint(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
-#ifdef DUCKDB_API_NO_DEPRECATED
-    return Qnil;
-#else
-    rb_warn("private method `_to_smallint` will be deprecated in the future. Set DuckDB::Result#use_chunk_each to true.");
-    int16_t i16val = duckdb_value_int16(result, col_idx, row_idx);
-    return INT2FIX(i16val);
-#endif
-}
-
-static VALUE to_ruby_obj_utinyint(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
-#ifdef DUCKDB_API_NO_DEPRECATED
-    return Qnil;
-#else
-    rb_warn("private method `_to_utinyint` will be deprecated in the future. Set DuckDB::Result#use_chunk_each to true.");
-    uint8_t ui8val = duckdb_value_uint8(result, col_idx, row_idx);
-    return UINT2NUM(ui8val);
-#endif
-}
-
-static VALUE to_ruby_obj_integer(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
-#ifdef DUCKDB_API_NO_DEPRECATED
-    return Qnil;
-#else
-    rb_warn("private method `_to_integer` will be deprecated in the future. Set DuckDB::Result#use_chunk_each to true.");
-    int32_t i32val = duckdb_value_int32(result, col_idx, row_idx);
-    return INT2NUM(i32val);
-#endif
-}
-
-static VALUE to_ruby_obj_bigint(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
-#ifdef DUCKDB_API_NO_DEPRECATED
-    return Qnil;
-#else
-    rb_warn("private method `_to_bigint` will be deprecated in the future. Set DuckDB::Result#use_chunk_each to true.");
-    int64_t i64val = duckdb_value_int64(result, col_idx, row_idx);
-    return LL2NUM(i64val);
-#endif
-}
-
-static VALUE to_ruby_obj_hugeint(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
-#ifdef DUCKDB_API_NO_DEPRECATED
-    return Qnil;
-#else
-    rb_warn("private method `__to_hugeint_internal` will be deprecated in the future. Set DuckDB::Result#use_chunk_each to true.");
-    duckdb_hugeint hugeint = duckdb_value_hugeint(result, col_idx, row_idx);
-    return rb_ary_new3(2, ULL2NUM(hugeint.lower), LL2NUM(hugeint.upper));
-#endif
-}
-
-static VALUE to_ruby_obj_decimal(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
-#ifdef DUCKDB_API_NO_DEPRECATED
-    return Qnil;
-#else
-    rb_warn("private method `__to_decimal_internal` will be deprecated in the future. Set DuckDB::Result#use_chunk_each to true.");
-    duckdb_decimal decimal = duckdb_value_decimal(result, col_idx, row_idx);
-    return rb_ary_new3(4, ULL2NUM(decimal.value.lower), LL2NUM(decimal.value.upper), UINT2NUM(decimal.width), UINT2NUM(decimal.scale));
-#endif
-}
-
-static VALUE to_ruby_obj_float(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
-#ifdef DUCKDB_API_NO_DEPRECATED
-    return Qnil;
-#else
-    rb_warn("private method `_to_float` will be deprecated in the future. Set DuckDB::Result#use_chunk_each to true.");
-    float fval = duckdb_value_float(result, col_idx, row_idx);
-    return DBL2NUM(fval);
-#endif
-}
-
-static VALUE to_ruby_obj_double(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
-#ifdef DUCKDB_API_NO_DEPRECATED
-    return Qnil;
-#else
-    rb_warn("private method `_to_double` will be deprecated in the future. Set DuckDB::Result#use_chunk_each to true.");
-    double dval = duckdb_value_double(result, col_idx, row_idx);
-    return DBL2NUM(dval);
-#endif
-}
-
-static VALUE to_ruby_obj_blob(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
-
-#ifdef DUCKDB_API_NO_DEPRECATED
-    return Qnil;
-#else
-    VALUE str;
-    rb_warn("private method `_to_blob` will be deprecated in the future. Set DuckDB::Result#use_chunk_each to true.");
-    duckdb_blob bval = duckdb_value_blob(result, col_idx, row_idx);
-    str = rb_str_new(bval.data, bval.size);
-
-    if (bval.data) {
-        duckdb_free(bval.data);
-    }
-
-    return str;
-#endif
-}
-
 /*
  *  call-seq:
  *    result.rows_changed -> integer
@@ -421,128 +307,16 @@ static VALUE duckdb_result__column_type(VALUE oDuckDBResult, VALUE col_idx) {
     return LL2NUM(duckdb_column_type(&(ctx->result), NUM2LL(col_idx)));
 }
 
-static VALUE duckdb_result__is_null(VALUE oDuckDBResult, VALUE row_idx, VALUE col_idx) {
+static VALUE duckdb_result__return_type(VALUE oDuckDBResult) {
     rubyDuckDBResult *ctx;
-    bool is_null;
-#ifdef DUCKDB_API_NO_DEPRECATED
-    return Qfalse;
-#else
-    rb_warn("private method `_null?` will be deprecated in the future. Set DuckDB::Result#use_chunk_each to true.");
     TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
-
-    is_null = duckdb_value_is_null(&(ctx->result), NUM2LL(col_idx), NUM2LL(row_idx));
-    return is_null ? Qtrue : Qfalse;
-#endif
+    return INT2FIX(duckdb_result_return_type(ctx->result));
 }
 
-static VALUE duckdb_result__to_boolean(VALUE oDuckDBResult, VALUE row_idx, VALUE col_idx) {
+static VALUE duckdb_result__statement_type(VALUE oDuckDBResult) {
     rubyDuckDBResult *ctx;
     TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
-
-    return to_ruby_obj_boolean(&(ctx->result), NUM2LL(col_idx), NUM2LL(row_idx)) ? Qtrue : Qfalse;
-}
-
-static VALUE duckdb_result__to_smallint(VALUE oDuckDBResult, VALUE row_idx, VALUE col_idx) {
-    rubyDuckDBResult *ctx;
-    TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
-
-    return to_ruby_obj_smallint(&(ctx->result), NUM2LL(col_idx), NUM2LL(row_idx));
-}
-
-static VALUE duckdb_result__to_utinyint(VALUE oDuckDBResult, VALUE row_idx, VALUE col_idx) {
-    rubyDuckDBResult *ctx;
-    TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
-
-    return to_ruby_obj_utinyint(&(ctx->result), NUM2LL(col_idx), NUM2LL(row_idx));
-}
-
-static VALUE duckdb_result__to_integer(VALUE oDuckDBResult, VALUE row_idx, VALUE col_idx) {
-    rubyDuckDBResult *ctx;
-    TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
-
-    return to_ruby_obj_integer(&(ctx->result), NUM2LL(col_idx), NUM2LL(row_idx));
-}
-
-static VALUE duckdb_result__to_bigint(VALUE oDuckDBResult, VALUE row_idx, VALUE col_idx) {
-    rubyDuckDBResult *ctx;
-    TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
-
-    return to_ruby_obj_bigint(&(ctx->result), NUM2LL(col_idx), NUM2LL(row_idx));
-}
-
-static VALUE duckdb_result___to_hugeint_internal(VALUE oDuckDBResult, VALUE row_idx, VALUE col_idx) {
-    rubyDuckDBResult *ctx;
-    TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
-
-    return to_ruby_obj_hugeint(&(ctx->result), NUM2LL(col_idx), NUM2LL(row_idx));
-}
-
-static VALUE duckdb_result___to_decimal_internal(VALUE oDuckDBResult, VALUE row_idx, VALUE col_idx) {
-    rubyDuckDBResult *ctx;
-    TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
-
-    return to_ruby_obj_decimal(&(ctx->result), NUM2LL(col_idx), NUM2LL(row_idx));
-}
-
-static VALUE duckdb_result__to_float(VALUE oDuckDBResult, VALUE row_idx, VALUE col_idx) {
-    rubyDuckDBResult *ctx;
-    TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
-
-    return to_ruby_obj_float(&(ctx->result), NUM2LL(col_idx), NUM2LL(row_idx));
-}
-
-static VALUE duckdb_result__to_double(VALUE oDuckDBResult, VALUE row_idx, VALUE col_idx) {
-    rubyDuckDBResult *ctx;
-    TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
-
-    return to_ruby_obj_double(&(ctx->result), NUM2LL(col_idx), NUM2LL(row_idx));
-}
-
-static VALUE duckdb_result__to_string(VALUE oDuckDBResult, VALUE row_idx, VALUE col_idx) {
-    rubyDuckDBResult *ctx;
-    duckdb_string p;
-    VALUE obj;
-
-#ifdef DUCKDB_API_NO_DEPRECATED
-    return Qnil;
-#else
-    rb_warn("private method `_to_string` will be deprecated in the future. Set DuckDB::Result#use_chunk_each to true.");
-    TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
-
-    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);
-        return obj;
-    }
-#endif
-    return Qnil;
-}
-
-static VALUE duckdb_result__to_string_internal(VALUE oDuckDBResult, VALUE row_idx, VALUE col_idx) {
-    rubyDuckDBResult *ctx;
-    duckdb_string p;
-    VALUE obj;
-#ifdef DUCKDB_API_NO_DEPRECATED
-    // duckdb_value_string_internal will be deprecated in the future.
-#else
-    rb_warn("private method `_to_string_internal` will be deprecated in the future. Set DuckDB::Result#use_chunk_each to true.");
-    TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
-
-    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);
-        return obj;
-    }
-#endif
-    return Qnil;
-}
-
-static VALUE duckdb_result__to_blob(VALUE oDuckDBResult, VALUE row_idx, VALUE col_idx) {
-    rubyDuckDBResult *ctx;
-    TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
-
-    return to_ruby_obj_blob(&(ctx->result), NUM2LL(col_idx), NUM2LL(row_idx));
+    return INT2FIX(duckdb_result_statement_type(ctx->result));
 }
 
 static VALUE duckdb_result__enum_internal_type(VALUE oDuckDBResult, VALUE col_idx) {
@@ -596,27 +370,47 @@ VALUE rbduckdb_create_result(void) {
     return allocate(cDuckDBResult);
 }
 
-static VALUE vector_date(void *vector_data, idx_t row_idx) {
-    duckdb_date_struct date = duckdb_from_date(((duckdb_date *) vector_data)[row_idx]);
+static VALUE infinite_date_value(duckdb_date date) {
+    if (duckdb_is_finite_date(date) == false) {
+        return rb_funcall(mDuckDBConverter, id__to_infinity, 1,
+                          INT2NUM(date.days)
+                         );
+    }
+    return Qnil;
+}
 
-    return rb_funcall(mDuckDBConverter, id__to_date, 3,
-                      INT2FIX(date.year),
-                      INT2FIX(date.month),
-                      INT2FIX(date.day)
-                      );
+static VALUE vector_date(void *vector_data, idx_t row_idx) {
+    duckdb_date date = ((duckdb_date *) vector_data)[row_idx];
+    VALUE obj = infinite_date_value(date);
+
+    if (obj == Qnil) {
+        duckdb_date_struct date_st = duckdb_from_date(date);
+        obj = rb_funcall(mDuckDBConverter, id__to_date, 3,
+                         INT2FIX(date_st.year),
+                         INT2FIX(date_st.month),
+                         INT2FIX(date_st.day)
+                         );
+    }
+    return obj;
 }
 
 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, id__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)
-                      );
+    duckdb_timestamp data = ((duckdb_timestamp *)vector_data)[row_idx];
+    VALUE obj = infinite_timestamp_value(data);
+
+    if (obj == Qnil) {
+        duckdb_timestamp_struct data_st = duckdb_from_timestamp(data);
+        return rb_funcall(mDuckDBConverter, id__to_time, 7,
+                          INT2FIX(data_st.date.year),
+                          INT2FIX(data_st.date.month),
+                          INT2FIX(data_st.date.day),
+                          INT2FIX(data_st.time.hour),
+                          INT2FIX(data_st.time.min),
+                          INT2FIX(data_st.time.sec),
+                          INT2NUM(data_st.time.micros)
+                          );
+    }
+    return obj;
 }
 
 static VALUE vector_time(void* vector_data, idx_t row_idx) {
@@ -711,6 +505,36 @@ static VALUE vector_decimal(duckdb_logical_type ty, void* vector_data, idx_t row
                       );
 }
 
+static VALUE infinite_timestamp_value(duckdb_timestamp timestamp) {
+    if (duckdb_is_finite_timestamp(timestamp) == false) {
+        return rb_funcall(mDuckDBConverter, id__to_infinity, 1,
+                          LL2NUM(timestamp.micros)
+                         );
+    }
+    return Qnil;
+}
+
+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 +568,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 +576,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 +621,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 +654,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 +716,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 +755,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 +764,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 +777,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 +865,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 +885,12 @@ 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");
+    id__to_infinity = rb_intern("_to_infinity");
 
     rb_define_alloc_func(cDuckDBResult, allocate);
 
@@ -1056,20 +902,9 @@ void rbduckdb_init_duckdb_result(void) {
     rb_define_method(cDuckDBResult, "chunk_each", duckdb_result_chunk_each, 0);
     rb_define_private_method(cDuckDBResult, "_chunk_stream", duckdb_result__chunk_stream, 0);
     rb_define_private_method(cDuckDBResult, "_column_type", duckdb_result__column_type, 1);
+    rb_define_private_method(cDuckDBResult, "_return_type", duckdb_result__return_type, 0);
+    rb_define_private_method(cDuckDBResult, "_statement_type", duckdb_result__statement_type, 0);
 
-    rb_define_private_method(cDuckDBResult, "_null?", duckdb_result__is_null, 2); /* deprecated */
-    rb_define_private_method(cDuckDBResult, "_to_boolean", duckdb_result__to_boolean, 2); /* deprecated */
-    rb_define_private_method(cDuckDBResult, "_to_smallint", duckdb_result__to_smallint, 2); /* deprecated */
-    rb_define_private_method(cDuckDBResult, "_to_utinyint", duckdb_result__to_utinyint, 2); /* deprecated */
-    rb_define_private_method(cDuckDBResult, "_to_integer", duckdb_result__to_integer, 2); /* deprecated */
-    rb_define_private_method(cDuckDBResult, "_to_bigint", duckdb_result__to_bigint, 2); /* deprecated */
-    rb_define_private_method(cDuckDBResult, "__to_hugeint_internal", duckdb_result___to_hugeint_internal, 2); /* deprecated */
-    rb_define_private_method(cDuckDBResult, "__to_decimal_internal", duckdb_result___to_decimal_internal, 2); /* deprecated */
-    rb_define_private_method(cDuckDBResult, "_to_float", duckdb_result__to_float, 2); /* deprecated */
-    rb_define_private_method(cDuckDBResult, "_to_double", duckdb_result__to_double, 2); /* deprecated */
-    rb_define_private_method(cDuckDBResult, "_to_string", duckdb_result__to_string, 2); /* deprecated */
-    rb_define_private_method(cDuckDBResult, "_to_string_internal", duckdb_result__to_string_internal, 2); /* deprecated */
-    rb_define_private_method(cDuckDBResult, "_to_blob", duckdb_result__to_blob, 2); /* deprecated */
     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);