duckdb 1.5.6.1 → 2.0.0.1

data/ext/duckdb/result.c

@@ -3,6 +3,30 @@
 struct chunk_arg {
     duckdb_data_chunk chunk;
     idx_t col_count;
+    duckdb_logical_type *types;
+};
+
+struct owned_type_arg {
+    duckdb_vector vector;
+    duckdb_logical_type type;
+    idx_t bgn;
+    idx_t end;
+};
+
+struct struct_fields_arg {
+    duckdb_logical_type ty;
+    duckdb_vector vector;
+    idx_t row_idx;
+    duckdb_logical_type child_type;
+};
+
+struct map_entries_arg {
+    duckdb_vector key_vector;
+    duckdb_vector value_vector;
+    duckdb_logical_type key_type;
+    duckdb_logical_type value_type;
+    idx_t bgn;
+    idx_t end;
 };
 
 static VALUE cDuckDBResult;
@@ -14,6 +38,7 @@ static VALUE result_column_count(VALUE oDuckDBResult);
 static VALUE result_rows_changed(VALUE oDuckDBResult);
 static VALUE result_columns(VALUE oDuckDBResult);
 static VALUE destroy_data_chunk(VALUE arg);
+static duckdb_logical_type *result_column_types(rubyDuckDBResult *ctx);
 
 static VALUE result__chunk_stream(VALUE oDuckDBResult);
 static VALUE result_arrow_c_stream(VALUE oDuckDBResult);
