duckdb 1.5.2.1 → 1.5.4.0

data/ext/duckdb/arrow_import.c

@@ -0,0 +1,165 @@
+#include "ruby-duckdb.h"
+
+/*
+ * Internal helpers backing DuckDB::Connection#append_arrow. They consume an
+ * Arrow producer's struct ArrowArrayStream (given by its address) and convert
+ * each chunk into a DuckDB::DataChunk using DuckDB's unstable Arrow C API. The
+ * Ruby layer owns the loop, the appender lifecycle, and error handling; these
+ * primitives only do the raw-pointer / C-API work.
+ */
+
+static VALUE cDuckDBArrowConvertedSchema;
+
+typedef struct {
+    duckdb_arrow_converted_schema converted_schema;
+} rubyDuckDBArrowConvertedSchema;
+
+static void deallocate(void *ctx);
+static VALUE allocate(VALUE klass);
+static size_t memsize(const void *p);
+static void raise_error_data(duckdb_error_data error_data);
+
+static VALUE connection__arrow_converted_schema(VALUE self, VALUE address);
+static VALUE connection__arrow_next_chunk(VALUE self, VALUE address, VALUE converted);
+static VALUE connection__arrow_release(VALUE self, VALUE address);
+
+static const rb_data_type_t arrow_converted_schema_data_type = {
+    "DuckDB/ArrowConvertedSchema",
+    {NULL, deallocate, memsize,},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static void deallocate(void *ctx) {
+    rubyDuckDBArrowConvertedSchema *p = (rubyDuckDBArrowConvertedSchema *)ctx;
+
+    if (p->converted_schema) {
+        duckdb_destroy_arrow_converted_schema(&(p->converted_schema));
+    }
+    xfree(p);
+}
+
+static VALUE allocate(VALUE klass) {
+    rubyDuckDBArrowConvertedSchema *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBArrowConvertedSchema));
+    return TypedData_Wrap_Struct(klass, &arrow_converted_schema_data_type, ctx);
+}
+
+static size_t memsize(const void *p) {
+    return sizeof(rubyDuckDBArrowConvertedSchema);
+}
+
+static void raise_error_data(duckdb_error_data error_data) {
+    VALUE message;
+
+    if (error_data == NULL) {
+        return;
+    }
+    if (!duckdb_error_data_has_error(error_data)) {
+        duckdb_destroy_error_data(&error_data);
+        return;
+    }
+    message = rb_str_new_cstr(duckdb_error_data_message(error_data));
+    duckdb_destroy_error_data(&error_data);
+    rb_raise(eDuckDBError, "%s", StringValueCStr(message));
+}
+
+static struct ArrowArrayStream *stream_from_address(VALUE address) {
+    return (struct ArrowArrayStream *)(uintptr_t)NUM2ULL(address);
+}
+
+/* :nodoc: */
+static VALUE connection__arrow_converted_schema(VALUE self, VALUE address) {
+    rubyDuckDBConnection *ctx;
+    struct ArrowArrayStream *stream;
+    struct ArrowSchema schema;
+    duckdb_arrow_converted_schema converted_schema = NULL;
+    duckdb_error_data error_data;
+    VALUE obj;
+    rubyDuckDBArrowConvertedSchema *schema_ctx;
+    int rc;
+
+    ctx = rbduckdb_get_struct_connection(self);
+    stream = stream_from_address(address);
+    if (stream == NULL) {
+        rb_raise(eDuckDBError, "Arrow producer returned a NULL stream");
+    }
+
+    memset(&schema, 0, sizeof(schema));
+    rc = stream->get_schema(stream, &schema);
+    if (rc != 0) {
+        const char *err = stream->get_last_error(stream);
+        rb_raise(eDuckDBError, "failed to get Arrow schema: %s", err ? err : "unknown error");
+    }
+
+    error_data = duckdb_schema_from_arrow(ctx->con, &schema, &converted_schema);
+    if (schema.release != NULL) {
+        schema.release(&schema);
+    }
+    raise_error_data(error_data);
+
+    obj = allocate(cDuckDBArrowConvertedSchema);
+    TypedData_Get_Struct(obj, rubyDuckDBArrowConvertedSchema, &arrow_converted_schema_data_type, schema_ctx);
+    schema_ctx->converted_schema = converted_schema;
+    return obj;
+}
+
+/* :nodoc: */
+static VALUE connection__arrow_next_chunk(VALUE self, VALUE address, VALUE converted) {
+    rubyDuckDBConnection *ctx;
+    rubyDuckDBArrowConvertedSchema *schema_ctx;
+    struct ArrowArrayStream *stream;
+    struct ArrowArray array;
+    duckdb_data_chunk chunk = NULL;
+    duckdb_error_data error_data;
+    int rc;
+
+    ctx = rbduckdb_get_struct_connection(self);
+    TypedData_Get_Struct(converted, rubyDuckDBArrowConvertedSchema, &arrow_converted_schema_data_type, schema_ctx);
+    stream = stream_from_address(address);
+
+    memset(&array, 0, sizeof(array));
+    rc = stream->get_next(stream, &array);
+    if (rc != 0) {
+        const char *err = stream->get_last_error(stream);
+        rb_raise(eDuckDBError, "failed to get next Arrow chunk: %s", err ? err : "unknown error");
+    }
+    /* End of stream: a released array (release == NULL). */
+    if (array.release == NULL) {
+        return Qnil;
+    }
+
+    /* duckdb_data_chunk_from_arrow takes ownership of the array (nulls its
+     * release). On error before that, we still own it and must release it. */
+    error_data = duckdb_data_chunk_from_arrow(ctx->con, &array, schema_ctx->converted_schema, &chunk);
+    if (error_data != NULL && duckdb_error_data_has_error(error_data)) {
+        if (array.release != NULL) {
+            array.release(&array);
+        }
+        raise_error_data(error_data);
+    } else if (error_data != NULL) {
+        duckdb_destroy_error_data(&error_data);
+    }
+
+    return rbduckdb_create_data_chunk(chunk, true);
+}
+
+/* :nodoc: */
+static VALUE connection__arrow_release(VALUE self, VALUE address) {
+    struct ArrowArrayStream *stream = stream_from_address(address);
+
+    if (stream != NULL && stream->release != NULL) {
+        stream->release(stream);
+    }
+    return Qnil;
+}
+
+void rbduckdb_init_arrow_import(void) {
+#if 0
+    VALUE mDuckDB = rb_define_module("DuckDB");
+#endif
+    cDuckDBArrowConvertedSchema = rb_define_class_under(mDuckDB, "ArrowConvertedSchema", rb_cObject);
+    rb_define_alloc_func(cDuckDBArrowConvertedSchema, allocate);
+
+    rb_define_private_method(cDuckDBConnection, "_arrow_converted_schema", connection__arrow_converted_schema, 1);
+    rb_define_private_method(cDuckDBConnection, "_arrow_next_chunk", connection__arrow_next_chunk, 2);
+    rb_define_private_method(cDuckDBConnection, "_arrow_release", connection__arrow_release, 1);
+}

