duckdb 1.4.2.0 → 1.4.4.0

data/ext/duckdb/logical_type.c

@@ -23,6 +23,8 @@ static VALUE duckdb_logical_type_dictionary_size(VALUE self);
 static VALUE duckdb_logical_type_dictionary_value_at(VALUE self, VALUE didx);
 static VALUE duckdb_logical_type__get_alias(VALUE self);
 static VALUE duckdb_logical_type__set_alias(VALUE self, VALUE aname);
+static VALUE duckdb_logical_type_s_create_array_type(VALUE klass, VALUE child, VALUE array_size);
+static VALUE duckdb_logical_type_s_create_list_type(VALUE klass, VALUE child);
 static VALUE initialize(VALUE self, VALUE type_id_arg);
 
 static const rb_data_type_t logical_type_data_type = {
@@ -434,6 +436,41 @@ static VALUE duckdb_logical_type__set_alias(VALUE self, VALUE aname) {
     return alias;
 }
 
+/*
+ *  call-seq:
+ *    DuckDB::LogicalType._create_array_type(logical_type, size) -> DuckDB::LogicalType
+ *
+ *  Return an array logical type from the given child logical type and size.
+ */
+ static VALUE duckdb_logical_type_s_create_array_type(VALUE klass, VALUE child, VALUE array_size) {
+    rubyDuckDBLogicalType *child_ctx = get_struct_logical_type(child);
+    idx_t size = NUM2ULL(array_size);
+    duckdb_logical_type new_type = duckdb_create_array_type(child_ctx->logical_type, size);
+
+    if (!new_type) {
+        rb_raise(eDuckDBError, "Failed to create array type");
+    }
+
+    return rbduckdb_create_logical_type(new_type);
+}
+
+/*
+ *  call-seq:
+ *    DuckDB::LogicalType._create_list_type(logical_type) -> DuckDB::LogicalType
+ *
+ *  Return a list logical type from the given child logical type.
+ */
+static VALUE duckdb_logical_type_s_create_list_type(VALUE klass, VALUE child) {
+    rubyDuckDBLogicalType *child_ctx = get_struct_logical_type(child);
+    duckdb_logical_type new_type = duckdb_create_list_type(child_ctx->logical_type);
+
+    if (!new_type) {
+        rb_raise(eDuckDBError, "Failed to create list type");
+    }
+
+    return rbduckdb_create_logical_type(new_type);
+}
+
 VALUE rbduckdb_create_logical_type(duckdb_logical_type logical_type) {
     VALUE obj;
     rubyDuckDBLogicalType *ctx;
@@ -472,5 +509,10 @@ void rbduckdb_init_duckdb_logical_type(void) {
     rb_define_method(cDuckDBLogicalType, "get_alias", duckdb_logical_type__get_alias, 0);
     rb_define_method(cDuckDBLogicalType, "set_alias", duckdb_logical_type__set_alias, 1);
 
+    rb_define_private_method(rb_singleton_class(cDuckDBLogicalType), "_create_array_type",
+                             duckdb_logical_type_s_create_array_type, 2);
+    rb_define_private_method(rb_singleton_class(cDuckDBLogicalType), "_create_list_type",
+                             duckdb_logical_type_s_create_list_type, 1);
+
     rb_define_method(cDuckDBLogicalType, "initialize", initialize, 1);
 }

data/ext/duckdb/memory_helper.c

@@ -0,0 +1,339 @@
+/* frozen_string_literal: true */
+
+#include "ruby-duckdb.h"
+
+static VALUE mDuckDBMemoryHelper;
+
+/*
+ * call-seq:
+ *   DuckDB::MemoryHelper.write_bigint(ptr, index, value) -> nil
+ *
+ * Writes a 64-bit signed integer (BIGINT) to raw memory.
+ *
+ *   ptr = vector.get_data
+ *   DuckDB::MemoryHelper.write_bigint(ptr, 0, 42)  # Write 42 at index 0
+ *   DuckDB::MemoryHelper.write_bigint(ptr, 1, 84)  # Write 84 at index 1
+ */
+static VALUE rbduckdb_memory_helper_write_bigint(VALUE self, VALUE ptr, VALUE index, VALUE value) {
+    int64_t *data;
+    idx_t idx;
+    int64_t val;
+
+    (void)self;
+
+    /* Convert Ruby values to C types */
+    data = (int64_t *)NUM2ULL(ptr);
+    idx = (idx_t)NUM2ULL(index);
+    val = (int64_t)NUM2LL(value);
+
+    /* Write the value */
+    data[idx] = val;
+
+    return Qnil;
+}
+
+/*
+ * call-seq:
+ *   DuckDB::MemoryHelper.write_double(ptr, index, value) -> nil
+ *
+ * Writes a 64-bit floating point number (DOUBLE) to raw memory.
+ *
+ *   ptr = vector.get_data
+ *   DuckDB::MemoryHelper.write_double(ptr, 0, 3.14)
+ */
+static VALUE rbduckdb_memory_helper_write_double(VALUE self, VALUE ptr, VALUE index, VALUE value) {
+    double *data;
+    idx_t idx;
+    double val;
+
+    (void)self;
+
+    data = (double *)NUM2ULL(ptr);
+    idx = (idx_t)NUM2ULL(index);
+    val = NUM2DBL(value);
+
+    data[idx] = val;
+
+    return Qnil;
+}
+
+/*
+ * call-seq:
+ *   DuckDB::MemoryHelper.write_integer(ptr, index, value) -> nil
+ *
+ * Writes a 32-bit signed integer (INTEGER) to raw memory.
+ *
+ *   ptr = vector.get_data
+ *   DuckDB::MemoryHelper.write_integer(ptr, 0, 42)
+ */
+static VALUE rbduckdb_memory_helper_write_integer(VALUE self, VALUE ptr, VALUE index, VALUE value) {
+    int32_t *data;
+    idx_t idx;
+    int32_t val;
+
+    (void)self;
+
+    data = (int32_t *)NUM2ULL(ptr);
+    idx = (idx_t)NUM2ULL(index);
+    val = (int32_t)NUM2INT(value);
+
+    data[idx] = val;
+
+    return Qnil;
+}
+
+/*
+ * call-seq:
+ *   DuckDB::MemoryHelper.write_boolean(ptr, index, value) -> nil
+ *
+ * Writes a boolean to raw memory.
+ */
+static VALUE rbduckdb_memory_helper_write_boolean(VALUE self, VALUE ptr, VALUE index, VALUE value) {
+    bool *data;
+    idx_t idx;
+
+    (void)self;
+
+    data = (bool *)NUM2ULL(ptr);
+    idx = (idx_t)NUM2ULL(index);
+    data[idx] = RTEST(value);
+
+    return Qnil;
+}
+
+/*
+ * call-seq:
+ *   DuckDB::MemoryHelper.write_tinyint(ptr, index, value) -> nil
+ *
+ * Writes an 8-bit signed integer (TINYINT) to raw memory.
+ */
+static VALUE rbduckdb_memory_helper_write_tinyint(VALUE self, VALUE ptr, VALUE index, VALUE value) {
+    int8_t *data;
+    idx_t idx;
+
+    (void)self;
+
+    data = (int8_t *)NUM2ULL(ptr);
+    idx = (idx_t)NUM2ULL(index);
+    data[idx] = (int8_t)NUM2INT(value);
+
+    return Qnil;
+}
+
+/*
+ * call-seq:
+ *   DuckDB::MemoryHelper.write_smallint(ptr, index, value) -> nil
+ *
+ * Writes a 16-bit signed integer (SMALLINT) to raw memory.
+ */
+static VALUE rbduckdb_memory_helper_write_smallint(VALUE self, VALUE ptr, VALUE index, VALUE value) {
+    int16_t *data;
+    idx_t idx;
+
+    (void)self;
+
+    data = (int16_t *)NUM2ULL(ptr);
+    idx = (idx_t)NUM2ULL(index);
+    data[idx] = (int16_t)NUM2INT(value);
+
+    return Qnil;
+}
+
+/*
+ * call-seq:
+ *   DuckDB::MemoryHelper.write_utinyint(ptr, index, value) -> nil
+ *
+ * Writes an 8-bit unsigned integer (UTINYINT) to raw memory.
+ */
+static VALUE rbduckdb_memory_helper_write_utinyint(VALUE self, VALUE ptr, VALUE index, VALUE value) {
+    uint8_t *data;
+    idx_t idx;
+
+    (void)self;
+
+    data = (uint8_t *)NUM2ULL(ptr);
+    idx = (idx_t)NUM2ULL(index);
+    data[idx] = (uint8_t)NUM2UINT(value);
+
+    return Qnil;
+}
+
+/*
+ * call-seq:
+ *   DuckDB::MemoryHelper.write_usmallint(ptr, index, value) -> nil
+ *
+ * Writes a 16-bit unsigned integer (USMALLINT) to raw memory.
+ */
+static VALUE rbduckdb_memory_helper_write_usmallint(VALUE self, VALUE ptr, VALUE index, VALUE value) {
+    uint16_t *data;
+    idx_t idx;
+
+    (void)self;
+
+    data = (uint16_t *)NUM2ULL(ptr);
+    idx = (idx_t)NUM2ULL(index);
+    data[idx] = (uint16_t)NUM2UINT(value);
+
+    return Qnil;
+}
+
+/*
+ * call-seq:
+ *   DuckDB::MemoryHelper.write_uinteger(ptr, index, value) -> nil
+ *
+ * Writes a 32-bit unsigned integer (UINTEGER) to raw memory.
+ */
+static VALUE rbduckdb_memory_helper_write_uinteger(VALUE self, VALUE ptr, VALUE index, VALUE value) {
+    uint32_t *data;
+    idx_t idx;
+
+    (void)self;
+
+    data = (uint32_t *)NUM2ULL(ptr);
+    idx = (idx_t)NUM2ULL(index);
+    data[idx] = (uint32_t)NUM2ULL(value);
+
+    return Qnil;
+}
+
+/*
+ * call-seq:
+ *   DuckDB::MemoryHelper.write_ubigint(ptr, index, value) -> nil
+ *
+ * Writes a 64-bit unsigned integer (UBIGINT) to raw memory.
+ */
+static VALUE rbduckdb_memory_helper_write_ubigint(VALUE self, VALUE ptr, VALUE index, VALUE value) {
+    uint64_t *data;
+    idx_t idx;
+
+    (void)self;
+
+    data = (uint64_t *)NUM2ULL(ptr);
+    idx = (idx_t)NUM2ULL(index);
+    data[idx] = NUM2ULL(value);
+
+    return Qnil;
+}
+
+/*
+ * call-seq:
+ *   DuckDB::MemoryHelper.write_float(ptr, index, value) -> nil
+ *
+ * Writes a 32-bit floating point number (FLOAT) to raw memory.
+ */
+static VALUE rbduckdb_memory_helper_write_float(VALUE self, VALUE ptr, VALUE index, VALUE value) {
+    float *data;
+    idx_t idx;
+
+    (void)self;
+
+    data = (float *)NUM2ULL(ptr);
+    idx = (idx_t)NUM2ULL(index);
+    data[idx] = (float)NUM2DBL(value);
+
+    return Qnil;
+}
+
+/*
+ * call-seq:
+ *   DuckDB::MemoryHelper.write_timestamp(ptr, index, value) -> nil
+ *
+ * Writes a DuckDB timestamp to raw memory.
+ * +value+ must be a Ruby Time object.
+ *
+ *   ptr = vector.get_data
+ *   DuckDB::MemoryHelper.write_timestamp(ptr, 0, Time.new(2024, 3, 15, 10, 30, 45))
+ */
+static VALUE rbduckdb_memory_helper_write_timestamp(VALUE self, VALUE ptr, VALUE index, VALUE value) {
+    duckdb_timestamp *data;
+    idx_t idx;
+
+    (void)self;
+
+    if (!rb_obj_is_kind_of(value, rb_cTime)) {
+        rb_raise(rb_eTypeError, "Expected Time object for TIMESTAMP");
+    }
+
+    data = (duckdb_timestamp *)NUM2ULL(ptr);
+    idx = (idx_t)NUM2ULL(index);
+
+    VALUE local_time = rb_funcall(value, rb_intern("getlocal"), 0);
+    data[idx] = rbduckdb_to_duckdb_timestamp_from_value(
+        rb_funcall(local_time, rb_intern("year"), 0),
+        rb_funcall(local_time, rb_intern("month"), 0),
+        rb_funcall(local_time, rb_intern("day"), 0),
+        rb_funcall(local_time, rb_intern("hour"), 0),
+        rb_funcall(local_time, rb_intern("min"), 0),
+        rb_funcall(local_time, rb_intern("sec"), 0),
+        rb_funcall(local_time, rb_intern("usec"), 0)
+    );
+
+    return Qnil;
+}
+
+/*
+ * call-seq:
+ *   DuckDB::MemoryHelper.write_timestamp_tz(ptr, index, value) -> nil
+ *
+ * Writes a DuckDB TIMESTAMP_TZ to raw memory as microseconds since Unix epoch (UTC).
+ * +value+ must be a Ruby Time object.
+ *
+ *   ptr = vector.get_data
+ *   DuckDB::MemoryHelper.write_timestamp_tz(ptr, 0, Time.new(2024, 3, 15, 10, 30, 45, '+00:00'))
+ */
+static VALUE rbduckdb_memory_helper_write_timestamp_tz(VALUE self, VALUE ptr, VALUE index, VALUE value) {
+    duckdb_time_tz *data;
+    idx_t idx;
+    int64_t secs;
+    int32_t usecs;
+
+    (void)self;
+
+    if (!rb_obj_is_kind_of(value, rb_cTime)) {
+        rb_raise(rb_eTypeError, "Expected Time object for TIMESTAMP_TZ");
+    }
+
+    data = (duckdb_time_tz *)NUM2ULL(ptr);
+    idx = (idx_t)NUM2ULL(index);
+
+    secs = NUM2LL(rb_funcall(value, rb_intern("to_i"), 0));
+    usecs = NUM2INT(rb_funcall(value, rb_intern("usec"), 0));
+    data[idx].bits = (uint64_t)(secs * 1000000LL + usecs);
+
+    return Qnil;
+}
+
+static VALUE rbduckdb_memory_helper_write_date(VALUE self, VALUE ptr, VALUE index, VALUE value) {
+    duckdb_date *data;
+    idx_t idx;
+
+    data = (duckdb_date *)NUM2ULL(ptr);
+    idx = (idx_t)NUM2ULL(index);
+
+    data[idx] = rbduckdb_to_duckdb_date_from_value(
+        rb_funcall(value, rb_intern("year"), 0),
+        rb_funcall(value, rb_intern("month"), 0),
+        rb_funcall(value, rb_intern("day"), 0)
+    );
+
+    return Qnil;
+}
+
+void rbduckdb_init_memory_helper(void) {
+    mDuckDBMemoryHelper = rb_define_module_under(mDuckDB, "MemoryHelper");
+
+    rb_define_singleton_method(mDuckDBMemoryHelper, "write_bigint", rbduckdb_memory_helper_write_bigint, 3);
+    rb_define_singleton_method(mDuckDBMemoryHelper, "write_double", rbduckdb_memory_helper_write_double, 3);
+    rb_define_singleton_method(mDuckDBMemoryHelper, "write_integer", rbduckdb_memory_helper_write_integer, 3);
+    rb_define_singleton_method(mDuckDBMemoryHelper, "write_boolean", rbduckdb_memory_helper_write_boolean, 3);
+    rb_define_singleton_method(mDuckDBMemoryHelper, "write_tinyint", rbduckdb_memory_helper_write_tinyint, 3);
+    rb_define_singleton_method(mDuckDBMemoryHelper, "write_smallint", rbduckdb_memory_helper_write_smallint, 3);
+    rb_define_singleton_method(mDuckDBMemoryHelper, "write_utinyint", rbduckdb_memory_helper_write_utinyint, 3);
+    rb_define_singleton_method(mDuckDBMemoryHelper, "write_usmallint", rbduckdb_memory_helper_write_usmallint, 3);
+    rb_define_singleton_method(mDuckDBMemoryHelper, "write_uinteger", rbduckdb_memory_helper_write_uinteger, 3);
+    rb_define_singleton_method(mDuckDBMemoryHelper, "write_ubigint", rbduckdb_memory_helper_write_ubigint, 3);
+    rb_define_singleton_method(mDuckDBMemoryHelper, "write_float", rbduckdb_memory_helper_write_float, 3);
+    rb_define_singleton_method(mDuckDBMemoryHelper, "write_timestamp", rbduckdb_memory_helper_write_timestamp, 3);
+    rb_define_singleton_method(mDuckDBMemoryHelper, "write_timestamp_tz", rbduckdb_memory_helper_write_timestamp_tz, 3);
+    rb_define_singleton_method(mDuckDBMemoryHelper, "write_date", rbduckdb_memory_helper_write_date, 3);
+}

data/ext/duckdb/memory_helper.h

@@ -0,0 +1,8 @@
+/* frozen_string_literal: true */
+
+#ifndef RUBY_DUCKDB_MEMORY_HELPER_H
+#define RUBY_DUCKDB_MEMORY_HELPER_H
+
+void rbduckdb_init_memory_helper(void);
+
+#endif /* RUBY_DUCKDB_MEMORY_HELPER_H */

data/ext/duckdb/result.c

@@ -57,7 +57,6 @@ 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_value_at(duckdb_vector vector, duckdb_logical_type element_type, idx_t index);
 static VALUE vector_list(duckdb_logical_type ty, duckdb_vector vector, void* vector_data, idx_t row_idx);
 static VALUE vector_map(duckdb_logical_type ty, duckdb_vector vector, void* vector_data, idx_t row_idx);
 static VALUE vector_struct(duckdb_logical_type ty, duckdb_vector vector, idx_t row_idx);
@@ -528,7 +527,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_value_at(child, child_logical_type, i);
+        value = rbduckdb_vector_value_at(child, child_logical_type, i);
         rb_ary_store(ary, i - bgn, value);
     }
 
@@ -536,7 +535,7 @@ static VALUE vector_array(duckdb_logical_type ty, duckdb_vector vector, idx_t ro
     return ary;
 }
 
-static VALUE vector_value_at(duckdb_vector vector, duckdb_logical_type element_type, idx_t index) {
+VALUE rbduckdb_vector_value_at(duckdb_vector vector, duckdb_logical_type element_type, idx_t index) {
     uint64_t *validity;
     duckdb_type type_id;
     void* vector_data;
@@ -676,7 +675,7 @@ 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_value_at(child, child_logical_type, 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);
@@ -701,8 +700,8 @@ static VALUE vector_map(duckdb_logical_type ty, duckdb_vector vector, void* vect
     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);
+        key = rbduckdb_vector_value_at(key_vector, key_logical_type, i);
+        value = rbduckdb_vector_value_at(value_vector, value_logical_type, i);
         rb_hash_aset(hash, key, value);
     }
 
@@ -727,7 +726,7 @@ static VALUE vector_struct(duckdb_logical_type ty, duckdb_vector vector, idx_t r
             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);
+            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);
@@ -746,7 +745,7 @@ static VALUE vector_union(duckdb_logical_type ty, duckdb_vector vector, void* ve
     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);
+    value = rbduckdb_vector_value_at(vector_value, child_type, row_idx);
     duckdb_destroy_logical_type(&child_type);
     return value;
 }