@@ -22,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);
@@ -46,7 +61,13 @@ 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);
+static VALUE convert_values_in_range(VALUE varg);
+static VALUE destroy_owned_type(VALUE varg);
+static VALUE vector_values_with_owned_type(duckdb_vector vector, duckdb_logical_type type, idx_t bgn, idx_t end);
+static VALUE convert_map_entries(VALUE varg);
+static VALUE destroy_map_types(VALUE varg);
+static VALUE convert_struct_fields(VALUE varg);
+static VALUE destroy_struct_child_type(VALUE varg);
 
 /*
  * No RUBY_TYPED_FREE_IMMEDIATELY: deallocate can block, and must not run
@@ -66,6 +87,11 @@ static void deallocate(void *ctx) {
 }
 
 static VALUE allocate(VALUE klass) {
+    /*
+     * Use calloc (not xcalloc): rbduckdb_result_unref frees the struct, and it
+     * can run from the Arrow stream release callback on a non-Ruby thread
+     * where xfree is unsafe.
+     */
     rubyDuckDBResult *ctx = calloc((size_t)1, sizeof(rubyDuckDBResult));
 
     if (ctx == NULL) {
@@ -80,7 +106,13 @@ void rbduckdb_result_ref(rubyDuckDBResult *ctx) {
 }
 
 void rbduckdb_result_unref(rubyDuckDBResult *ctx) {
+    idx_t col_idx;
+
     if (RUBY_ATOMIC_FETCH_SUB(ctx->refcount, 1) == 1) {
+        for (col_idx = 0; col_idx < ctx->column_types_count; col_idx++) {
+            duckdb_destroy_logical_type(&(ctx->column_types[col_idx]));
+        }
+        free(ctx->column_types);
         duckdb_destroy_result(&(ctx->result));
         free(ctx);
     }
@@ -176,6 +208,25 @@ static VALUE destroy_data_chunk(VALUE arg) {
     return Qnil;
 }
 
+static duckdb_logical_type *result_column_types(rubyDuckDBResult *ctx) {
+    idx_t col_idx;
+    idx_t column_count;
+
+    if (ctx->column_types == NULL) {
+        column_count = duckdb_column_count(&(ctx->result));
+        /* Use calloc (not xcalloc): freed by rbduckdb_result_unref (see allocate). */
+        ctx->column_types = calloc(column_count + 1, sizeof(duckdb_logical_type));
+        if (ctx->column_types == NULL) {
+            rb_raise(rb_eNoMemError, "failed to allocate DuckDB::Result column types");
+        }
+        for (col_idx = 0; col_idx < column_count; col_idx++) {
+            ctx->column_types[col_idx] = duckdb_column_logical_type(&(ctx->result), col_idx);
+        }
+        ctx->column_types_count = column_count;
+    }
+    return ctx->column_types;
+}
+
 /* :nodoc: */
 static VALUE result__chunk_stream(VALUE oDuckDBResult) {
     rubyDuckDBResult *ctx;
@@ -186,6 +237,7 @@ static VALUE result__chunk_stream(VALUE oDuckDBResult) {
     RETURN_ENUMERATOR(oDuckDBResult, 0, 0);
 
     arg.col_count = duckdb_column_count(&(ctx->result));
+    arg.types = result_column_types(ctx);
 
     while((arg.chunk = duckdb_fetch_chunk(ctx->result)) != NULL) {
         rb_ensure(yield_rows, (VALUE)&arg, destroy_data_chunk, (VALUE)&arg);
@@ -208,7 +260,7 @@ static VALUE yield_rows(VALUE arg) {
         row = rb_ary_new2(p->col_count);
         for (col_idx = 0; col_idx < p->col_count; col_idx++) {
             vector = duckdb_data_chunk_get_vector(p->chunk, col_idx);
-            val = vector_value(vector, row_idx);
+            val = rbduckdb_vector_value_at(vector, p->types[col_idx], row_idx);
             rb_ary_store(row, col_idx, val);
         }
         rb_yield(row);
@@ -249,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) {
@@ -329,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;
@@ -371,23 +371,11 @@ static VALUE vector_enum(duckdb_logical_type ty, void* vector_data, idx_t row_id
 }
 
 static VALUE vector_array(duckdb_logical_type ty, duckdb_vector vector, idx_t row_idx) {
-    VALUE ary = Qnil;
-    VALUE value = Qnil;
-
-    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);
-
-    ary = rb_ary_new2(size);
-    for (idx_t i = bgn; i < end; ++i) {
-        value = rbduckdb_vector_value_at(child, child_logical_type, i);
-        rb_ary_store(ary, i - bgn, value);
-    }
+    duckdb_vector child = duckdb_array_vector_get_child(vector);
 
-    duckdb_destroy_logical_type(&child_logical_type);
-    return ary;
+    return vector_values_with_owned_type(child, duckdb_array_type_child_type(ty), bgn, bgn + size);
 }
 
 VALUE rbduckdb_vector_value_at(duckdb_vector vector, duckdb_logical_type element_type, idx_t index) {
@@ -442,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);
@@ -469,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);
@@ -519,93 +507,121 @@ VALUE rbduckdb_vector_value_at(duckdb_vector vector, duckdb_logical_type element
 }
 
 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 = rbduckdb_vector_value_at(child, child_logical_type, i);
-        rb_ary_store(ary, i - bgn, value);
-    }
-    duckdb_destroy_logical_type(&child_logical_type);
-    return ary;
+    return vector_values_with_owned_type(child, duckdb_list_type_child_type(ty), bgn, bgn + list_entry.length);
 }
 
 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);
-
+    struct map_entries_arg arg;
     duckdb_list_entry list_entry = ((duckdb_list_entry *)vector_data)[row_idx];
+    duckdb_vector child = duckdb_list_vector_get_child(vector);
 
-    idx_t bgn = list_entry.offset;
-    idx_t end = bgn + list_entry.length;
+    arg.key_vector = duckdb_struct_vector_get_child(child, 0);
+    arg.value_vector = duckdb_struct_vector_get_child(child, 1);
+    arg.key_type = duckdb_map_type_key_type(ty);
+    arg.value_type = duckdb_map_type_value_type(ty);
+    arg.bgn = list_entry.offset;
+    arg.end = list_entry.offset + 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);
+    return rb_ensure(convert_map_entries, (VALUE)&arg, destroy_map_types, (VALUE)&arg);
+}
 
