nanoarrow 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0668ff2aa2561742313b8be3995876831289201eef98b073cb0ee6c089098b41'
-  data.tar.gz: 809ea605cd7c610f8db96d17c162a4d76ce8b68418af623bae58c563603cf96c
+  metadata.gz: a01c23d857a3993f98281df9c297cc68e27550cdd19eff8844dc088389e73375
+  data.tar.gz: 272666407eaab6685a2739e4e318a9f17df6f3284a2b5438cd5a6729d9ca6345
 SHA512:
-  metadata.gz: d90231519749a6f5c45cb5355b6d31afcbb8682bf0e33d7230603b1afe9e0f7e3fb62c191cba5ebf2cbc5a1d5888725ec365e9d359e4945a9fce47f5fbd0e239
-  data.tar.gz: c19adf7d83b663c0f1cb675f780729f26563a67d6e9ea24535a71e550e2f06860740becb3634f86707daae5cc38583a807332c59db640c5bf623463c948de8f1
+  metadata.gz: 86fcf358b4353c6b7047907a691c0742e3404c0030f7f486bd60295746c8ac6ede47630cbb4d88585166f1ac5e900ad9be688952613251efbeca26027746202c
+  data.tar.gz: cc2e9133a58184ec28159268840d5831eec8b2fd445986da2f36b2c7743ffa567e581979771f4294481ff9af82e2c504d6358d5856ef3cf0d679b3b103f61e29

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.1.1 (2026-07-21)
+
+- Added support for more types
+
 ## 0.1.0 (2026-07-18)
 
 - First release

data/ext/nanoarrow/array.c

@@ -94,6 +94,7 @@ void Init_array(void)
     rb_define_alloc_func(cCArray, array_allocate);
     rb_define_method(cCArray, "schema", array_schema, 0);
     rb_define_method(cCArray, "valid?", array_is_valid, 0);
+    rb_define_method(cCArray, "assert_valid", array_assert_valid, 0);
     rb_define_method(cCArray, "length", array_length, 0);
     rb_define_method(cCArray, "child", array_child, 1);
 }

data/ext/nanoarrow/array_builder.c

@@ -231,6 +231,164 @@ static VALUE array_builder_append_bytes(VALUE self, VALUE obj)
     return self;
 }
 
