nanoarrow 0.1.0

data/ext/nanoarrow/schema_view.c

@@ -0,0 +1,204 @@
+#include <ruby/ruby.h>
+
+#include "ext.h"
+#include "nanoarrow/nanoarrow.h"
+
+VALUE cCSchemaView;
+
+typedef struct schema_view {
+    VALUE base;
+    struct ArrowSchemaView schema_view;
+    int nullable;
+} schema_view_t;
+
+static void schema_view_mark(void* ptr)
+{
+    schema_view_t* view = (schema_view_t*) ptr;
+    rb_gc_mark_movable(view->base);
+}
+
+const rb_data_type_t schema_view_data_type = {
+    .wrap_struct_name = "Nanoarrow::CSchemaView",
+    .function = {
+        .dmark = schema_view_mark,
+        .dfree = RUBY_TYPED_DEFAULT_FREE,
+    },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+VALUE schema_view_allocate(VALUE klass)
+{
+    schema_view_t* view;
+    VALUE obj = TypedData_Make_Struct(klass, schema_view_t, &schema_view_data_type, view);
+    view->base = Qnil;
+    view->schema_view.type = NANOARROW_TYPE_UNINITIALIZED;
+    view->schema_view.storage_type = NANOARROW_TYPE_UNINITIALIZED;
+    view->nullable = 0;
+    return obj;
+}
+
+VALUE schema_view_initialize(VALUE self, VALUE schema)
+{
+    schema_view_t* view;
+    GetSchemaView(self, view);
+
+    view->base = schema;
+    view->schema_view.type = NANOARROW_TYPE_UNINITIALIZED;
+    view->schema_view.storage_type = NANOARROW_TYPE_UNINITIALIZED;
+
+    schema_t* schema_ptr;
+    GetSchema(schema, schema_ptr);
+
+    struct ArrowError error;
+    int code = ArrowSchemaViewInit(&view->schema_view, schema_ptr->ptr, &error);
+    raise_message_not_ok(&error, "ArrowSchemaViewInit()", code);
+
+    view->nullable = schema_ptr->ptr->flags & ARROW_FLAG_NULLABLE;
+
+    return self;
+}
+
+VALUE schema_view_type_id(VALUE self)
+{
+    schema_view_t* view;
+    GetSchemaView(self, view);
+
+    return INT2NUM(view->schema_view.type);
+}
+
+VALUE schema_view_storage_type_id(VALUE self)
+{
+    schema_view_t* view;
+    GetSchemaView(self, view);
+
+    return INT2NUM(view->schema_view.storage_type);
+}
+
+VALUE schema_view_type(VALUE self)
+{
+    schema_view_t* view;
+    GetSchemaView(self, view);
+
+    const char* type_str = ArrowTypeString(view->schema_view.type);
+    if (type_str != NULL)
+        return rb_utf8_str_new_cstr(type_str);
+    else
+        rb_raise(rb_eArgError, "ArrowTypeString() returned NULL");
+}
+
+VALUE schema_view_nullable(VALUE self)
+{
+    schema_view_t* view;
+    GetSchemaView(self, view);
+
+    return view->nullable != 0 ? Qtrue : Qfalse;
+}
+
+bool is_fixed_size(int type)
+{
+    switch (type)
+    {
+        case NANOARROW_TYPE_FIXED_SIZE_BINARY:
+        case NANOARROW_TYPE_FIXED_SIZE_LIST:
+            return true;
+        default:
+            return false;
+    }
+}
+
+bool is_decimal(int type)
+{
+    switch (type)
+    {
+        case NANOARROW_TYPE_DECIMAL128:
+        case NANOARROW_TYPE_DECIMAL256:
+            return true;
+        default:
+            return false;
+    }
+}
+
+bool has_time_unit(int type)
+{
+    switch (type)
+    {
+        case NANOARROW_TYPE_TIME32:
+        case NANOARROW_TYPE_TIME64:
+        case NANOARROW_TYPE_TIMESTAMP:
+        case NANOARROW_TYPE_DURATION:
+            return true;
+        default:
+            return false;
+    }
+}
+
+VALUE schema_view_fixed_size(VALUE self)
+{
+    schema_view_t* view;
+    GetSchemaView(self, view);
+
+    if (is_fixed_size(view->schema_view.type))
+        return INT2NUM(view->schema_view.fixed_size);
+    else
+        return Qnil;
+}
+
+VALUE schema_view_decimal_precision(VALUE self)
+{
+    schema_view_t* view;
+    GetSchemaView(self, view);
+
+    if (is_decimal(view->schema_view.type))
+        return INT2NUM(view->schema_view.decimal_precision);
+    else
+        return Qnil;
+}
+
+VALUE schema_view_decimal_scale(VALUE self)
+{
+    schema_view_t* view;
+    GetSchemaView(self, view);
+
+    if (is_decimal(view->schema_view.type))
+        return INT2NUM(view->schema_view.decimal_scale);
+    else
+        return Qnil;
+}
+
+VALUE schema_view_time_unit(VALUE self)
+{
+    schema_view_t* view;
+    GetSchemaView(self, view);
+
+    if (has_time_unit(view->schema_view.type))
+        return rb_utf8_str_new_cstr(ArrowTimeUnitString(view->schema_view.time_unit));
+    else
+        return Qnil;
+}
+
+VALUE schema_view_timezone(VALUE self)
+{
+    schema_view_t* view;
+    GetSchemaView(self, view);
+
+    if (view->schema_view.type == NANOARROW_TYPE_TIMESTAMP)
+        return rb_utf8_str_new_cstr(view->schema_view.timezone);
+    else
+        return Qnil;
+}
+
+void Init_schema_view(void)
+{
+    cCSchemaView = rb_define_class_under(mNanoarrow, "CSchemaView", rb_cObject);
+    rb_define_alloc_func(cCSchemaView, schema_view_allocate);
+    rb_define_method(cCSchemaView, "initialize", schema_view_initialize, 1);
+    rb_define_method(cCSchemaView, "type_id", schema_view_type_id, 0);
+    rb_define_method(cCSchemaView, "storage_type_id", schema_view_storage_type_id, 0);
+    rb_define_method(cCSchemaView, "type", schema_view_type, 0);
+    rb_define_method(cCSchemaView, "nullable", schema_view_nullable, 0);
+    rb_define_method(cCSchemaView, "fixed_size", schema_view_fixed_size, 0);
+    rb_define_method(cCSchemaView, "decimal_precision", schema_view_decimal_precision, 0);
+    rb_define_method(cCSchemaView, "decimal_scale", schema_view_decimal_scale, 0);
+    rb_define_method(cCSchemaView, "time_unit", schema_view_time_unit, 0);
+    rb_define_method(cCSchemaView, "timezone", schema_view_timezone, 0);
+}

data/ext/nanoarrow/types.c

@@ -0,0 +1,48 @@
+#include <ruby/ruby.h>
+
+#include "ext.h"
+#include "nanoarrow/nanoarrow.h"
+
+void Init_types(void)
+{
+    VALUE mType = rb_define_module_under(mNanoarrow, "Type");
+    rb_define_const(mType, "NULL", INT2NUM(NANOARROW_TYPE_NA));
+    rb_define_const(mType, "BOOL", INT2NUM(NANOARROW_TYPE_BOOL));
+    rb_define_const(mType, "INT8", INT2NUM(NANOARROW_TYPE_INT8));
+    rb_define_const(mType, "UINT8", INT2NUM(NANOARROW_TYPE_UINT8));
+    rb_define_const(mType, "INT16", INT2NUM(NANOARROW_TYPE_INT16));
+    rb_define_const(mType, "UINT16", INT2NUM(NANOARROW_TYPE_UINT16));
+    rb_define_const(mType, "INT32", INT2NUM(NANOARROW_TYPE_INT32));
+    rb_define_const(mType, "UINT32", INT2NUM(NANOARROW_TYPE_UINT32));
+    rb_define_const(mType, "INT64", INT2NUM(NANOARROW_TYPE_INT64));
+    rb_define_const(mType, "UINT64", INT2NUM(NANOARROW_TYPE_UINT64));
+    rb_define_const(mType, "HALF_FLOAT", INT2NUM(NANOARROW_TYPE_HALF_FLOAT));
+    rb_define_const(mType, "FLOAT", INT2NUM(NANOARROW_TYPE_FLOAT));
+    rb_define_const(mType, "DOUBLE", INT2NUM(NANOARROW_TYPE_DOUBLE));
+    rb_define_const(mType, "STRING", INT2NUM(NANOARROW_TYPE_STRING));
+    rb_define_const(mType, "LARGE_STRING", INT2NUM(NANOARROW_TYPE_LARGE_STRING));
+    rb_define_const(mType, "STRING_VIEW", INT2NUM(NANOARROW_TYPE_STRING_VIEW));
+    rb_define_const(mType, "BINARY", INT2NUM(NANOARROW_TYPE_BINARY));
+    rb_define_const(mType, "LARGE_BINARY", INT2NUM(NANOARROW_TYPE_LARGE_BINARY));
+    rb_define_const(mType, "BINARY_VIEW", INT2NUM(NANOARROW_TYPE_BINARY_VIEW));
+    rb_define_const(mType, "FIXED_SIZE_BINARY", INT2NUM(NANOARROW_TYPE_FIXED_SIZE_BINARY));
+    rb_define_const(mType, "DATE32", INT2NUM(NANOARROW_TYPE_DATE32));
+    rb_define_const(mType, "DATE64", INT2NUM(NANOARROW_TYPE_DATE64));
+    rb_define_const(mType, "TIME32", INT2NUM(NANOARROW_TYPE_TIME32));
+    rb_define_const(mType, "TIME64", INT2NUM(NANOARROW_TYPE_TIME64));
+    rb_define_const(mType, "TIMESTAMP", INT2NUM(NANOARROW_TYPE_TIMESTAMP));
+    rb_define_const(mType, "DURATION", INT2NUM(NANOARROW_TYPE_DURATION));
+    rb_define_const(mType, "INTERVAL_MONTHS", INT2NUM(NANOARROW_TYPE_INTERVAL_MONTHS));
+    rb_define_const(mType, "INTERVAL_DAY_TIME", INT2NUM(NANOARROW_TYPE_INTERVAL_DAY_TIME));
+    rb_define_const(mType, "INTERVAL_MONTH_DAY_NANO", INT2NUM(NANOARROW_TYPE_INTERVAL_MONTH_DAY_NANO));
+    rb_define_const(mType, "DECIMAL128", INT2NUM(NANOARROW_TYPE_DECIMAL128));
+    rb_define_const(mType, "DECIMAL256", INT2NUM(NANOARROW_TYPE_DECIMAL256));
+    rb_define_const(mType, "STRUCT", INT2NUM(NANOARROW_TYPE_STRUCT));
+    rb_define_const(mType, "LIST", INT2NUM(NANOARROW_TYPE_LIST));
+    rb_define_const(mType, "LARGE_LIST", INT2NUM(NANOARROW_TYPE_LARGE_LIST));
+    rb_define_const(mType, "FIXED_SIZE_LIST", INT2NUM(NANOARROW_TYPE_FIXED_SIZE_LIST));
+    rb_define_const(mType, "MAP", INT2NUM(NANOARROW_TYPE_MAP));
+    rb_define_const(mType, "DICTIONARY", INT2NUM(NANOARROW_TYPE_DICTIONARY));
+    rb_define_const(mType, "SPARSE_UNION", INT2NUM(NANOARROW_TYPE_SPARSE_UNION));
+    rb_define_const(mType, "DENSE_UNION", INT2NUM(NANOARROW_TYPE_DENSE_UNION));
+}

data/ext/nanoarrow/utils.c

@@ -0,0 +1,202 @@
+#include <ruby/ruby.h>
+
+#include "ext.h"
+#include "nanoarrow/nanoarrow.h"
+
+void raise_todo(void)
+{
+    rb_raise(rb_const_get(mNanoarrow, rb_intern("Todo")), "not implemented yet");
+}
+
+void raise_message_not_ok(struct ArrowError* error, const char* message, int code)
+{
+    if (code != NANOARROW_OK)
+        rb_raise(rb_const_get(mNanoarrow, rb_intern("Error")), "%s", error->message);
+}
+
+void raise_error_not_ok(const char* message, int code)
+{
+    if (code != NANOARROW_OK)
+        rb_raise(rb_const_get(mNanoarrow, rb_intern("Error")), "%s", message);
+}
+
+void array_deleter(void* ptr)
+{
+    struct ArrowArray* array = (struct ArrowArray*) ptr;
+
+    if (array->release != NULL)
+        ArrowArrayRelease(array);
+
+    ArrowFree(array);
+}
+
+void rbcapsule_array_deleter(capsule_t* capsule)
+{
+    rc_t* rc = capsule_pointer(capsule, "arrow_array");
+
+    if (rc == NULL)
+        return;
+
+    rc_decrement(rc);
+}
+
+VALUE alloc_c_array(struct ArrowArray** c_array)
+{
+    *c_array = ArrowMalloc(sizeof(struct ArrowArray));
+    (*c_array)->release = NULL;
+    rc_t* rc = rc_new(*c_array, array_deleter);
+    return capsule_new(rc, "arrow_array", rbcapsule_array_deleter);
+}
+
+void rbcapsule_array_stream_deleter(capsule_t* capsule)
+{
+    struct ArrowArrayStream* stream = capsule_pointer(capsule, "arrow_array_stream");
+
+    if (stream == NULL)
+        return;
+
+    if (stream->release != NULL)
+        ArrowArrayStreamRelease(stream);
+
+    ArrowFree(stream);
+}
+
+VALUE alloc_c_array_stream(struct ArrowArrayStream** c_stream)
+{
+    *c_stream = ArrowMalloc(sizeof(struct ArrowArrayStream));
+    (*c_stream)->release = NULL;
+    return capsule_new(*c_stream, "arrow_array_stream", rbcapsule_array_stream_deleter);
+}
+
+void rbcapsule_array_view_deleter(capsule_t* capsule)
+{
+    struct ArrowArrayView* array_view = capsule_pointer(capsule, "nanoarrow_array_view");
+
+    if (array_view == NULL)
+        return;
+
+    ArrowArrayViewReset(array_view);
+
+    ArrowFree(array_view);
+}
+
+VALUE alloc_c_array_view(struct ArrowArrayView** c_array_view)
+{
+    *c_array_view = ArrowMalloc(sizeof(struct ArrowArrayView));
+    ArrowArrayViewInitFromType(*c_array_view, NANOARROW_TYPE_UNINITIALIZED);
+    return capsule_new(*c_array_view, "nanoarrow_array_view", rbcapsule_array_view_deleter);
+}
+
+void rbcapsule_buffer_deleter(capsule_t* capsule)
+{
+    struct ArrowBuffer* buffer = capsule_pointer(capsule, "nanoarrow_buffer");
+
+    if (buffer == NULL)
+        return;
+
+    ArrowBufferReset(buffer);
+    ArrowFree(buffer);
+}
+
+VALUE alloc_c_buffer(struct ArrowBuffer** c_buffer)
+{
+    *c_buffer = ArrowMalloc(sizeof(struct ArrowBuffer));
+    ArrowBufferInit(*c_buffer);
+    return capsule_new(*c_buffer, "nanoarrow_buffer", rbcapsule_buffer_deleter);
+}
+
+void rbcapsule_schema_deleter(capsule_t* capsule)
+{
+    struct ArrowSchema* schema = capsule_pointer(capsule, "arrow_schema");
+
+    if (schema == NULL)
+        return;
+
+    if (schema->release != NULL)
+        ArrowSchemaRelease(schema);
+
+    ArrowFree(schema);
+}
+
+VALUE alloc_c_schema(struct ArrowSchema** c_schema)
+{
+    *c_schema = ArrowMalloc(sizeof(struct ArrowSchema));
+    (*c_schema)->release = NULL;
+    return capsule_new(*c_schema, "arrow_schema", rbcapsule_schema_deleter);
+}
+
+void c_deallocate_rbobject_buffer(struct ArrowBufferAllocator* allocator, uint8_t* ptr, int64_t size)
+{
+    rc_t* rc = allocator->private_data;
+    rc_decrement(rc);
+}
+
+void c_rbobject_buffer(VALUE base, const void* buf, int64_t size_bytes, struct ArrowBuffer* out)
+{
+    out->data = (void*) buf;
+    out->size_bytes = size_bytes;
+
+    capsule_t* capsule;
+    GetCapsule(base, capsule);
+    rc_t* rc = capsule_pointer(capsule, "arrow_array");
+
+    if (rc == NULL)
+        rb_raise(rb_eRuntimeError, "cannot open capsule");
+
+    rc_increment(rc);
+
+    // since buffers can be moved by receiver (non-Ruby code), need to reference count
+    // and only destroy C array when no more references (this can be long after Ruby object is GCed)
+    out->allocator = ArrowBufferDeallocator(c_deallocate_rbobject_buffer, rc);
+}
+
+void c_array_shallow_copy(VALUE base, const struct ArrowArray* src, struct ArrowArray* dst)
+{
+    struct ArrowArray* tmp;
+    VALUE shelter = alloc_c_array(&tmp);
+    int code;
+
+    code = ArrowArrayInitFromType(tmp, NANOARROW_TYPE_UNINITIALIZED);
+    raise_error_not_ok("ArrowArrayInitFromType()", code);
+
+    tmp->length = src->length;
+    tmp->offset = src->offset;
+    tmp->null_count = src->null_count;
+
+    if (src->n_buffers > 3)
+    {
+        code = ArrowArrayAddVariadicBuffers(dst, src->n_buffers - 3);
+        raise_error_not_ok("ArrowArrayAddVariadicBuffers()", code);
+    }
+
+    for (int64_t i = 0; i < src->n_buffers; i++)
+    {
+        if (src->buffers[i] != NULL)
+            c_rbobject_buffer(base, src->buffers[i], 0, ArrowArrayBuffer(tmp, i));
+
+        tmp->buffers[i] = src->buffers[i];
+    }
+
+    tmp->n_buffers = src->n_buffers;
+
+    if (src->n_children > 0)
+    {
+        code = ArrowArrayAllocateChildren(tmp, src->n_children);
+        raise_error_not_ok("ArrowArrayAllocateChildren()", code);
+
+        for (int64_t i = 0; i < src->n_children; i++)
+            c_array_shallow_copy(base, src->children[i], tmp->children[i]);
+    }
+
+    if (src->dictionary != NULL)
+    {
+        code = ArrowArrayAllocateDictionary(tmp);
+        raise_error_not_ok("ArrowArrayAllocateDictionary()", code);
+
+        c_array_shallow_copy(base, src->dictionary, tmp->dictionary);
+    }
+
+    ArrowArrayMove(tmp, dst);
+
+    (void) shelter;
+}

data/lib/nanoarrow/array.rb

@@ -0,0 +1,97 @@
+module Nanoarrow
+  class Array
+    def initialize(obj, schema = nil)
+      if obj.is_a?(CMaterializedArrayStream) && schema.nil?
+        @data = obj
+        return
+      end
+
+      if obj.is_a?(Array) && schema.nil?
+        @data = obj.instance_variable_get(:@data)
+        return
+      end
+
+      if obj.is_a?(CArray) && schema.nil?
+        @data = CMaterializedArrayStream.from_c_array(obj)
+        return
+      end
+
+      stream = Utils.c_array_stream(obj, schema)
+      @data = CMaterializedArrayStream.from_c_array_stream(stream)
+    end
+
+    def self.from_chunks(obj, schema = nil, validate: true)
+      if schema.nil?
+        raise Todo
+      else
+        out_schema = Utils.c_schema(schema)
+      end
+
+      data =
+        CMaterializedArrayStream.from_c_arrays(
+          obj.map { |item| Utils.c_array(item, schema) },
+          out_schema,
+          validate
+        )
+
+      Array.new(data)
+    end
+
+    def arrow_c_stream
+      @data.arrow_c_stream
+    end
+
+    def schema
+      Schema.new(@data.schema)
+    end
+
+    def n_children
+      @data.schema.n_children
+    end
+
+    def child(i)
+      Array.new(@data.child(i))
+    end
+
+    def each_child
+      return to_enum(:each_child) unless block_given?
+
+      n_children.times do |i|
+        yield child(i)
+      end
+    end
+
+    def n_chunks
+      @data.n_arrays
+    end
+
+    def chunk(i)
+      Array.new(@data.array(i))
+    end
+
+    def each_chunk
+      return to_enum(:each_chunk) unless block_given?
+
+      n_chunks.times do |i|
+        yield chunk(i)
+      end
+    end
+
+    def length
+      @data.length
+    end
+    alias_method :size, :length
+
+    def each
+      RbIterator.get_iterator(self)
+    end
+
+    def to_a
+      each.to_a
+    end
+
+    def inspect
+      "#<#{self.class.name} #{schema.inspect}[#{length.inspect}]>"
+    end
+  end
+end

data/lib/nanoarrow/array_builder.rb

@@ -0,0 +1,115 @@
+module Nanoarrow
+  class ArrayBuilder
+    def initialize(schema)
+      @schema = Utils.c_schema(schema)
+      @schema_view = Utils.c_schema_view(@schema)
+      @c_builder = CArrayBuilder.allocate
+      @c_builder.init_from_schema(@schema)
+    end
+
+    def build_c_array(obj)
+      start_building
+      append(obj)
+      finish_building
+    end
+  end
+
+  class ArrayFromIterableBuilder < ArrayBuilder
+    def initialize(schema)
+      super(schema)
+
+      type_id = @schema_view.type_id
+      if !ARRAY_BUILDER_FROM_ITERABLE_METHOD.include?(type_id)
+        raise ArgumentError, "Can't build array of type #{@schema_view.type} from iterable"
+      end
+
+      method_name = ARRAY_BUILDER_FROM_ITERABLE_METHOD.fetch(type_id)
+      @append_impl = method(method_name)
+    end
+
+    def start_building
+      @c_builder.start_appending
+    end
+
+    def append(obj)
+      @append_impl.(obj)
+    end
+
+    def finish_building
+      @c_builder.finish
+    end
+
+    private
+
+    def append_bools(obj)
+      @c_builder.append_bools(obj)
+    end
+
+    def append_ints(obj)
+      @c_builder.append_ints(obj)
+    end
+
+    def append_uints(obj)
+      @c_builder.append_uints(obj)
+    end
+
+    def append_doubles(obj)
+      @c_builder.append_doubles(obj)
+    end
+
+    def append_strings(obj)
+      @c_builder.append_strings(obj)
+    end
+
+    def append_bytes(obj)
+      @c_builder.append_bytes(obj)
+    end
+
+    def append_dates(obj)
+      @c_builder.append_ints(obj.map { |v| v.nil? ? v : v - EPOCH })
+    end
+
+    def append_timestamps(obj)
+      obj =
+        case @schema_view.time_unit
+        when "s"
+          obj.map { |v| v.nil? ? v : v.to_i }
+        when "ms"
+          # truncates like usec
+          obj.map { |v| v.nil? ? v : v.to_i * 1_000 + v.usec / 1_000 }
+        when "us"
+          obj.map { |v| v.nil? ? v : v.to_i * 1_000_000 + v.usec }
+        when "ns"
+          obj.map { |v| v.nil? ? v : v.to_i * 1_000_000_000 + v.nsec }
+        else
+          raise Todo
+        end
+      @c_builder.append_ints(obj)
+    end
+
+    ARRAY_BUILDER_FROM_ITERABLE_METHOD = {
+      Type::BOOL => :append_bools,
+      Type::INT8 => :append_ints,
+      Type::UINT8 => :append_uints,
+      Type::INT16 => :append_ints,
+      Type::UINT16 => :append_uints,
+      Type::INT32 => :append_ints,
+      Type::UINT32 => :append_uints,
+      Type::INT64 => :append_ints,
+      Type::UINT64 => :append_uints,
+      Type::HALF_FLOAT => :append_doubles,
+      Type::FLOAT => :append_doubles,
+      Type::DOUBLE => :append_doubles,
+      Type::STRING => :append_strings,
+      Type::LARGE_STRING => :append_strings,
+      Type::STRING_VIEW => :append_strings,
+      Type::BINARY => :append_bytes,
+      Type::LARGE_BINARY => :append_bytes,
+      Type::BINARY_VIEW => :append_bytes,
+      Type::FIXED_SIZE_BINARY => :append_bytes,
+      Type::DATE32 => :append_dates,
+      Type::DATE64 => :append_dates,
+      Type::TIMESTAMP => :append_timestamps
+    }
+  end
+end

data/lib/nanoarrow/array_stream.rb

@@ -0,0 +1,32 @@
+module Nanoarrow
+  class ArrayStream
+    def initialize(obj, schema = nil)
+      @c_array_stream = Utils.c_array_stream(obj, schema)
+    end
+
+    def schema
+      Schema.new(@c_array_stream.get_cached_schema)
+    end
+
+    def arrow_c_stream
+      @c_array_stream.arrow_c_stream
+    end
+
+    def read_all
+      Array.new(@c_array_stream)
+    end
+
+    def read_next
+      c_array = @c_array_stream.get_next
+      Array.new(CMaterializedArrayStream.from_c_array(c_array)) if c_array
+    end
+
+    def each
+      return to_enum(:each) unless block_given?
+
+      while (c_array = @c_array_stream.get_next)
+        yield Array.new(CMaterializedArrayStream.from_c_array(c_array))
+      end
+    end
+  end
+end