-    for (idx_t i = bgn; i < end; ++i) {
-        key = rbduckdb_vector_value_at(key_vector, key_logical_type, i);
-        value = rbduckdb_vector_value_at(value_vector, value_logical_type, i);
+static VALUE convert_map_entries(VALUE varg) {
+    struct map_entries_arg *arg = (struct map_entries_arg *)varg;
+    VALUE hash = rb_hash_new();
+    VALUE key;
+    VALUE value;
+
+    for (idx_t i = arg->bgn; i < arg->end; ++i) {
+        key = rbduckdb_vector_value_at(arg->key_vector, arg->key_type, i);
+        value = rbduckdb_vector_value_at(arg->value_vector, arg->value_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 destroy_map_types(VALUE varg) {
+    struct map_entries_arg *arg = (struct map_entries_arg *)varg;
+
+    duckdb_destroy_logical_type(&(arg->key_type));
+    duckdb_destroy_logical_type(&(arg->value_type));
+    return Qnil;
+}
+
 static VALUE vector_struct(duckdb_logical_type ty, duckdb_vector vector, idx_t row_idx) {
+    struct struct_fields_arg arg = {ty, vector, row_idx, NULL};
+
+    return rb_ensure(convert_struct_fields, (VALUE)&arg, destroy_struct_child_type, (VALUE)&arg);
+}
+
+static VALUE convert_struct_fields(VALUE varg) {
+    struct struct_fields_arg *arg = (struct struct_fields_arg *)varg;
     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);
+    idx_t child_count = duckdb_struct_type_child_count(arg->ty);
 
     for (idx_t i = 0; i < child_count; ++i) {
-        p = duckdb_struct_type_child_name(ty, i);
+        p = duckdb_struct_type_child_name(arg->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 = rbduckdb_vector_value_at(child, child_type, row_idx);
-            rb_hash_aset(hash, key, value);
-            duckdb_destroy_logical_type(&child_type);
             duckdb_free(p);
+            child = duckdb_struct_vector_get_child(arg->vector, i);
+            arg->child_type = duckdb_struct_type_child_type(arg->ty, i);
+            value = rbduckdb_vector_value_at(child, arg->child_type, arg->row_idx);
+            duckdb_destroy_logical_type(&(arg->child_type));
+            rb_hash_aset(hash, key, value);
         }
     }
 
     return hash;
 }
 
+static VALUE destroy_struct_child_type(VALUE varg) {
+    struct struct_fields_arg *arg = (struct struct_fields_arg *)varg;
+
+    duckdb_destroy_logical_type(&(arg->child_type));
+    return Qnil;
+}
+
 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 member_vector = duckdb_struct_vector_get_child(vector, index + 1);
+    VALUE values = vector_values_with_owned_type(member_vector, duckdb_union_type_member_type(ty, index), row_idx, row_idx + 1);
 
-    duckdb_vector vector_value = duckdb_struct_vector_get_child(vector, index + 1);
-    value = rbduckdb_vector_value_at(vector_value, child_type, row_idx);
-    duckdb_destroy_logical_type(&child_type);
-    return value;
+    return rb_ary_entry(values, 0);
+}
+
+static VALUE convert_values_in_range(VALUE varg) {
+    struct owned_type_arg *arg = (struct owned_type_arg *)varg;
+    VALUE ary = rb_ary_new2(arg->end - arg->bgn);
+
+    for (idx_t i = arg->bgn; i < arg->end; ++i) {
+        rb_ary_store(ary, i - arg->bgn, rbduckdb_vector_value_at(arg->vector, arg->type, i));
+    }
+    return ary;
+}
+
+static VALUE destroy_owned_type(VALUE varg) {
+    struct owned_type_arg *arg = (struct owned_type_arg *)varg;
+
+    duckdb_destroy_logical_type(&(arg->type));
+    return Qnil;
+}
+
+static VALUE vector_values_with_owned_type(duckdb_vector vector, duckdb_logical_type type, idx_t bgn, idx_t end) {
+    struct owned_type_arg arg = {vector, type, bgn, end};
+
+    return rb_ensure(convert_values_in_range, (VALUE)&arg, destroy_owned_type, (VALUE)&arg);
 }
 
 static VALUE str_concat_byte(VALUE str, unsigned char byte, int offset) {
@@ -625,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++) {
@@ -636,22 +652,16 @@ 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 - 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);
+    if (length < 2 || (unsigned char)p[0] > 7) {
+        rb_raise(eDuckDBError, "invalid BIT value");
     }
+    offset = (unsigned char)p[0];
+    str = bytes_to_string(p + 1, length - 1, offset);
     return str;
 }
 
@@ -697,18 +707,6 @@ static VALUE result_arrow_c_stream(VALUE oDuckDBResult) {
     return stream;
 }
 
-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 = rbduckdb_vector_value_at(vector, ty, row_idx);
-
-    duckdb_destroy_logical_type(&ty);
-    return obj;
-}
-
 void rbduckdb_init_result(void) {
 #if 0
     VALUE mDuckDB = rb_define_module("DuckDB");

data/ext/duckdb/result.h

@@ -12,6 +12,8 @@ struct _rubyDuckDBResult {
     duckdb_result result;
     bool arrow_exported;
     rb_atomic_t refcount;
+    duckdb_logical_type *column_types;
+    idx_t column_types_count;
 };
 
 typedef struct _rubyDuckDBResult rubyDuckDBResult;

data/ext/duckdb/scalar_function.c

@@ -18,11 +18,6 @@ static VALUE scalar_function__set_bind(VALUE self);
 static void scalar_function_callback(duckdb_function_info info, duckdb_data_chunk input, duckdb_vector output);
 static void scalar_function_bind_callback(duckdb_bind_info info);
 #ifdef HAVE_DUCKDB_H_GE_V1_5_0
-/*
- * Thread detection functions (available since Ruby 2.3).
- * Used to skip the proxy on Ruby threads.
- */
-extern int ruby_native_thread_p(void);
 static void scalar_function_init_callback(duckdb_init_info info);
 #endif
 
@@ -251,15 +246,8 @@ static VALUE process_rows(VALUE varg) {
      * a GC, and the earlier columns' objects must stay reachable. */
     VALUE args = rb_ary_new_capa((long)arg->col_count);
 
-    /* Allocate arrays to hold input vectors and their types */
-    arg->input_vectors = ALLOC_N(duckdb_vector, arg->col_count);
-    arg->input_types = ALLOC_N(duckdb_logical_type, arg->col_count);
-
     /* Get all input vectors and their types */
-    for (j = 0; j < arg->col_count; j++) {
-        arg->input_vectors[j] = duckdb_data_chunk_get_vector(arg->input, j);
-        arg->input_types[j] = duckdb_vector_get_column_type(arg->input_vectors[j]);
-    }
+    rbduckdb_input_columns_load(arg->input, arg->col_count, &arg->input_vectors, &arg->input_types);
 
     /* Process each row */
     for (i = 0; i < arg->row_count; i++) {
@@ -282,24 +270,10 @@ static VALUE process_rows(VALUE varg) {
 
 static VALUE cleanup_callback(VALUE varg) {
     struct callback_arg *arg = (struct callback_arg *)varg;
-    idx_t j;
 
-    /* Destroy all logical types */
-    if (arg->input_types != NULL) {
-        for (j = 0; j < arg->col_count; j++) {
-            duckdb_destroy_logical_type(&arg->input_types[j]);
-        }
-    }
+    rbduckdb_input_columns_free(arg->input_vectors, arg->input_types, arg->col_count);
     duckdb_destroy_logical_type(&arg->output_type);
 
-    /* Free allocated memory */
-    if (arg->input_types != NULL) {
-        xfree(arg->input_types);
-    }
-    if (arg->input_vectors != NULL) {
-        xfree(arg->input_vectors);
-    }
-
     return Qnil;
 }
 
@@ -307,50 +281,16 @@ static VALUE cleanup_callback(VALUE varg) {
 /*
  * Per-worker init for the execute path (DuckDB >= 1.5.0).
  *
- * DuckDB calls this once on each worker thread that will run the execute
- * callback. We create a per-worker proxy (allocating its Ruby thread under the
- * GVL via the global executor, since this runs on a non-Ruby thread) and store
- * it as per-worker state. The execute callback then dispatches through it
- * instead of the shared global executor, so workers run callbacks concurrently.
- * DuckDB invokes rbduckdb_worker_proxy_destroy when the state is freed.
+ * Runs once on each worker thread that will execute the callback. Creates the
+ * worker's proxy and stores it as per-worker state, so the execute callback
+ * dispatches through it rather than the shared global executor. DuckDB calls
+ * rbduckdb_worker_proxy_destroy when the state is freed.
  */
-struct create_proxy_callback_arg {
-    struct worker_proxy *proxy;
-};
-
-static VALUE create_proxy_callback(VALUE varg) {
-    struct create_proxy_callback_arg *arg = (struct create_proxy_callback_arg *)varg;
-    arg->proxy = rbduckdb_worker_proxy_create();
-    return Qnil;
-}
-
-/*
- * rbduckdb_worker_proxy_create may raise (NoMemError, Thread.new failure),
- * and the executor runs callbacks unprotected — a raise would longjmp past
- * its done-signaling and block the waiting DuckDB worker forever. Swallow
- * the exception instead: the proxy stays NULL, init sets no state, and the
- * execute callback falls back to the global executor.
- */
-static void create_proxy_callback_protected(void *user_data) {
-    int exception_state;
-
-    rb_protect(create_proxy_callback, (VALUE)user_data, &exception_state);
-    if (exception_state) {
-        rb_set_errinfo(Qnil);
-    }
-}
-
 static void scalar_function_init_callback(duckdb_init_info info) {
-    struct create_proxy_callback_arg arg;
-
-    /* A Ruby calling thread runs the callback inline (Case 1/2); no proxy needed. */
-    if (ruby_native_thread_p()) return;
-
-    arg.proxy = NULL;
-    rbduckdb_function_executor_dispatch(create_proxy_callback_protected, &arg);
+    struct worker_proxy *proxy = rbduckdb_worker_proxy_create_for_current_thread();
 
-    if (arg.proxy != NULL) {
-        duckdb_scalar_function_init_set_state(info, arg.proxy, rbduckdb_worker_proxy_destroy);
+    if (proxy != NULL) {
+        duckdb_scalar_function_init_set_state(info, proxy, rbduckdb_worker_proxy_destroy);
     }
 }
 #endif