data/ext/duckdb/arrow_import.h

@@ -0,0 +1,6 @@
+#ifndef RUBY_DUCKDB_ARROW_IMPORT_H
+#define RUBY_DUCKDB_ARROW_IMPORT_H
+
+void rbduckdb_init_arrow_import(void);
+
+#endif

data/ext/duckdb/blob.c

@@ -2,7 +2,7 @@
 
 VALUE cDuckDBBlob;
 
-void rbduckdb_init_duckdb_blob(void) {
+void rbduckdb_init_blob(void) {
 #if 0
     VALUE mDuckDB = rb_define_module("DuckDB");
 #endif

data/ext/duckdb/blob.h

@@ -1,7 +1,6 @@
 #ifndef RUBY_DUCKDB_BLOB_H
 #define RUBY_DUCKDB_BLOB_H
 
-void rbduckdb_init_duckdb_blob(void);
+void rbduckdb_init_blob(void);
 
 #endif
-

data/ext/duckdb/config.c

@@ -79,7 +79,7 @@ static VALUE config_set_config(VALUE self, VALUE key, VALUE value) {
     return self;
 }
 
-void rbduckdb_init_duckdb_config(void) {
+void rbduckdb_init_config(void) {
 #if 0
     VALUE mDuckDB = rb_define_module("DuckDB");
 #endif

data/ext/duckdb/config.h

@@ -9,6 +9,6 @@ typedef struct _rubyDuckDBConfig rubyDuckDBConfig;
 
 rubyDuckDBConfig *get_struct_config(VALUE obj);
 
-void rbduckdb_init_duckdb_config(void);
+void rbduckdb_init_config(void);
 
 #endif

data/ext/duckdb/connection.c

@@ -15,6 +15,7 @@ static VALUE connection__register_logical_type(VALUE self, VALUE logical_type);
 static VALUE connection__register_scalar_function(VALUE self, VALUE scalar_function);
 static VALUE connection__register_scalar_function_set(VALUE self, VALUE scalar_function_set);
 static VALUE connection__register_aggregate_function(VALUE self, VALUE aggregate_function);
+static VALUE connection__register_aggregate_function_set(VALUE self, VALUE aggregate_function_set);
 static VALUE connection__register_table_function(VALUE self, VALUE table_function);
 
 static const rb_data_type_t connection_data_type = {
@@ -230,7 +231,7 @@ static VALUE connection__register_scalar_function(VALUE self, VALUE scalar_funct
     duckdb_state state;
 
     ctxcon = rbduckdb_get_struct_connection(self);
-    ctxsf = get_struct_scalar_function(scalar_function);
+    ctxsf = rbduckdb_get_struct_scalar_function(scalar_function);
 
     state = duckdb_register_scalar_function(ctxcon->con, ctxsf->scalar_function);
 
@@ -251,7 +252,7 @@ static VALUE connection__register_scalar_function_set(VALUE self, VALUE scalar_f
     duckdb_state state;
 
     ctxcon = rbduckdb_get_struct_connection(self);
-    ctxsfs = get_struct_scalar_function_set(scalar_function_set);
+    ctxsfs = rbduckdb_get_struct_scalar_function_set(scalar_function_set);
 
     state = duckdb_register_scalar_function_set(ctxcon->con, ctxsfs->scalar_function_set);
 
@@ -286,13 +287,34 @@ static VALUE connection__register_aggregate_function(VALUE self, VALUE aggregate
     return self;
 }
 
+/* :nodoc: */
+static VALUE connection__register_aggregate_function_set(VALUE self, VALUE aggregate_function_set) {
+    rubyDuckDBConnection *ctxcon;
+    rubyDuckDBAggregateFunctionSet *ctxafs;
+    duckdb_state state;
+
+    ctxcon = rbduckdb_get_struct_connection(self);
+    ctxafs = rbduckdb_get_struct_aggregate_function_set(aggregate_function_set);
+
+    state = duckdb_register_aggregate_function_set(ctxcon->con, ctxafs->aggregate_function_set);
+
+    if (state == DuckDBError) {
+        rb_raise(eDuckDBError, "Failed to register aggregate function set");
+    }
+
+    /* Keep reference to prevent GC while connection is alive */
+    rb_ary_push(ctxcon->registered_functions, aggregate_function_set);
+
+    return self;
+}
+
 static VALUE connection__register_table_function(VALUE self, VALUE table_function) {
     rubyDuckDBConnection *ctxcon;
     rubyDuckDBTableFunction *ctxtf;
     duckdb_state state;
 
     ctxcon = rbduckdb_get_struct_connection(self);
-    ctxtf = get_struct_table_function(table_function);
+    ctxtf = rbduckdb_get_struct_table_function(table_function);
 
     state = duckdb_register_table_function(ctxcon->con, ctxtf->table_function);
 
@@ -320,6 +342,7 @@ void rbduckdb_init_connection(void) {
     rb_define_private_method(cDuckDBConnection, "_register_scalar_function", connection__register_scalar_function, 1);
     rb_define_private_method(cDuckDBConnection, "_register_scalar_function_set", connection__register_scalar_function_set, 1);
     rb_define_private_method(cDuckDBConnection, "_register_aggregate_function", connection__register_aggregate_function, 1);
+    rb_define_private_method(cDuckDBConnection, "_register_aggregate_function_set", connection__register_aggregate_function_set, 1);
     rb_define_private_method(cDuckDBConnection, "_register_table_function", connection__register_table_function, 1);
     rb_define_private_method(cDuckDBConnection, "_connect", connection__connect, 1);
     rb_define_private_method(cDuckDBConnection, "_query_sql", connection__query_sql, 1);

data/ext/duckdb/converter.h

@@ -19,6 +19,7 @@ extern ID id__decimal_to_unscaled;
 VALUE rbduckdb_uuid_to_ruby(duckdb_hugeint h);
 VALUE rbduckdb_uuid_uhugeint_to_ruby(duckdb_uhugeint h);
 void rbduckdb_uuid_str_to_hugeint(VALUE uuid_str, duckdb_hugeint *out);
+void rbduckdb_uuid_str_to_uhugeint(VALUE uuid_str, duckdb_uhugeint *out);
 VALUE rbduckdb_interval_to_ruby(duckdb_interval i);
 VALUE rbduckdb_hugeint_to_ruby(duckdb_hugeint h);
 VALUE rbduckdb_uhugeint_to_ruby(duckdb_uhugeint h);

data/ext/duckdb/conveter.c

@@ -153,22 +153,21 @@ static int hex_nibble(unsigned char c)
 
 /*
  * Parse a canonical UUID string ("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx") into
- * a duckdb_hugeint. Returns true on success, false on invalid input.
+ * two uint64_t halves. Returns true on success, false on invalid input.
  *
  * Iterates the 36-character string, skipping the four dash positions. The 32
- * hex nibbles are accumulated directly into two uint64_t halves (hi, lo) with
- * no bignum arithmetic or intermediate allocation. The sign-bit flip is applied
- * to hi before storing in upper, matching DuckDB's internal UUID representation.
+ * hex nibbles are accumulated directly into hi (upper 64 bits) and lo (lower
+ * 64 bits) with no bignum arithmetic or intermediate allocation.
  */
-static bool uuid_str_to_hugeint(const char *str, long len, duckdb_hugeint *out)
+static bool parse_uuid_string(const char *str, long len, uint64_t *hi, uint64_t *lo)
 {
-    // Expected format: 8-4-4-4-12 = 36 characters with dashes at fixed positions
     if (len != 36 ||
         str[8] != '-' || str[13] != '-' || str[18] != '-' || str[23] != '-') {
         return false;
     }
 
-    uint64_t hi = 0, lo = 0;
+    *hi = 0;
+    *lo = 0;
     int nibble_idx = 0;
 
     for (int string_idx = 0; string_idx < 36; string_idx++) {
@@ -176,13 +175,27 @@ static bool uuid_str_to_hugeint(const char *str, long len, duckdb_hugeint *out)
         int nib = hex_nibble((unsigned char)str[string_idx]);
         if (nib < 0) return false;
         if (nibble_idx < 16) {
-            hi = (hi << 4) | (uint64_t)nib;
+            *hi = (*hi << 4) | (uint64_t)nib;
         } else {
-            lo = (lo << 4) | (uint64_t)nib;
+            *lo = (*lo << 4) | (uint64_t)nib;
         }
         nibble_idx++;
     }
 
+    return true;
+}
+
+/*
+ * Parse a canonical UUID string ("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx") into
+ * a duckdb_hugeint. Returns true on success, false on invalid input.
+ *
+ * The sign-bit flip is applied to hi before storing in upper, matching
+ * DuckDB's internal UUID representation.
+ */
+static bool uuid_str_to_hugeint(const char *str, long len, duckdb_hugeint *out)
+{
+    uint64_t hi, lo;
+    if (!parse_uuid_string(str, len, &hi, &lo)) return false;
     // Apply the sign-bit flip to match DuckDB's internal UUID representation
     out->upper = (int64_t)(hi ^ DUCKDB_UUID_SIGN_BIT);
     out->lower = lo;
@@ -203,6 +216,23 @@ void rbduckdb_uuid_str_to_hugeint(VALUE uuid_str, duckdb_hugeint *out)
     }
 }
 
+/*
+ * Ruby-callable wrapper: parse a UUID string VALUE into a duckdb_uhugeint
+ * (no sign-bit flip), raising ArgumentError on invalid input.
+ */
+void rbduckdb_uuid_str_to_uhugeint(VALUE uuid_str, duckdb_uhugeint *out)
+{
+    StringValue(uuid_str);
+    const char *str = RSTRING_PTR(uuid_str);
+    long len = RSTRING_LEN(uuid_str);
+    uint64_t hi, lo;
+    if (!parse_uuid_string(str, len, &hi, &lo)) {
+        rb_raise(rb_eArgError, "Invalid UUID format: %"PRIsVALUE, uuid_str);
+    }
+    out->upper = hi;
+    out->lower = lo;
+}
+
 VALUE rbduckdb_interval_to_ruby(duckdb_interval i) {
     return rb_funcall(mDuckDBConverter, id__to_interval_from_vector, 3,
                       INT2NUM(i.months),

data/ext/duckdb/data_chunk.c

@@ -44,6 +44,16 @@ rubyDuckDBDataChunk *rbduckdb_get_struct_data_chunk(VALUE obj) {
     return ctx;
 }
 
+VALUE rbduckdb_create_data_chunk(duckdb_data_chunk chunk, bool owned) {
+    VALUE obj = allocate(cDuckDBDataChunk);
+    rubyDuckDBDataChunk *ctx;
+
+    TypedData_Get_Struct(obj, rubyDuckDBDataChunk, &data_chunk_data_type, ctx);
+    ctx->data_chunk = chunk;
+    ctx->owned = owned;
+    return obj;
+}
+
 static VALUE data_chunk_initialize(int argc, VALUE *argv, VALUE self) {
     rubyDuckDBDataChunk *ctx;
     VALUE logical_types;

data/ext/duckdb/data_chunk.h

@@ -9,6 +9,7 @@ struct _rubyDuckDBDataChunk {
 typedef struct _rubyDuckDBDataChunk rubyDuckDBDataChunk;
 
 rubyDuckDBDataChunk *rbduckdb_get_struct_data_chunk(VALUE obj);
+VALUE rbduckdb_create_data_chunk(duckdb_data_chunk chunk, bool owned);
 void rbduckdb_init_data_chunk(void);
 
 #endif

data/ext/duckdb/duckdb.c

@@ -41,7 +41,7 @@ Init_duckdb_native(void) {
     rb_define_singleton_method(mDuckDB, "library_version", duckdb_s_library_version, 0);
     rb_define_singleton_method(mDuckDB, "vector_size", duckdb_s_vector_size, 0);
 
-    rbduckdb_init_duckdb_error();
+    rbduckdb_init_error();
     rbduckdb_init_database();
     rbduckdb_init_connection();
     rbduckdb_init_result();
@@ -49,27 +49,30 @@ Init_duckdb_native(void) {
     rbduckdb_init_logical_type();
     rbduckdb_init_prepared_statement();
     rbduckdb_init_pending_result();
-    rbduckdb_init_duckdb_blob();
+    rbduckdb_init_blob();
     rbduckdb_init_appender();
-    rbduckdb_init_duckdb_config();
+    rbduckdb_init_config();
     rbduckdb_init_converter();
     rbduckdb_init_extracted_statements();
     rbduckdb_init_instance_cache();
     rbduckdb_init_value();
-    rbduckdb_init_duckdb_scalar_function();
-    rbduckdb_init_duckdb_scalar_function_set();
+    rbduckdb_init_scalar_function();
+    rbduckdb_init_scalar_function_set();
     rbduckdb_init_aggregate_function();
+    rbduckdb_init_aggregate_function_set();
     rbduckdb_init_expression();
     rbduckdb_init_client_context();
-    rbduckdb_init_duckdb_scalar_function_bind_info();
+    rbduckdb_init_scalar_function_bind_info();
     rbduckdb_init_vector();
     rbduckdb_init_data_chunk();
     rbduckdb_init_memory_helper();
-    rbduckdb_init_duckdb_table_function();
-    rbduckdb_init_duckdb_table_function_bind_info();
-    rbduckdb_init_duckdb_table_function_init_info();
-    rbduckdb_init_duckdb_table_function_function_info();
+    rbduckdb_init_table_function();
+    rbduckdb_init_table_function_bind_info();
+    rbduckdb_init_table_function_init_info();
+    rbduckdb_init_table_function_function_info();
 #ifdef HAVE_DUCKDB_H_GE_V1_5_0
-    rbduckdb_init_duckdb_table_description();
+    rbduckdb_init_table_description();
 #endif
+    rbduckdb_init_arrow_array_stream();
+    rbduckdb_init_arrow_import();
 }

data/ext/duckdb/error.c

@@ -2,7 +2,7 @@
 
 VALUE eDuckDBError;
 
-void rbduckdb_init_duckdb_error(void) {
+void rbduckdb_init_error(void) {
 #if 0
     VALUE mDuckDB = rb_define_module("DuckDB");
 #endif

data/ext/duckdb/error.h

@@ -1,8 +1,6 @@
 #ifndef RUBY_DUCKDB_ERROR_H
 #define RUBY_DUCKDB_ERROR_H
 
-void rbduckdb_init_duckdb_error(void);
+void rbduckdb_init_error(void);
 
 #endif
-
-

data/ext/duckdb/extconf.rb

@@ -4,13 +4,34 @@ require 'mkmf'
 
 DUCKDB_REQUIRED_VERSION = '1.4.0'
 
+def brew_prefix(formula = nil)
+  cmd = formula ? "brew --prefix #{formula} 2>/dev/null" : 'brew --prefix 2>/dev/null'
+  prefix = `#{cmd}`.chomp
+  prefix.empty? ? nil : prefix
+end
+
+FALLBACK_PREFIXES = %w[/opt/homebrew /opt/homebrew/opt/duckdb /opt/local].freeze
+
+def brew_dirs(subdir)
+  dirs = []
+  dirs << "#{brew_prefix('duckdb')}/#{subdir}" if brew_prefix('duckdb')
+  if (prefix = brew_prefix)
+    dirs << "#{prefix}/#{subdir}"
+    dirs << "#{prefix}/opt/duckdb/#{subdir}"
+  end
+  dirs
+end
+
+def homebrew_include_dirs
+  (brew_dirs('include') + FALLBACK_PREFIXES.map { |p| "#{p}/include" }).uniq
+end
+
+def homebrew_lib_dirs
+  (brew_dirs('lib') + FALLBACK_PREFIXES.map { |p| "#{p}/lib" }).uniq
+end
+
 def check_duckdb_header(header, version)
-  found = find_header(
-    header,
-    '/opt/homebrew/include',
-    '/opt/homebrew/opt/duckdb/include',
-    '/opt/local/include'
-  )
+  found = find_header(header, *homebrew_include_dirs)
   return if found
 
   msg = "#{header} is not found. Install #{header} of duckdb >= #{version}."
@@ -19,13 +40,7 @@ def check_duckdb_header(header, version)
 end
 
 def check_duckdb_library(library, func, version)
-  found = find_library(
-    library,
-    func,
-    '/opt/homebrew/lib',
-    '/opt/homebrew/opt/duckdb/lib',
-    '/opt/local/lib'
-  )
+  found = find_library(library, func, *homebrew_lib_dirs)
   have_func(func, 'duckdb.h')
   return if found