duckdb 1.5.3.0 → 1.5.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4226fa5e46b5d23fec1fd817577faa2329dced7fa67cedacaa75140849c2de16
-  data.tar.gz: 931c46acf582c8d01057c7a5b81f8356d430d1ed44cfad85ff79fd16a1935664
+  metadata.gz: c9c37c59f2e64ac10b72765250ec674ef40e82d83a7499a6c9e1117ee8e9e9d0
+  data.tar.gz: e9510873a0de444b35bb7c3de2d26f8d9a9ebcd01466a95383fa16d38d277e97
 SHA512:
-  metadata.gz: e41cee0179f52dab024e361a69725468a7f088a6e5314df76b1d4d5d2b216b687f075c6873a4d294026e29466e99223b79653c6391a8ddf44a574dc0ec1e633e
-  data.tar.gz: 49c1f2218424af2b13009fff358de4ace4050385323d5a6e06dee4c3b301fe8ee4855abbcbd944593b1ada48ec59eabd6af1e963aed3e70085da7f74b9257fd6
+  metadata.gz: 2ab204dc5d6034b846d3267ca78fd4d47f75f000e3d6c97e5673ca9791618c84e7130230cd1ad7634858ff25fd5cc5952bac500263ef228225767a730684749c
+  data.tar.gz: f55e20a3dc6a97aea0606dca4b047746da44941c4f84145a48c45248d150fd58ef800ca617adc7921ae6418ac0f8275bf29e24405f3cdbf2e917377029b8641f

data/CHANGELOG.md

@@ -4,6 +4,17 @@ All notable changes to this project will be documented in this file.
 
 # Unreleased
 
+# 1.5.4.0 - 2026-06-20
+- bump up DuckDB 1.5.4 and 1.4.5 on CI.
+- add experimental `DuckDB::Result#arrow_c_stream` returning `DuckDB::ArrowArrayStream` to export a query result as an Arrow C stream (Arrow C Data Interface). The stream can be consumed directly by ruby-polars (`Polars::DataFrame.new(result)`) and red-arrow (`Arrow::RecordBatchReader.import(stream.to_i)`).
+- add experimental `DuckDB::Connection#append_arrow(table, producer)` to import an Arrow producer (any object responding to `#arrow_c_stream`, such as a Polars `DataFrame` or a `DuckDB::Result`) into an existing table, returning the number of rows appended.
+- drop Ruby 3.2.
+- add `DuckDB::TableFunction::InitInfo#max_threads=` (and `#set_max_threads`) to hint DuckDB how many worker threads can execute a custom table function concurrently.
+- add `DuckDB::TableFunction::InitInfo#column_count` to get the number of projected result columns of a custom table function scan.
+- add `DuckDB::TableFunction::InitInfo#column_index` to get the source column index of a given projected result column of a custom table function scan.
+- add `DuckDB::Appender#append_uuid(value)` to append a UUID value to a `UUID` column. `value` must be a String in canonical UUID format (`xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx`).
+- add `DuckDB::PreparedStatement#bind_uuid(index, value)` to bind a UUID parameter. `value` must be a String in canonical UUID format.
+
 # 1.5.3.0 - 2026-05-24
 - bump up DuckDB 1.5.3 on CI.
 - add `DuckDB::AggregateFunctionSet` class and `DuckDB::Connection#register_aggregate_function_set` to register multiple overloads of a custom aggregate function under one SQL name.

data/README.md

@@ -266,6 +266,58 @@ res.first.first # => 4
 
 Set `DuckDB.default_timezone` to control how TIMESTAMP and TIME values without time zone are converted to Ruby `Time` objects. The default is `:local`, but you can use `:utc` for UTC conversion.
 