+static VALUE array_builder_append_decimals(VALUE self, VALUE obj, VALUE bitwidth, VALUE precision, VALUE scale)
+{
+    array_builder_t* builder;
+    GetArrayBuilder(self, builder);
+
+    int pi = NUM2INT(precision);
+    int si = NUM2INT(scale);
+    VALUE pad = rb_str_new_cstr("0");
+
+    struct ArrowDecimal decimal;
+    ArrowDecimalInit(&decimal, NUM2INT(bitwidth), pi, si);
+
+    Check_Type(obj, T_ARRAY);
+
+    for (long i = 0; i < RARRAY_LEN(obj); i++)
+    {
+        VALUE v = rb_ary_entry(obj, i);
+        int code;
+
+        if (NIL_P(v))
+            code = ArrowArrayAppendNull(builder->ptr, 1);
+        else
+        {
+            VALUE split = rb_funcall(v, rb_intern("split"), 0);
+            VALUE sign = rb_ary_entry(split, 0);
+            VALUE digits = rb_ary_entry(split, 1);
+            VALUE base = rb_ary_entry(split, 2);
+            VALUE exponent = rb_ary_entry(split, 3);
+
+            if (NUM2INT(base) != 10)
+                raise_todo();
+
+            Check_Type(digits, T_STRING);
+
+            // exceeds precision
+            // TODO better error
+            if (RSTRING_LEN(digits) > pi)
+                raise_todo();
+
+            int target = si + NUM2INT(exponent);
+
+            // exceeds scale
+            // TODO either round in Ruby or better error
+            if (RSTRING_LEN(digits) > target)
+                raise_todo();
+
+            digits = rb_funcall(digits, rb_intern("ljust"), 2, INT2NUM(target), pad);
+
+            struct ArrowStringView sv;
+            sv.data = StringValuePtr(digits);
+            sv.size_bytes = RSTRING_LEN(digits);
+            code = ArrowDecimalSetDigits(&decimal, sv);
+            raise_error_not_ok("ArrowDecimalSetDigits()", code);
+
+            if (NUM2INT(sign) == -1)
+                ArrowDecimalNegate(&decimal);
+
+            code = ArrowArrayAppendDecimal(builder->ptr, &decimal);
+        }
+
+        raise_error_not_ok("ArrowArrayAppendDecimal()", code);
+    }
+
+    return self;
+}
+
+static VALUE array_builder_set_offset(VALUE self, VALUE offset)
+{
+    array_builder_t* builder;
+    GetArrayBuilder(self, builder);
+
+    rb_funcall(builder->c_array, rb_intern("assert_valid"), 0);
+    builder->ptr->offset = NUM2LL(offset);
+    return self;
+}
+
+static VALUE array_builder_set_length(VALUE self, VALUE length)
+{
+    array_builder_t* builder;
+    GetArrayBuilder(self, builder);
+
+    rb_funcall(builder->c_array, rb_intern("assert_valid"), 0);
+    builder->ptr->length = NUM2LL(length);
+    return self;
+}
+
+static VALUE array_builder_set_null_count(VALUE self, VALUE null_count)
+{
+    array_builder_t* builder;
+    GetArrayBuilder(self, builder);
+
+    rb_funcall(builder->c_array, rb_intern("assert_valid"), 0);
+    builder->ptr->null_count = NUM2LL(null_count);
+    return self;
+}
+
+static VALUE array_builder_resolve_null_count(VALUE self)
+{
+    array_builder_t* builder;
+    GetArrayBuilder(self, builder);
+
+    rb_funcall(builder->c_array, rb_intern("assert_valid"), 0);
+
+    VALUE format = rb_funcall(rb_funcall(builder->c_array, rb_intern("schema"), 0), rb_intern("format"), 0);
+    if (RTEST(rb_funcall(format, rb_intern("start_with?"), 1, rb_str_new_cstr("+us:"))) || RTEST(rb_funcall(format, rb_intern("start_with?"), 1, rb_str_new_cstr("+ud:"))))
+        return self;
+
+    if (builder->ptr->null_count != -1)
+        return self;
+
+    struct ArrowBuffer* validity_buffer = ArrowArrayBuffer(builder->ptr, 0);
+    if (validity_buffer->size_bytes == 0)
+    {
+        builder->ptr->null_count = 0;
+        return self;
+    }
+
+    int64_t bits = builder->ptr->offset + builder->ptr->length;
+    int64_t bytes_required = (bits >> 3) + ((bits & 7) != 0);
+
+    if (validity_buffer->size_bytes < bytes_required)
+        rb_raise(rb_eArgError, "validity bitmap mismatch");
+
+    int64_t count = ArrowBitCountSet(
+        validity_buffer->data,
+        builder->ptr->offset,
+        builder->ptr->length
+    );
+    builder->ptr->null_count = builder->ptr->length - count;
+
+    return self;
+}
+
+static VALUE array_builder_set_child(VALUE self, VALUE idx, VALUE c_array)
+{
+    array_builder_t* builder;
+    GetArrayBuilder(self, builder);
+
+    array_t* c_array_ptr;
+    GetArray(c_array, c_array_ptr);
+
+    VALUE child = rb_funcall(builder->c_array, rb_intern("child"), 1, idx);
+    array_t* child_ptr;
+    GetArray(child, child_ptr);
+    if (child_ptr->ptr->release != NULL)
+        ArrowArrayRelease(child_ptr->ptr);
+
+    // TODO move to parameter
+    VALUE move = Qfalse;
+
+    if (!RTEST(move))
+        c_array_shallow_copy(c_array_ptr->base, c_array_ptr->ptr, child_ptr->ptr);
+    else
+        ArrowArrayMove(c_array_ptr->ptr, child_ptr->ptr);
+
+    return self;
+}
+
 static VALUE array_builder_finish(VALUE self)
 {
     array_builder_t* builder;
@@ -264,5 +422,11 @@ void Init_array_builder(void)
     rb_define_method(cCArrayBuilder, "append_doubles", array_builder_append_doubles, 1);
     rb_define_method(cCArrayBuilder, "append_strings", array_builder_append_strings, 1);
     rb_define_method(cCArrayBuilder, "append_bytes", array_builder_append_bytes, 1);
+    rb_define_method(cCArrayBuilder, "append_decimals", array_builder_append_decimals, 4);
+    rb_define_method(cCArrayBuilder, "set_offset", array_builder_set_offset, 1);
+    rb_define_method(cCArrayBuilder, "set_length", array_builder_set_length, 1);
+    rb_define_method(cCArrayBuilder, "set_null_count", array_builder_set_null_count, 1);
+    rb_define_method(cCArrayBuilder, "resolve_null_count", array_builder_resolve_null_count, 0);
+    rb_define_method(cCArrayBuilder, "set_child", array_builder_set_child, 2);
     rb_define_method(cCArrayBuilder, "finish", array_builder_finish, 0);
 }

