duckdb 2.0.0.0 → 2.0.0.1

data/ext/duckdb/prepared_statement.c

@@ -253,140 +253,102 @@ static VALUE prepared_statement_clear_bindings(VALUE self) {
     return self;
 }
 
-static VALUE prepared_statement_bind_bool(VALUE self, VALUE vidx, VALUE val) {
+static duckdb_prepared_statement prepared_statement_of(VALUE self) {
     rubyDuckDBPreparedStatement *ctx;
+    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
+    return ctx->prepared_statement;
+}
+
+static void raise_if_bind_failed(duckdb_state state, idx_t idx) {
+    if (state == DuckDBError) {
+        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
+    }
+}
+
+static VALUE prepared_statement_bind_bool(VALUE self, VALUE vidx, VALUE val) {
     idx_t idx = check_index(vidx);
 
-    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
     if (val != Qtrue && val != Qfalse) {
         rb_raise(rb_eArgError, "binding value must be boolean");
     }
 
-    if (duckdb_bind_boolean(ctx->prepared_statement, idx, (val == Qtrue)) == DuckDBError) {
-        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
-    }
+    raise_if_bind_failed(duckdb_bind_boolean(prepared_statement_of(self), idx, (val == Qtrue)), idx);
     return self;
 }
 
 static VALUE prepared_statement_bind_int8(VALUE self, VALUE vidx, VALUE val) {
-    rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
     int8_t i8val = (int8_t)NUM2INT(val);
 
-    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
-
-    if (duckdb_bind_int8(ctx->prepared_statement, idx, i8val) == DuckDBError) {
-        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
-    }
+    raise_if_bind_failed(duckdb_bind_int8(prepared_statement_of(self), idx, i8val), idx);
     return self;
 }
 
-
 static VALUE prepared_statement_bind_int16(VALUE self, VALUE vidx, VALUE val) {
-    rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
     int16_t i16val = NUM2INT(val);
 
-    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
-
-    if (duckdb_bind_int16(ctx->prepared_statement, idx, i16val) == DuckDBError) {
-        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
-    }
+    raise_if_bind_failed(duckdb_bind_int16(prepared_statement_of(self), idx, i16val), idx);
     return self;
 }
 
 static VALUE prepared_statement_bind_int32(VALUE self, VALUE vidx, VALUE val) {
-    rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
     int32_t i32val = NUM2INT(val);
 
-    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
-
-    if (duckdb_bind_int32(ctx->prepared_statement, idx, i32val) == DuckDBError) {
-        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
-    }
+    raise_if_bind_failed(duckdb_bind_int32(prepared_statement_of(self), idx, i32val), idx);
     return self;
 }
 
 static VALUE prepared_statement_bind_int64(VALUE self, VALUE vidx, VALUE val) {
-    rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
     int64_t i64val = NUM2LL(val);
 
-    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
-
-    if (duckdb_bind_int64(ctx->prepared_statement, idx, i64val) == DuckDBError) {
-        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
-    }
+    raise_if_bind_failed(duckdb_bind_int64(prepared_statement_of(self), idx, i64val), idx);
     return self;
 }
 
 static VALUE prepared_statement_bind_float(VALUE self, VALUE vidx, VALUE val) {
-    rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
     double dbl = NUM2DBL(val);
 
-    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
-
-    if (duckdb_bind_float(ctx->prepared_statement, idx, (float)dbl) == DuckDBError) {
-        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
-    }
+    raise_if_bind_failed(duckdb_bind_float(prepared_statement_of(self), idx, (float)dbl), idx);
     return self;
 }
 
 static VALUE prepared_statement_bind_double(VALUE self, VALUE vidx, VALUE val) {
-    rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
     double dbl = NUM2DBL(val);
 
-    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
-
-    if (duckdb_bind_double(ctx->prepared_statement, idx, dbl) == DuckDBError) {
-        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
-    }
+    raise_if_bind_failed(duckdb_bind_double(prepared_statement_of(self), idx, dbl), idx);
     return self;
 }
 
 static VALUE prepared_statement_bind_varchar(VALUE self, VALUE vidx, VALUE str) {
-    rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
     const char *pstr;
     long len;
 
-    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
-
     /* Pass the byte length: duckdb_bind_varchar stops at the first NUL, so an
      * embedded one stored a prefix of the String the caller had validated. */
     pstr = StringValuePtr(str);
     len = RSTRING_LEN(str);
 
-    if (duckdb_bind_varchar_length(ctx->prepared_statement, idx, pstr, (idx_t)len) == DuckDBError) {
-        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
-    }
+    raise_if_bind_failed(duckdb_bind_varchar_length(prepared_statement_of(self), idx, pstr, (idx_t)len), idx);
     return self;
 }
 
 static VALUE prepared_statement_bind_blob(VALUE self, VALUE vidx, VALUE blob) {
-    rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
 
-    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
-
-    if (duckdb_bind_blob(ctx->prepared_statement, idx, (const void *)StringValuePtr(blob), (idx_t)RSTRING_LEN(blob)) == DuckDBError) {
-        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
-    }
+    raise_if_bind_failed(duckdb_bind_blob(prepared_statement_of(self), idx, (const void *)StringValuePtr(blob), (idx_t)RSTRING_LEN(blob)), idx);
     return self;
 }
 
 static VALUE prepared_statement_bind_null(VALUE self, VALUE vidx) {
-    rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
 
-    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
-
-    if (duckdb_bind_null(ctx->prepared_statement, idx) == DuckDBError) {
-        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
-    }
+    raise_if_bind_failed(duckdb_bind_null(prepared_statement_of(self), idx), idx);
     return self;
 }
 
@@ -491,91 +453,61 @@ static VALUE prepared_statement__param_type(VALUE self, VALUE vidx) {
 
 /* :nodoc: */
 static VALUE prepared_statement__bind_uint8(VALUE self, VALUE vidx, VALUE val) {
-    rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
     uint8_t ui8val = (uint8_t)NUM2UINT(val);
 
-    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
-
-    if (duckdb_bind_uint8(ctx->prepared_statement, idx, ui8val) == DuckDBError) {
-        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
-    }
+    raise_if_bind_failed(duckdb_bind_uint8(prepared_statement_of(self), idx, ui8val), idx);
     return self;
 }
 
 /* :nodoc: */
 static VALUE prepared_statement__bind_uint16(VALUE self, VALUE vidx, VALUE val) {
-    rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
     uint16_t ui16val = (uint16_t)NUM2UINT(val);
 
-    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
-
-    if (duckdb_bind_uint16(ctx->prepared_statement, idx, ui16val) == DuckDBError) {
-        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
-    }
+    raise_if_bind_failed(duckdb_bind_uint16(prepared_statement_of(self), idx, ui16val), idx);
     return self;
 }
 
 /* :nodoc: */
 static VALUE prepared_statement__bind_uint32(VALUE self, VALUE vidx, VALUE val) {
-    rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
     uint32_t ui32val = (uint32_t)NUM2UINT(val);
 
-    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
-
-    if (duckdb_bind_uint32(ctx->prepared_statement, idx, ui32val) == DuckDBError) {
-        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
-    }
+    raise_if_bind_failed(duckdb_bind_uint32(prepared_statement_of(self), idx, ui32val), idx);
     return self;
 }
 
 /* :nodoc: */
 static VALUE prepared_statement__bind_uint64(VALUE self, VALUE vidx, VALUE val) {
-    rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
     uint64_t ui64val = (uint64_t)NUM2ULL(val);
 
-    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
-
-    if (duckdb_bind_uint64(ctx->prepared_statement, idx, ui64val) == DuckDBError) {
-        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
-    }
+    raise_if_bind_failed(duckdb_bind_uint64(prepared_statement_of(self), idx, ui64val), idx);
     return self;
 }
 
 /* :nodoc: */
 static VALUE prepared_statement__bind_date(VALUE self, VALUE vidx, VALUE year, VALUE month, VALUE day) {
-    rubyDuckDBPreparedStatement *ctx;
     duckdb_date dt;
     idx_t idx = check_index(vidx);
 
     dt = rbduckdb_to_duckdb_date_from_value(year, month, day);
 
-    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
-
-    if (duckdb_bind_date(ctx->prepared_statement, idx, dt) == DuckDBError) {
-        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
-    }
+    raise_if_bind_failed(duckdb_bind_date(prepared_statement_of(self), idx, dt), idx);
 
     return self;
 }
 
 /* :nodoc: */
 static VALUE prepared_statement__bind_time(VALUE self, VALUE vidx, VALUE hour, VALUE min, VALUE sec, VALUE micros){
-    rubyDuckDBPreparedStatement *ctx;
     duckdb_time time;
 
     idx_t idx = check_index(vidx);
 
     time = rbduckdb_to_duckdb_time_from_value(hour, min, sec, micros);
 
-    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
-
-    if (duckdb_bind_time(ctx->prepared_statement, idx, time) == DuckDBError) {
-        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
-    }
+    raise_if_bind_failed(duckdb_bind_time(prepared_statement_of(self), idx, time), idx);
 
     return self;
 }
@@ -583,62 +515,45 @@ static VALUE prepared_statement__bind_time(VALUE self, VALUE vidx, VALUE hour, V
 /* :nodoc: */
 static VALUE prepared_statement__bind_timestamp(VALUE self, VALUE vidx, VALUE year, VALUE month, VALUE day, VALUE hour, VALUE min, VALUE sec, VALUE micros) {
     duckdb_timestamp timestamp;
-    rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
 
     timestamp = rbduckdb_to_duckdb_timestamp_from_value(year, month, day, hour, min, sec, micros);
-    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
 
-    if (duckdb_bind_timestamp(ctx->prepared_statement, idx, timestamp) == DuckDBError) {
-        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
-    }
+    raise_if_bind_failed(duckdb_bind_timestamp(prepared_statement_of(self), idx, timestamp), idx);
     return self;
 }
 
 /* :nodoc: */
 static VALUE prepared_statement__bind_timestamp_tz(VALUE self, VALUE vidx, VALUE year, VALUE month, VALUE day, VALUE hour, VALUE min, VALUE sec, VALUE micros) {
     duckdb_timestamp timestamp_tz;
-    rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
 
     timestamp_tz = rbduckdb_to_duckdb_timestamp_from_value(year, month, day, hour, min, sec, micros);
-    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
 
-    if (duckdb_bind_timestamp_tz(ctx->prepared_statement, idx, timestamp_tz) == DuckDBError) {
-        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
-    }
+    raise_if_bind_failed(duckdb_bind_timestamp_tz(prepared_statement_of(self), idx, timestamp_tz), idx);
     return self;
 }
 
 /* :nodoc: */
 static VALUE prepared_statement__bind_interval(VALUE self, VALUE vidx, VALUE months, VALUE days, VALUE micros) {
     duckdb_interval interval;
-    rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
 
-    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
-
     rbduckdb_to_duckdb_interval_from_value(&interval, months, days, micros);
 
-    if (duckdb_bind_interval(ctx->prepared_statement, idx, interval) == DuckDBError) {
-        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
-    }
+    raise_if_bind_failed(duckdb_bind_interval(prepared_statement_of(self), idx, interval), idx);
     return self;
 }
 
 /* :nodoc: */
 static VALUE prepared_statement__bind_hugeint(VALUE self, VALUE vidx, VALUE lower, VALUE upper) {
     duckdb_hugeint hugeint;
-    rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
 
-    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
     hugeint.lower = NUM2ULL(lower);
     hugeint.upper = NUM2LL(upper);
 
-    if (duckdb_bind_hugeint(ctx->prepared_statement, idx, hugeint) == DuckDBError) {
-        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
-    }
+    raise_if_bind_failed(duckdb_bind_hugeint(prepared_statement_of(self), idx, hugeint), idx);
 
     return self;
 }
@@ -646,16 +561,12 @@ static VALUE prepared_statement__bind_hugeint(VALUE self, VALUE vidx, VALUE lowe
 /* :nodoc: */
 static VALUE prepared_statement__bind_uhugeint(VALUE self, VALUE vidx, VALUE lower, VALUE upper) {
     duckdb_uhugeint uhugeint;
-    rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
 
-    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
     uhugeint.lower = NUM2ULL(lower);
     uhugeint.upper = NUM2ULL(upper);
 
-    if (duckdb_bind_uhugeint(ctx->prepared_statement, idx, uhugeint) == DuckDBError) {
-        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
-    }
+    raise_if_bind_failed(duckdb_bind_uhugeint(prepared_statement_of(self), idx, uhugeint), idx);
 
     return self;
 }
@@ -664,54 +575,42 @@ static VALUE prepared_statement__bind_uhugeint(VALUE self, VALUE vidx, VALUE low
 static VALUE prepared_statement__bind_decimal(VALUE self, VALUE vidx, VALUE lower, VALUE upper, VALUE width, VALUE scale) {
     duckdb_hugeint hugeint;
     duckdb_decimal decimal;
-    rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
 
-    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
     hugeint.lower = NUM2ULL(lower);
     hugeint.upper = NUM2LL(upper);
     decimal.value = hugeint;
     decimal.width = (uint8_t)NUM2UINT(width);
     decimal.scale = (uint8_t)NUM2UINT(scale);
 
-    if (duckdb_bind_decimal(ctx->prepared_statement, idx, decimal) == DuckDBError) {
-        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
-    }
+    raise_if_bind_failed(duckdb_bind_decimal(prepared_statement_of(self), idx, decimal), idx);
 
     return self;
 }
 
 /* :nodoc: */
 static VALUE prepared_statement__bind_uuid(VALUE self, VALUE vidx, VALUE val) {
-    rubyDuckDBPreparedStatement *ctx;
     duckdb_uhugeint uhugeint;
     duckdb_value uuid_val;
     duckdb_state state;
     idx_t idx = check_index(vidx);
 
-    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
     rbduckdb_uuid_str_to_uhugeint(val, &uhugeint);
     uuid_val = duckdb_create_uuid(uhugeint);
-    state = duckdb_bind_value(ctx->prepared_statement, idx, uuid_val);
+    state = duckdb_bind_value(prepared_statement_of(self), idx, uuid_val);
     duckdb_destroy_value(&uuid_val);
-    if (state == DuckDBError) {
-        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
-    }
+    raise_if_bind_failed(state, idx);
     return self;
 }
 
 /* :nodoc: */
 static VALUE prepared_statement__bind_value(VALUE self, VALUE vidx, VALUE val) {
-    rubyDuckDBPreparedStatement *ctx;
     rubyDuckDBValue *val_ctx;
     idx_t idx = check_index(vidx);
 
-    TypedData_Get_Struct(self, rubyDuckDBPreparedStatement, &prepared_statement_data_type, ctx);
     val_ctx = rbduckdb_get_struct_value(val);
 
-    if (duckdb_bind_value(ctx->prepared_statement, idx, val_ctx->value) == DuckDBError) {
-        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
-    }
+    raise_if_bind_failed(duckdb_bind_value(prepared_statement_of(self), idx, val_ctx->value), idx);
     return self;
 }
 

data/ext/duckdb/result.c

@@ -47,20 +47,10 @@ static VALUE result__return_type(VALUE oDuckDBResult);
 static VALUE result__statement_type(VALUE oDuckDBResult);
 static VALUE result__enum_internal_type(VALUE oDuckDBResult, VALUE col_idx);
 
-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);
-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_time_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_list(duckdb_logical_type ty, duckdb_vector vector, void* vector_data, idx_t row_idx);
@@ -311,46 +301,14 @@ VALUE rbduckdb_create_result(void) {
     return allocate(cDuckDBResult);
 }
 
-static VALUE vector_date(void *vector_data, idx_t row_idx) {
-    return rbduckdb_date_to_ruby(((duckdb_date *)vector_data)[row_idx]);
-}
-
-static VALUE vector_timestamp(void* vector_data, idx_t row_idx) {
-    return rbduckdb_timestamp_to_ruby(((duckdb_timestamp *)vector_data)[row_idx]);
-}
-
-static VALUE vector_time(void* vector_data, idx_t row_idx) {
-    return rbduckdb_time_to_ruby(((duckdb_time *)vector_data)[row_idx]);
-}
-
-static VALUE vector_interval(void* vector_data, idx_t row_idx) {
-    return rbduckdb_interval_to_ruby(((duckdb_interval *)vector_data)[row_idx]);
-}
-
 static VALUE vector_blob(void* vector_data, idx_t row_idx) {
     duckdb_string_t s = (((duckdb_string_t *)vector_data)[row_idx]);
-    if(duckdb_string_is_inlined(s)) {
-        return rb_str_new(s.value.inlined.inlined, s.value.inlined.length);
-    } else {
-        return rb_str_new(s.value.pointer.ptr, s.value.pointer.length);
-    }
+    return rb_str_new(duckdb_string_t_data(&s), duckdb_string_t_length(s));
 }
 
 static VALUE vector_varchar(void* vector_data, idx_t row_idx) {
     duckdb_string_t s = (((duckdb_string_t *)vector_data)[row_idx]);
-    if(duckdb_string_is_inlined(s)) {
-        return rb_utf8_str_new(s.value.inlined.inlined, s.value.inlined.length);
-    } else {
-        return rb_utf8_str_new(s.value.pointer.ptr, s.value.pointer.length);
-    }
-}
-
-static VALUE vector_hugeint(void* vector_data, idx_t row_idx) {
-    return rbduckdb_hugeint_to_ruby(((duckdb_hugeint *)vector_data)[row_idx]);
-}
-
-static VALUE vector_uhugeint(void* vector_data, idx_t row_idx) {
-    return rbduckdb_uhugeint_to_ruby(((duckdb_uhugeint *)vector_data)[row_idx]);
+    return rb_utf8_str_new(duckdb_string_t_data(&s), duckdb_string_t_length(s));
 }
 
 static VALUE vector_decimal(duckdb_logical_type ty, void* vector_data, idx_t row_idx) {
@@ -391,26 +349,6 @@ 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) {
-    return rbduckdb_timestamp_s_to_ruby(((duckdb_timestamp_s *)vector_data)[row_idx]);
-}
-
-
-static VALUE vector_timestamp_ms(void* vector_data, idx_t row_idx) {
-    return rbduckdb_timestamp_ms_to_ruby(((duckdb_timestamp_ms *)vector_data)[row_idx]);
-}
-
-
-static VALUE vector_timestamp_ns(void* vector_data, idx_t row_idx) {
-    return rbduckdb_timestamp_ns_to_ruby(((duckdb_timestamp_ns *)vector_data)[row_idx]);
-}
-
-static VALUE vector_time_ns(void* vector_data, idx_t row_idx) {
-    return rbduckdb_time_ns_to_ruby(((duckdb_time_ns *)vector_data)[row_idx]);
-}
-
 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;
@@ -492,22 +430,22 @@ VALUE rbduckdb_vector_value_at(duckdb_vector vector, duckdb_logical_type element
             obj = DBL2NUM((((double *) vector_data)[index]));
             break;
         case DUCKDB_TYPE_TIMESTAMP:
-            obj = vector_timestamp(vector_data, index);
+            obj = rbduckdb_timestamp_to_ruby(((duckdb_timestamp *)vector_data)[index]);
             break;
         case DUCKDB_TYPE_DATE:
-            obj = vector_date(vector_data, index);
+            obj = rbduckdb_date_to_ruby(((duckdb_date *)vector_data)[index]);
             break;
         case DUCKDB_TYPE_TIME:
-            obj = vector_time(vector_data, index);
+            obj = rbduckdb_time_to_ruby(((duckdb_time *)vector_data)[index]);
             break;
         case DUCKDB_TYPE_INTERVAL:
-            obj = vector_interval(vector_data, index);
+            obj = rbduckdb_interval_to_ruby(((duckdb_interval *)vector_data)[index]);
             break;
         case DUCKDB_TYPE_HUGEINT:
-            obj = vector_hugeint(vector_data, index);
+            obj = rbduckdb_hugeint_to_ruby(((duckdb_hugeint *)vector_data)[index]);
             break;
         case DUCKDB_TYPE_UHUGEINT:
-            obj = vector_uhugeint(vector_data, index);
+            obj = rbduckdb_uhugeint_to_ruby(((duckdb_uhugeint *)vector_data)[index]);
             break;
         case DUCKDB_TYPE_VARCHAR:
             obj = vector_varchar(vector_data, index);
@@ -519,16 +457,16 @@ VALUE rbduckdb_vector_value_at(duckdb_vector vector, duckdb_logical_type element
             obj = vector_decimal(element_type, vector_data, index);
             break;
         case DUCKDB_TYPE_TIMESTAMP_S:
-            obj = vector_timestamp_s(vector_data, index);
+            obj = rbduckdb_timestamp_s_to_ruby(((duckdb_timestamp_s *)vector_data)[index]);
             break;
         case DUCKDB_TYPE_TIMESTAMP_MS:
-            obj = vector_timestamp_ms(vector_data, index);
+            obj = rbduckdb_timestamp_ms_to_ruby(((duckdb_timestamp_ms *)vector_data)[index]);
             break;
         case DUCKDB_TYPE_TIMESTAMP_NS:
-            obj = vector_timestamp_ns(vector_data, index);
+            obj = rbduckdb_timestamp_ns_to_ruby(((duckdb_timestamp_ns *)vector_data)[index]);
             break;
         case DUCKDB_TYPE_TIME_NS:
-            obj = vector_time_ns(vector_data, index);
+            obj = rbduckdb_time_ns_to_ruby(((duckdb_time_ns *)vector_data)[index]);
             break;
         case DUCKDB_TYPE_ENUM:
             obj = vector_enum(element_type, vector_data, index);
@@ -703,7 +641,7 @@ static VALUE str_concat_byte(VALUE str, unsigned char byte, int offset) {
     return rb_str_cat(str, p, 8 - offset);
 }
 
-static VALUE bytes_to_string(char *bytes, uint32_t length, int offset) {
+static VALUE bytes_to_string(const 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++) {
@@ -714,18 +652,11 @@ static VALUE bytes_to_string(char *bytes, uint32_t length, int offset) {
 
 static VALUE vector_bit(void* vector_data, idx_t row_idx) {
     duckdb_string_t s = (((duckdb_string_t *)vector_data)[row_idx]);
-    char *p;
+    const char *p = duckdb_string_t_data(&s);
+    uint32_t length = duckdb_string_t_length(s);
     int offset;
-    uint32_t length;
     VALUE str = Qnil;
 
-    if(duckdb_string_is_inlined(s)) {
-        length = s.value.inlined.length;
-        p = s.value.inlined.inlined;
-    } else {
-        length = s.value.pointer.length;
-        p = s.value.pointer.ptr;
-    }
     if (length < 2 || (unsigned char)p[0] > 7) {
         rb_raise(eDuckDBError, "invalid BIT value");
     }