@@ -830,7 +829,7 @@ static VALUE vector_value(duckdb_vector vector, idx_t row_idx) {
 
     ty = duckdb_vector_get_column_type(vector);
 
-    obj = vector_value_at(vector, ty, row_idx);
+    obj = rbduckdb_vector_value_at(vector, ty, row_idx);
 
     duckdb_destroy_logical_type(&ty);
     return obj;

data/ext/duckdb/result.h

@@ -10,6 +10,7 @@ typedef struct _rubyDuckDBResult rubyDuckDBResult;
 rubyDuckDBResult *get_struct_result(VALUE obj);
 void rbduckdb_init_duckdb_result(void);
 VALUE rbduckdb_create_result(void);
+VALUE rbduckdb_vector_value_at(duckdb_vector vector, duckdb_logical_type element_type, idx_t index);
 
 #endif
 

data/ext/duckdb/ruby-duckdb.h

@@ -30,6 +30,13 @@
 #include "./instance_cache.h"
 #include "./value_impl.h"
 #include "./scalar_function.h"
+#include "./bind_info.h"
+#include "./init_info.h"
+#include "./function_info.h"
+#include "./vector.h"
+#include "./data_chunk.h"
+#include "./memory_helper.h"
+#include "./table_function.h"
 
 extern VALUE mDuckDB;
 extern VALUE cDuckDBDatabase;