data/ext/nanoarrow/array_view.c

@@ -76,6 +76,41 @@ static VALUE array_view_set_array(VALUE self, VALUE array)
     return self;
 }
 
+static VALUE array_view_n_children(VALUE self)
+{
+    array_view_t* view;
+    GetArrayView(self, view);
+
+    return LL2NUM(view->ptr->n_children);
+}
+
+static VALUE array_view_child(VALUE self, VALUE idx)
+{
+    array_view_t* view;
+    GetArrayView(self, view);
+
+    int64_t i = NUM2LL(idx);
+    if (i < 0 || i >= view->ptr->n_children)
+        rb_raise(rb_eIndexError, "out of range");
+
+    VALUE child = array_view_allocate(cCArrayView);
+    array_view_t* child_ptr;
+    GetArrayView(child, child_ptr);
+    child_ptr->base = view->base;
+    child_ptr->ptr = view->ptr->children[i];
+
+    return child;
+}
+
+static VALUE array_view_children(VALUE self)
+{
+    int64_t n_children = NUM2LL(array_view_n_children(self));
+    VALUE children = rb_ary_new();
+    for (int64_t i = 0; i < n_children; i++)
+        rb_ary_push(children, array_view_child(self, LL2NUM(i)));
+    return children;
+}
+
 static VALUE array_view_each_bool(VALUE self)
 {
     array_view_t* view;
@@ -162,16 +197,50 @@ static VALUE array_view_each_binary(VALUE self)
     return self;
 }
 
+static VALUE array_view_each_decimal(VALUE self, VALUE bitwidth, VALUE precision, VALUE scale)
+{
+    array_view_t* view;
+    GetArrayView(self, view);
+
+    struct ArrowDecimal decimal;
+    ArrowDecimalInit(&decimal, NUM2INT(bitwidth), NUM2INT(precision), NUM2INT(scale));
+
+    struct ArrowBuffer buffer;
+    ArrowBufferInit(&buffer);
+
+    for (int64_t i = 0; i < view->ptr->length; i++)
+    {
+        VALUE v;
+        if (ArrowArrayViewIsNull(view->ptr, i))
+            v = Qnil;
+        else
+        {
+            ArrowArrayViewGetDecimalUnsafe(view->ptr, i, &decimal);
+            int code = ArrowDecimalAppendStringToBuffer(&decimal, &buffer);
+            raise_error_not_ok("ArrowDecimalAppendStringToBuffer()", code);
+            v = rb_str_new((char*) buffer.data, buffer.size_bytes);
+            ArrowBufferReset(&buffer);
+        }
+        rb_yield(v);
+    }
+
+    return self;
+}
+
 void Init_array_view(void)
 {
     cCArrayView = rb_define_class_under(mNanoarrow, "CArrayView", rb_cObject);
     rb_define_alloc_func(cCArrayView, array_view_allocate);
     rb_define_singleton_method(cCArrayView, "from_schema", array_view_from_schema, 1);
     rb_define_method(cCArrayView, "set_array", array_view_set_array, 1);
+    rb_define_method(cCArrayView, "n_children", array_view_n_children, 0);
+    rb_define_method(cCArrayView, "child", array_view_child, 1);
+    rb_define_method(cCArrayView, "children", array_view_children, 0);
     rb_define_method(cCArrayView, "each_bool", array_view_each_bool, 0);
     rb_define_method(cCArrayView, "each_int", array_view_each_int, 0);
     rb_define_method(cCArrayView, "each_uint", array_view_each_uint, 0);
     rb_define_method(cCArrayView, "each_double", array_view_each_double, 0);
     rb_define_method(cCArrayView, "each_string", array_view_each_string, 0);
     rb_define_method(cCArrayView, "each_binary", array_view_each_binary, 0);
+    rb_define_method(cCArrayView, "each_decimal", array_view_each_decimal, 3);
 }