+### Arrow interop (experimental)
+
+`DuckDB::Result#arrow_c_stream` exports a query result as an Arrow C stream
+([Arrow C Data Interface](https://arrow.apache.org/docs/format/CDataInterface.html)).
+The returned `DuckDB::ArrowArrayStream` satisfies the Ruby Arrow C stream
+protocol (`#arrow_c_stream` / `#to_i`), so query results can be handed to
+Arrow consumers in columnar form, without converting each row to Ruby objects.
+
+With [ruby-polars](https://github.com/ankane/ruby-polars), no glue code is needed:
+
+```ruby
+result = con.query('SELECT * FROM users')
+df = Polars::DataFrame.new(result)
+```
+
+With [red-arrow](https://github.com/apache/arrow/tree/main/ruby/red-arrow),
+pass the stream address to `Arrow::RecordBatchReader.import`:
+
+```ruby
+result = con.query('SELECT * FROM users')
+reader = Arrow::RecordBatchReader.import(result.arrow_c_stream.to_i)
+```
+
+The consumer takes ownership of the stream's contents, so a result can be
+exported only once; exporting the same result again raises `DuckDB::Error`.
+
+In the other direction, `DuckDB::Connection#append_arrow` imports an Arrow
+producer into an existing table. Any object responding to `#arrow_c_stream`
+works as the producer — for example a Polars `DataFrame`, or another
+`DuckDB::Result`:
+
+```ruby
+con.query('CREATE TABLE users (id BIGINT, name VARCHAR)')
+rows = con.append_arrow('users', polars_df) # => number of rows appended
+con.query('SELECT * FROM users').to_a
+```
+
+The producer's columns must line up with the table's columns by count and
+position. DuckDB casts compatible column types (e.g. INTEGER into a BIGINT
+column); a type that cannot be cast raises `DuckDB::Error`. `append_arrow` is
+not transactional — wrap it in your own transaction if you need all-or-nothing.
+
+These features are **experimental**: they are built on DuckDB's unstable Arrow
+C API and may change in any minor release.
+
+Note: [red-arrow-format](https://github.com/apache/arrow/tree/main/ruby/red-arrow-format)
+(the pure-Ruby Arrow implementation) supports only the Arrow IPC
+serialization format, not the C Data Interface. To exchange data with it,
+write/read Arrow IPC files through DuckDB's
+[arrow community extension](https://duckdb.org/community_extensions/extensions/arrow.html)
+(`COPY ... TO 'data.arrows'` / `read_arrow(...)`).
+
 ## Versioning and DuckDB support
 
 The first three digits of the gem version track the DuckDB release that the

data/ext/duckdb/aggregate_function.c

@@ -737,7 +737,6 @@ void rbduckdb_init_aggregate_function(void) {
     rb_define_alloc_func(cDuckDBAggregateFunction, allocate);
     rb_define_method(cDuckDBAggregateFunction, "initialize", aggregate_function_initialize, 0);
     rb_define_method(cDuckDBAggregateFunction, "set_name", aggregate_function_set_name, 1);
-    rb_define_method(cDuckDBAggregateFunction, "name=", aggregate_function_set_name, 1);
     rb_define_private_method(cDuckDBAggregateFunction, "_set_return_type", aggregate_function__set_return_type, 1);
     rb_define_private_method(cDuckDBAggregateFunction, "_add_parameter", aggregate_function__add_parameter, 1);
     rb_define_private_method(cDuckDBAggregateFunction, "_set_init", aggregate_function__set_init, 0);

data/ext/duckdb/appender.c

@@ -35,6 +35,7 @@ static VALUE appender__append_time(VALUE self, VALUE hour, VALUE min, VALUE sec,
 static VALUE appender__append_timestamp(VALUE self, VALUE year, VALUE month, VALUE day, VALUE hour, VALUE min, VALUE sec, VALUE micros);
 static VALUE appender__append_hugeint(VALUE self, VALUE lower, VALUE upper);
 static VALUE appender__append_uhugeint(VALUE self, VALUE lower, VALUE upper);
+static VALUE appender__append_uuid(VALUE self, VALUE val);
 static VALUE appender__append_value(VALUE self, VALUE val);
 static VALUE appender__append_data_chunk(VALUE self, VALUE chunk);
 static VALUE appender__append_default_to_chunk(VALUE self, VALUE chunk, VALUE col, VALUE row);
@@ -453,6 +454,21 @@ static VALUE appender__append_uhugeint(VALUE self, VALUE lower, VALUE upper) {
     return state_to_rbool(duckdb_append_uhugeint(ctx->appender, uhugeint));
 }
 
+/* :nodoc: */
+static VALUE appender__append_uuid(VALUE self, VALUE val) {
+    rubyDuckDBAppender *ctx;
+    duckdb_uhugeint uhugeint;
+    duckdb_value uuid_val;
+    duckdb_state state;
+
+    TypedData_Get_Struct(self, rubyDuckDBAppender, &appender_data_type, ctx);
+    rbduckdb_uuid_str_to_uhugeint(val, &uhugeint);
+    uuid_val = duckdb_create_uuid(uhugeint);
+    state = duckdb_append_value(ctx->appender, uuid_val);
+    duckdb_destroy_value(&uuid_val);
+    return state_to_rbool(state);
+}
+
 /* :nodoc: */
 static VALUE appender__append_value(VALUE self, VALUE val) {
     rubyDuckDBAppender *ctx;
@@ -578,6 +594,7 @@ void rbduckdb_init_appender(void) {
     rb_define_private_method(cDuckDBAppender, "_append_timestamp", appender__append_timestamp, 7);
     rb_define_private_method(cDuckDBAppender, "_append_hugeint", appender__append_hugeint, 2);
     rb_define_private_method(cDuckDBAppender, "_append_uhugeint", appender__append_uhugeint, 2);
+    rb_define_private_method(cDuckDBAppender, "_append_uuid", appender__append_uuid, 1);
     rb_define_private_method(cDuckDBAppender, "_append_value", appender__append_value, 1);
     rb_define_private_method(cDuckDBAppender, "_append_data_chunk", appender__append_data_chunk, 1);
     rb_define_private_method(cDuckDBAppender, "_append_default_to_chunk", appender__append_default_to_chunk, 3);

data/ext/duckdb/arrow_array_stream.c

@@ -0,0 +1,226 @@
+#include "ruby-duckdb.h"
+#include <errno.h>
+
+static VALUE cDuckDBArrowArrayStream;
+
+typedef struct {
+    struct ArrowArrayStream stream;
+} rubyDuckDBArrowArrayStream;
+
+/*
+ * Heap-allocated context referenced by stream.private_data. Consumers may
+ * move the stream struct contents out and keep using the callbacks after
+ * the Ruby DuckDB::ArrowArrayStream object is gone, so this context is
+ * freed only by the stream release callback, and it holds a reference on
+ * the result struct (rbduckdb_result_ref) until then. The release callback
+ * must not call any Ruby API: it can run during GC sweep (via deallocate
+ * of an unconsumed stream) or from a non-Ruby thread.
+ */
+typedef struct {
+    rubyDuckDBResult *presult_ctx;
+    duckdb_arrow_options arrow_options;
+    char *last_error;
+} arrowArrayStreamContext;
+
+static void deallocate(void *ctx);
+static VALUE allocate(VALUE klass);
+static size_t memsize(const void *p);
+static VALUE arrow_array_stream_to_i(VALUE self);
+static VALUE arrow_array_stream_arrow_c_stream(VALUE self);
+static void stream_set_error(arrowArrayStreamContext *ctx, const char *msg);
+static int stream_check_error(arrowArrayStreamContext *ctx, duckdb_error_data error_data);
+static int stream_get_schema(struct ArrowArrayStream *stream, struct ArrowSchema *out);
+static int stream_get_next(struct ArrowArrayStream *stream, struct ArrowArray *out);
+static const char *stream_get_last_error(struct ArrowArrayStream *stream);
+static void stream_release(struct ArrowArrayStream *stream);
+
+static const rb_data_type_t arrow_array_stream_data_type = {
+    "DuckDB/ArrowArrayStream",
+    {NULL, deallocate, memsize,},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static void deallocate(void *ctx) {
+    rubyDuckDBArrowArrayStream *p = (rubyDuckDBArrowArrayStream *)ctx;
+
+    if (p->stream.release != NULL) {
+        p->stream.release(&(p->stream));
+    }
+    xfree(p);
+}
+
+static VALUE allocate(VALUE klass) {
+    rubyDuckDBArrowArrayStream *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBArrowArrayStream));
+    return TypedData_Wrap_Struct(klass, &arrow_array_stream_data_type, ctx);
+}
+
+static size_t memsize(const void *p) {
+    return sizeof(rubyDuckDBArrowArrayStream);
+}
+
+/* Context memory is managed with plain malloc/free because the release
+ * callback may run outside Ruby's memory bookkeeping. */
+static void stream_set_error(arrowArrayStreamContext *ctx, const char *msg) {
+    size_t len = strlen(msg) + 1;
+
+    free(ctx->last_error);
+    ctx->last_error = malloc(len);
+    if (ctx->last_error != NULL) {
+        memcpy(ctx->last_error, msg, len);
+    }
+}
+
+static int stream_check_error(arrowArrayStreamContext *ctx, duckdb_error_data error_data) {
+    if (error_data == NULL) {
+        return 0;
+    }
+    if (!duckdb_error_data_has_error(error_data)) {
+        duckdb_destroy_error_data(&error_data);
+        return 0;
+    }
+    stream_set_error(ctx, duckdb_error_data_message(error_data));
+    duckdb_destroy_error_data(&error_data);
+    return EIO;
+}
+
+static int stream_get_schema(struct ArrowArrayStream *stream, struct ArrowSchema *out) {
+    arrowArrayStreamContext *ctx = (arrowArrayStreamContext *)stream->private_data;
+    duckdb_error_data error_data;
+    duckdb_logical_type *types;
+    const char **names;
+    idx_t column_count;
+    idx_t i;
+
+    column_count = duckdb_column_count(&(ctx->presult_ctx->result));
+    types = calloc((size_t)column_count, sizeof(duckdb_logical_type));
+    names = calloc((size_t)column_count, sizeof(const char *));
+    if (column_count > 0 && (types == NULL || names == NULL)) {
+        free(types);
+        free(names);
+        stream_set_error(ctx, "failed to allocate memory for Arrow schema conversion");
+        return ENOMEM;
+    }
+    for (i = 0; i < column_count; i++) {
+        types[i] = duckdb_column_logical_type(&(ctx->presult_ctx->result), i);
+        names[i] = duckdb_column_name(&(ctx->presult_ctx->result), i);
+    }
+
+    error_data = duckdb_to_arrow_schema(ctx->arrow_options, types, names, column_count, out);
+
+    for (i = 0; i < column_count; i++) {
+        duckdb_destroy_logical_type(&types[i]);
+    }
+    free(types);
+    free(names);
+    return stream_check_error(ctx, error_data);
+}
+
+static int stream_get_next(struct ArrowArrayStream *stream, struct ArrowArray *out) {
+    arrowArrayStreamContext *ctx = (arrowArrayStreamContext *)stream->private_data;
+    duckdb_data_chunk chunk;
+    duckdb_error_data error_data;
+
+    chunk = duckdb_fetch_chunk(ctx->presult_ctx->result);
+    if (chunk == NULL) {
+        /* End of stream: a released (release == NULL) array. */
+        memset(out, 0, sizeof(struct ArrowArray));
+        return 0;
+    }
+    /* duckdb_data_chunk_to_arrow copies the chunk into Arrow-owned buffers,
+     * so the chunk can be destroyed right after conversion. */
+    error_data = duckdb_data_chunk_to_arrow(ctx->arrow_options, chunk, out);
+    duckdb_destroy_data_chunk(&chunk);
+    return stream_check_error(ctx, error_data);
+}
+
+static const char *stream_get_last_error(struct ArrowArrayStream *stream) {
+    arrowArrayStreamContext *ctx = (arrowArrayStreamContext *)stream->private_data;
+
+    return ctx == NULL ? NULL : ctx->last_error;
+}
+
+static void stream_release(struct ArrowArrayStream *stream) {
+    arrowArrayStreamContext *ctx;
+
+    if (stream == NULL || stream->release == NULL) {
+        return;
+    }
+    ctx = (arrowArrayStreamContext *)stream->private_data;
+    if (ctx != NULL) {
+        rbduckdb_result_unref(ctx->presult_ctx);
+        if (ctx->arrow_options != NULL) {
+            duckdb_destroy_arrow_options(&(ctx->arrow_options));
+        }
+        free(ctx->last_error);
+        free(ctx);
+    }
+    stream->private_data = NULL;
+    stream->release = NULL;
+}
+
+VALUE rbduckdb_create_arrow_array_stream(VALUE oDuckDBResult) {
+    VALUE obj;
+    rubyDuckDBArrowArrayStream *p;
+    rubyDuckDBResult *presult_ctx;
+    arrowArrayStreamContext *ctx;
+
+    obj = allocate(cDuckDBArrowArrayStream);
+    TypedData_Get_Struct(obj, rubyDuckDBArrowArrayStream, &arrow_array_stream_data_type, p);
+    presult_ctx = rbduckdb_get_struct_result(oDuckDBResult);
+
+    ctx = calloc((size_t)1, sizeof(arrowArrayStreamContext));
+    if (ctx == NULL) {
+        rb_raise(rb_eNoMemError, "failed to allocate ArrowArrayStream context");
+    }
+
+    rbduckdb_result_ref(presult_ctx);
+    ctx->presult_ctx = presult_ctx;
+    ctx->arrow_options = duckdb_result_get_arrow_options(&(presult_ctx->result));
+
+    p->stream.get_schema = stream_get_schema;
+    p->stream.get_next = stream_get_next;
+    p->stream.get_last_error = stream_get_last_error;
+    p->stream.release = stream_release;
+    p->stream.private_data = ctx;
+
+    return obj;
+}
+
+/*
+ *  call-seq:
+ *    stream.to_i -> Integer
+ *
+ *  Returns the address of the underlying C <code>struct ArrowArrayStream</code>.
+ *  Arrow consumers such as red-arrow accept this address directly:
+ *
+ *    reader = Arrow::RecordBatchReader.import(stream.to_i)
+ */
+static VALUE arrow_array_stream_to_i(VALUE self) {
+    rubyDuckDBArrowArrayStream *p;
+
+    TypedData_Get_Struct(self, rubyDuckDBArrowArrayStream, &arrow_array_stream_data_type, p);
+    return ULL2NUM((unsigned long long)(uintptr_t)&(p->stream));
+}
+
+/*
+ *  call-seq:
+ *    stream.arrow_c_stream -> self
+ *
+ *  Returns self. Defined so that the stream object itself satisfies the
+ *  Arrow C stream protocol used by ruby-polars and others.
+ */
+static VALUE arrow_array_stream_arrow_c_stream(VALUE self) {
+    return self;
+}
+
+void rbduckdb_init_arrow_array_stream(void) {
+#if 0
+    VALUE mDuckDB = rb_define_module("DuckDB");
+#endif
+    cDuckDBArrowArrayStream = rb_define_class_under(mDuckDB, "ArrowArrayStream", rb_cObject);
+
+    rb_define_alloc_func(cDuckDBArrowArrayStream, allocate);
+
+    rb_define_method(cDuckDBArrowArrayStream, "to_i", arrow_array_stream_to_i, 0);
+    rb_define_method(cDuckDBArrowArrayStream, "arrow_c_stream", arrow_array_stream_arrow_c_stream, 0);
+}

data/ext/duckdb/arrow_array_stream.h

@@ -0,0 +1,61 @@
+#ifndef RUBY_DUCKDB_ARROW_ARRAY_STREAM_H
+#define RUBY_DUCKDB_ARROW_ARRAY_STREAM_H
+
+/*
+ * Canonical Arrow C Data Interface and Arrow C Stream Interface definitions.
+ * https://arrow.apache.org/docs/format/CDataInterface.html
+ * duckdb.h only forward-declares these structs.
+ */
+#ifndef ARROW_C_DATA_INTERFACE
+#define ARROW_C_DATA_INTERFACE
+
+#define ARROW_FLAG_DICTIONARY_ORDERED 1
+#define ARROW_FLAG_NULLABLE 2
+#define ARROW_FLAG_MAP_KEYS_SORTED 4
+
+struct ArrowSchema {
+    const char *format;
+    const char *name;
+    const char *metadata;
+    int64_t flags;
+    int64_t n_children;
+    struct ArrowSchema **children;
+    struct ArrowSchema *dictionary;
+
+    void (*release)(struct ArrowSchema *);
+    void *private_data;
+};
+
+struct ArrowArray {
+    int64_t length;
+    int64_t null_count;
+    int64_t offset;
+    int64_t n_buffers;
+    int64_t n_children;
+    const void **buffers;
+    struct ArrowArray **children;
+    struct ArrowArray *dictionary;
+
+    void (*release)(struct ArrowArray *);
+    void *private_data;
+};
+
+#endif /* ARROW_C_DATA_INTERFACE */
+
+#ifndef ARROW_C_STREAM_INTERFACE
+#define ARROW_C_STREAM_INTERFACE
+
+struct ArrowArrayStream {
+    int (*get_schema)(struct ArrowArrayStream *, struct ArrowSchema *out);
+    int (*get_next)(struct ArrowArrayStream *, struct ArrowArray *out);
+    const char *(*get_last_error)(struct ArrowArrayStream *);
+    void (*release)(struct ArrowArrayStream *);
+    void *private_data;
+};
+
+#endif /* ARROW_C_STREAM_INTERFACE */
+
+void rbduckdb_init_arrow_array_stream(void);
+VALUE rbduckdb_create_arrow_array_stream(VALUE oDuckDBResult);
+
+#endif

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

@@ -231,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);
 
@@ -252,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);
 
@@ -314,7 +314,7 @@ static VALUE connection__register_table_function(VALUE self, VALUE table_functio
     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);
 

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);