data/ext/nanoarrow/capsule.c

@@ -77,7 +77,10 @@ static VALUE capsule_name(VALUE self)
     capsule_t* capsule;
     GetCapsule(self, capsule);
 
-    return rb_utf8_str_new_cstr(capsule->name);
+    if (capsule->name != NULL)
+        return rb_utf8_str_new_cstr(capsule->name);
+    else
+        return Qnil;
 }
 
 void Init_capsule(void)

data/ext/nanoarrow/schema.c

@@ -227,6 +227,15 @@ static VALUE schema_child(VALUE self, VALUE rb_i)
     return obj;
 }
 
+static VALUE schema_children(VALUE self)
+{
+    int64_t n_children = NUM2LL(schema_n_children(self));
+    VALUE children = rb_ary_new();
+    for (int64_t i = 0; i < n_children; i++)
+        rb_ary_push(children, schema_child(self, LL2NUM(i)));
+    return children;
+}
+
 static VALUE schema_dictionary(VALUE self)
 {
     schema_t* schema;
@@ -273,8 +282,41 @@ static VALUE schema_arrow_c_schema(VALUE self)
     return schema_capsule;
 }
 
-static VALUE schema_modify(VALUE self, VALUE format, VALUE name, VALUE flags, VALUE nullable, VALUE metadata, VALUE children, VALUE dictionary, VALUE validate)
+static VALUE schema_modify(int argc, VALUE* argv, VALUE self)
 {
+    VALUE kwargs;
+    rb_scan_args(argc, argv, "0:", &kwargs);
+
+    ID keywords[8];
+    VALUE values[8];
+    keywords[0] = rb_intern("format");
+    keywords[1] = rb_intern("name");
+    keywords[2] = rb_intern("flags");
+    keywords[3] = rb_intern("nullable");
+    keywords[4] = rb_intern("metadata");
+    keywords[5] = rb_intern("children");
+    keywords[6] = rb_intern("dictionary");
+    keywords[7] = rb_intern("validate");
+    rb_get_kwargs(kwargs, keywords, 0, 8, values);
+
+    for (int i = 0; i < 8; i++)
+    {
+        if (values[i] == Qundef)
+            values[i] = Qnil;
+    }
+
+    VALUE format = values[0];
+    VALUE name = values[1];
+    VALUE flags = values[2];
+    VALUE nullable = values[3];
+    VALUE metadata = values[4];
+    VALUE children = values[5];
+    VALUE dictionary = values[6];
+    VALUE validate = values[7];
+
+    if (NIL_P(validate))
+        validate = Qtrue;
+
     VALUE builder = rb_funcall(cCSchemaBuilder, rb_intern("allocate"), 0);
 
     if (NIL_P(format))
@@ -306,11 +348,34 @@ static VALUE schema_modify(VALUE self, VALUE format, VALUE name, VALUE flags, VA
 
     if (NIL_P(children))
     {
-        if (NUM2LL(rb_funcall(self, rb_intern("n_children"), 0)) > 0)
-            raise_todo();
+        int64_t n_children = NUM2LL(rb_funcall(self, rb_intern("n_children"), 0));
+        if (n_children > 0)
+        {
+            rb_funcall(builder, rb_intern("allocate_children"), 1, LL2NUM(n_children));
+            VALUE self_children = rb_funcall(self, rb_intern("children"), 0);
+            for (long i = 0; i < RARRAY_LEN(self_children); i++)
+                rb_funcall(builder, rb_intern("set_child"), 3, LONG2NUM(i), Qnil, rb_ary_entry(self_children, i));
+        }
+    }
+    else if (RB_TYPE_P(children, T_HASH))
+    {
+        // not as efficient as rb_hash_foreach, but simpler
+        VALUE keys = rb_funcall(children, rb_intern("keys"), 0);
+        Check_Type(keys, T_ARRAY);
+        rb_funcall(builder, rb_intern("allocate_children"), 1, LONG2NUM(RARRAY_LEN(keys)));
+        for (long i = 0; i < RARRAY_LEN(keys); i++)
+        {
+            VALUE key = rb_ary_entry(keys, i);
+            rb_funcall(builder, rb_intern("set_child"), 3, LONG2NUM(i), key, rb_hash_lookup(children, key));
+        }
     }
     else
-        raise_todo();
+    {
+        Check_Type(children, T_ARRAY);
+        rb_funcall(builder, rb_intern("allocate_children"), 1, LONG2NUM(RARRAY_LEN(children)));
+        for (long i = 0; i < RARRAY_LEN(children); i++)
+            rb_funcall(builder, rb_intern("set_child"), 3, LONG2NUM(i), Qnil, rb_ary_entry(children, i));
+    }
 
     if (NIL_P(dictionary))
     {
@@ -338,9 +403,10 @@ void Init_schema(void)
     rb_define_method(cCSchema, "metadata", schema_metadata, 0);
     rb_define_method(cCSchema, "n_children", schema_n_children, 0);
     rb_define_method(cCSchema, "child", schema_child, 1);
+    rb_define_method(cCSchema, "children", schema_children, 0);
     rb_define_method(cCSchema, "dictionary", schema_dictionary, 0);
     rb_define_method(cCSchema, "to_s", schema_to_s, 0);
     rb_define_method(cCSchema, "arrow_c_schema", schema_arrow_c_schema, 0);
-    rb_define_method(cCSchema, "modify", schema_modify, 8);
+    rb_define_method(cCSchema, "modify", schema_modify, -1);
     rb_define_method(cCSchema, "assert_valid", schema_assert_valid, 0);
 }

data/ext/nanoarrow/schema_builder.c

@@ -183,6 +183,75 @@ static VALUE schema_builder_set_name(VALUE self, VALUE name)
     return self;
 }
 
+static VALUE schema_builder_allocate_children(VALUE self, VALUE n)
+{
+    schema_builder_t* builder;
+    GetSchemaBuilder(self, builder);
+
+    schema_assert_valid(builder->c_schema);
+
+    int code = ArrowSchemaAllocateChildren(builder->ptr, NUM2LL(n));
+    raise_error_not_ok("ArrowSchemaAllocateChildren()", code);
+
+    return self;
+}
+
+static VALUE schema_builder_set_child(VALUE self, VALUE idx, VALUE name, VALUE child_src)
+{
+    schema_builder_t* builder;
+    GetSchemaBuilder(self, builder);
+
+    schema_assert_valid(builder->c_schema);
+
+    int64_t i = NUM2LL(idx);
+    if (i < 0 || i >= builder->ptr->n_children)
+        rb_raise(rb_eIndexError, "Index out of range");
+
+    if (builder->ptr->children[i]->release != NULL)
+        ArrowSchemaRelease(builder->ptr->children[i]);
+
+    schema_t* child_src_ptr;
+    GetSchema(child_src, child_src_ptr);
+
+    int code = ArrowSchemaDeepCopy(child_src_ptr->ptr, builder->ptr->children[i]);
+    raise_error_not_ok("ArrowSchemaDeepCopy()", code);
+
+    if (!NIL_P(name))
+    {
+        Check_Type(name, T_STRING);
+        code = ArrowSchemaSetName(builder->ptr->children[i], StringValueCStr(name));
+        raise_error_not_ok("ArrowSchemaSetName()", code);
+    }
+
+    return self;
+}
+
+static VALUE schema_builder_set_dictionary(VALUE self, VALUE dictionary)
+{
+    schema_builder_t* builder;
+    GetSchemaBuilder(self, builder);
+
+    schema_assert_valid(builder->c_schema);
+
+    int code;
+    if (builder->ptr->dictionary == NULL)
+    {
+        code = ArrowSchemaAllocateDictionary(builder->ptr);
+        raise_error_not_ok("ArrowSchemaAllocateDictionary()", code);
+    }
+
+    if (builder->ptr->dictionary->release != NULL)
+        ArrowSchemaRelease(builder->ptr->dictionary);
+
+    schema_t* dictionary_ptr;
+    GetSchema(dictionary, dictionary_ptr);
+
+    code = ArrowSchemaDeepCopy(dictionary_ptr->ptr, builder->ptr->dictionary);
+    raise_error_not_ok("ArrowSchemaDeepCopy()", code);
+
+    return self;
+}
+
 static VALUE schema_builder_set_flags(VALUE self, VALUE flags)
 {
     schema_builder_t* builder;
@@ -205,6 +274,32 @@ static VALUE schema_builder_set_nullable(VALUE self, VALUE nullable)
     return self;
 }
 
+static VALUE schema_builder_set_dictionary_ordered(VALUE self, VALUE dictionary_ordered)
+{
+    schema_builder_t* builder;
+    GetSchemaBuilder(self, builder);
+
+    if (RTEST(dictionary_ordered))
+        builder->ptr->flags |= ARROW_FLAG_DICTIONARY_ORDERED;
+    else
+        builder->ptr->flags &= ~ARROW_FLAG_DICTIONARY_ORDERED;
+
+    return self;
+}
+
+static VALUE schema_builder_set_map_keys_sorted(VALUE self, VALUE map_keys_sorted)
+{
+    schema_builder_t* builder;
+    GetSchemaBuilder(self, builder);
+
+    if (RTEST(map_keys_sorted))
+        builder->ptr->flags |= ARROW_FLAG_MAP_KEYS_SORTED;
+    else
+        builder->ptr->flags &= ~ARROW_FLAG_MAP_KEYS_SORTED;
+
+    return self;
+}
+
 static VALUE schema_builder_validate(VALUE self)
 {
     schema_builder_t* builder;
@@ -244,8 +339,13 @@ void Init_schema_builder(void)
     rb_define_method(cCSchemaBuilder, "set_type_date_time", schema_builder_set_type_date_time, 3);
     rb_define_method(cCSchemaBuilder, "set_format", schema_builder_set_format, 1);
     rb_define_method(cCSchemaBuilder, "set_name", schema_builder_set_name, 1);
+    rb_define_method(cCSchemaBuilder, "allocate_children", schema_builder_allocate_children, 1);
+    rb_define_method(cCSchemaBuilder, "set_child", schema_builder_set_child, 3);
+    rb_define_method(cCSchemaBuilder, "set_dictionary", schema_builder_set_dictionary, 1);
     rb_define_method(cCSchemaBuilder, "set_flags", schema_builder_set_flags, 1);
     rb_define_method(cCSchemaBuilder, "set_nullable", schema_builder_set_nullable, 1);
+    rb_define_method(cCSchemaBuilder, "set_dictionary_ordered", schema_builder_set_dictionary_ordered, 1);
+    rb_define_method(cCSchemaBuilder, "set_map_keys_sorted", schema_builder_set_map_keys_sorted, 1);
     rb_define_method(cCSchemaBuilder, "validate", schema_builder_validate, 0);
     rb_define_method(cCSchemaBuilder, "finish", schema_builder_finish, 0);
 }

data/lib/nanoarrow/array_builder.rb

@@ -87,6 +87,30 @@ module Nanoarrow
       @c_builder.append_ints(obj)
     end
 
+    def append_decimals(obj)
+      obj = obj.map { |v| (v.nil? || v.is_a?(BigDecimal)) ? v : BigDecimal(v.to_s) }
+      bitwidth = @schema_view.type_id == Type::DECIMAL128 ? 128 : 256
+      @c_builder.append_decimals(obj, bitwidth, @schema_view.decimal_precision, @schema_view.decimal_scale)
+    end
+
+    def append_struct(obj)
+      keys = @schema.children.map(&:name)
+      objs = keys.map { |k| obj.map { |v| v.nil? ? v : v.fetch(k) } }
+
+      # check for extra keys
+      obj.each do |v|
+        if !v.nil? && v.except(*keys).any?
+          raise ArgumentError, "extra keys"
+        end
+      end
+
+      arrays = @schema.children.zip(objs).map { |s, v| Utils.c_array(v, s) }
+      arrays.each_with_index do |a, i|
+        @c_builder.set_child(i, a)
+      end
+      @c_builder.set_length(objs[0].length)
+    end
+
     ARRAY_BUILDER_FROM_ITERABLE_METHOD = {
       Type::BOOL => :append_bools,
       Type::INT8 => :append_ints,
@@ -109,7 +133,10 @@ module Nanoarrow
       Type::FIXED_SIZE_BINARY => :append_bytes,
       Type::DATE32 => :append_dates,
       Type::DATE64 => :append_dates,
-      Type::TIMESTAMP => :append_timestamps
+      Type::TIMESTAMP => :append_timestamps,
+      Type::DECIMAL128 => :append_decimals,
+      Type::DECIMAL256 => :append_decimals,
+      Type::STRUCT => :append_struct
     }
   end
 end

data/lib/nanoarrow/iterator.rb

@@ -1,9 +1,14 @@
 module Nanoarrow
   class ArrayViewBaseIterator
-    def initialize(schema)
+    def initialize(schema, array_view: nil)
       @schema = Utils.c_schema(schema)
       @schema_view = Utils.c_schema_view(schema)
-      @array_view = CArrayView.from_schema(@schema)
+
+      if array_view.nil?
+        @array_view = CArrayView.from_schema(@schema)
+      else
+        @array_view = array_view
+      end
     end
 
     def set_array(array)
@@ -23,11 +28,15 @@ module Nanoarrow
       end
     end
 
-    def initialize(schema)
-      super(schema)
+    def initialize(schema, array_view: nil)
+      super(schema, array_view: array_view)
+
+      @children = @schema.children.zip(@array_view.children).map { |s, v| make_child(s, v) }
     end
 
     def each(&block)
+      return to_enum(:each) unless block_given?
+
       type_id = @schema_view.type_id
       if !ITEMS_ITER_LOOKUP.include?(type_id)
         raise KeyError, "Can't resolve iterator for type #{@schema_view.type.inspect}"
@@ -39,6 +48,10 @@ module Nanoarrow
 
     private
 
+    def make_child(schema, array_view)
+      self.class.new(schema, array_view: array_view)
+    end
+
     def each_bool(&block)
       @array_view.each_bool(&block)
     end
@@ -85,6 +98,21 @@ module Nanoarrow
       @array_view.each_int(&wrap)
     end
 
+    def each_decimal(&block)
+      bitwidth = @schema_view.type_id == Type::DECIMAL128 ? 128 : 256
+      wrap = ->(v) { block.call(v.nil? ? v : BigDecimal(v)) }
+      @array_view.each_decimal(bitwidth, @schema_view.decimal_precision, @schema_view.decimal_scale, &wrap)
+    end
+
+    def each_struct(&block)
+      if @children.any?
+        keys = @schema.children.map(&:name)
+        @children[0].each.zip(*@children[1..]) do |v|
+          block.call(v[0].nil? ? nil : keys.zip(v).to_h)
+        end
+      end
+    end
+
     ITEMS_ITER_LOOKUP = {
       Type::BOOL => :each_bool,
       Type::INT8 => :each_int,
@@ -108,6 +136,9 @@ module Nanoarrow
       Type::DATE32 => :each_date,
       Type::DATE64 => :each_date,
       Type::TIMESTAMP => :each_timestamp,
+      Type::DECIMAL128 => :each_decimal,
+      Type::DECIMAL256 => :each_decimal,
+      Type::STRUCT => :each_struct
     }
   end
 end

data/lib/nanoarrow/schema.rb

@@ -18,7 +18,7 @@ module Nanoarrow
       end
 
       if !name.nil? || !nullable.nil? || !metadata.nil? || !fields.nil?
-        @c_schema = @c_schema.modify(nil, name, nil, nullable, metadata, fields, nil, true)
+        @c_schema = @c_schema.modify(name:, nullable:, metadata:, children: clean_fields(fields))
       end
 
       @c_schema_view = CSchemaView.new(@c_schema)
@@ -81,5 +81,17 @@ module Nanoarrow
     def arrow_c_schema
       @c_schema.arrow_c_schema
     end
+
+    private
+
+    def clean_fields(fields)
+      if fields.nil?
+        fields
+      elsif fields.is_a?(Hash)
+        fields.transform_values { |v| Utils.c_schema(v) }
+      else
+        fields.map { |v| Utils.c_schema(v) }
+      end
+    end
   end
 end

data/lib/nanoarrow/types.rb

@@ -147,11 +147,17 @@ module Nanoarrow
     Schema.new(Type::DICTIONARY, index_type:, value_type:, dictionary_ordered:)
   end
 
-  def self.sparse_union(fields, nullable: true)
-    Schema.new(Type::SPARSE_UNION, fields:, nullable:)
-  end
-
-  def self.dense_union(fields, nullable: true)
-    Schema.new(Type::DENSE_UNION, fields:, nullable:)
+  def self.sparse_union(fields, type_codes: nil, nullable: true)
+    if type_codes.nil?
+      type_codes = fields.size.times.to_a
+    end
+    Schema.new(Type::SPARSE_UNION, fields:, type_codes:, nullable:)
+  end
+
+  def self.dense_union(fields, type_codes: nil, nullable: true)
+    if type_codes.nil?
+      type_codes = fields.size.times.to_a
+    end
+    Schema.new(Type::DENSE_UNION, fields:, type_codes:, nullable:)
   end
 end

data/lib/nanoarrow/utils.rb

@@ -90,25 +90,61 @@ module Nanoarrow
         factory.set_type_fixed_size(type, Integer(params.delete(:byte_width)))
 
       elsif type == Type::LIST
-        raise Todo
+        factory.set_format("+l")
+        factory.allocate_children(1)
+        factory.set_child(0, "item", c_schema(params.delete(:value_type)))
 
       elsif type == Type::LARGE_LIST
-        raise Todo
+        factory.set_format("+L")
+        factory.allocate_children(1)
+        factory.set_child(0, "item", c_schema(params.delete(:value_type)))
 
       elsif type == Type::FIXED_SIZE_LIST
-        raise Todo
+        fixed_size = Integer(params.delete(:list_size))
+        factory.set_format("+w:%d" % fixed_size)
+        factory.allocate_children(1)
+        factory.set_child(0, "item", c_schema(params.delete(:value_type)))
 
       elsif type == Type::MAP
-        raise Todo
+        key_schema = c_schema(params.delete(:key_type))
+        value_schema = c_schema(params.delete(:value_type))
+
+        entries = CSchemaBuilder.allocate
+        entries.set_format("+s")
+        entries.set_nullable(false)
+        entries.allocate_children(2)
+        entries.set_child(0, "key", key_schema.modify(nullable: false))
+        entries.set_child(1, "value", value_schema)
+
+        factory.set_format("+m")
+        factory.allocate_children(1)
+        factory.set_child(0, "entries", entries.finish)
+        factory.set_nullable(false)
+
+        if params.include?(:keys_sorted)
+          factory.set_map_keys_sorted(params.delete(:keys_sorted))
+        end
 
       elsif type == Type::DICTIONARY
-        raise Todo
+        index_type = c_schema(params.delete(:index_type))
+        factory.set_format(index_type.format)
+
+        value_type = c_schema(params.delete(:value_type))
+        factory.set_dictionary(value_type)
+
+        if params.delete(:dictionary_ordered)
+          factory.set_dictionary_ordered(true)
+        end
 
       elsif type == Type::SPARSE_UNION
-        raise Todo
+        type_codes = params.delete(:type_codes)
+        type_codes_str = type_codes.map { |code| Integer(code) }.join(",")
+        factory.set_format("+us:#{type_codes_str}")
 
       elsif type == Type::DENSE_UNION
-        raise Todo
+        type_codes = params.delete(:type_codes)
+        type_codes_str = type_codes.map { |code| Integer(code) }.join(",")
+        factory.set_format("+ud:#{type_codes_str}")
 
       else
         factory.set_type(type)

data/lib/nanoarrow/version.rb

@@ -1,3 +1,3 @@
 module Nanoarrow
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nanoarrow
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Andrew Kane