ARROW-5586: [R] convert Array of LIST type to R lists

r/R/List.R

@@ -18,7 +18,11 @@
 #' @include R6.R
 
 `arrow::ListType` <- R6Class("arrow::ListType",
-  inherit = `arrow::NestedType`
+  inherit = `arrow::NestedType`,
+  active = list(
+    value_field = function() shared_ptr(`arrow::Field`, ListType__value_field(self)),
+    value_type = function() `arrow::DataType`$dispatch(ListType__value_type(self))
+  )
 )
 
 #' @rdname DataType

r/R/array.R

@@ -118,12 +118,26 @@
   )
 )
 
+`arrow::ListArray` <- R6Class("arrow::ListArray", inherit = `arrow::Array`,
+  public = list(
+    values = function() `arrow::Array`$dispatch(ListArray__values(self)),
+    value_length = function(i) ListArray__value_length(self, i),
+    value_offset = function(i) ListArray__value_offset(self, i),
+    raw_value_offsets = function() ListArray__raw_value_offsets(self)
+  ),
+  active = list(
+    value_type = function() `arrow::DataType`$dispatch(ListArray__value_type(self))
+  )
+)
+
 `arrow::Array`$dispatch <- function(xp){
   a <- shared_ptr(`arrow::Array`, xp)
   if(a$type_id() == Type$DICTIONARY){
     a <- shared_ptr(`arrow::DictionaryArray`, xp)
   } else if (a$type_id() == Type$STRUCT) {
     a <- shared_ptr(`arrow::StructArray`, xp)
+  } else if(a$type_id() == Type$LIST) {
+    a <- shared_ptr(`arrow::ListArray`, xp)
   }
   a
 }

r/src/array.cpp

@@ -140,4 +140,35 @@ arrow::ArrayVector StructArray__Flatten(
   return out;
 }
 
+// [[arrow::export]]
+std::shared_ptr<arrow::DataType> ListArray__value_type(
+    const std::shared_ptr<arrow::ListArray>& array) {
+  return array->value_type();
+}
+
+// [[arrow::export]]
+std::shared_ptr<arrow::Array> ListArray__values(
+    const std::shared_ptr<arrow::ListArray>& array) {
+  return array->values();
+}
+
+// [[arrow::export]]
+int32_t ListArray__value_length(const std::shared_ptr<arrow::ListArray>& array,
+                                int64_t i) {
+  return array->value_length(i);
+}
+
+// [[arrow::export]]
+int32_t ListArray__value_offset(const std::shared_ptr<arrow::ListArray>& array,
+                                int64_t i) {
+  return array->value_offset(i);
+}
+
+// [[arrow::export]]
+Rcpp::IntegerVector ListArray__raw_value_offsets(
+    const std::shared_ptr<arrow::ListArray>& array) {
+  auto offsets = array->raw_value_offsets();
+  return Rcpp::IntegerVector(offsets, offsets + array->length());
+}
+
 #endif

r/src/array__to_vector.cpp

@@ -547,6 +547,47 @@ class Converter_Decimal : public Converter {
   }
 };
 
+class Converter_List : public Converter {
+ public:
+  explicit Converter_List(const ArrayVector& arrays) : Converter(arrays) {}
+
+  SEXP Allocate(R_xlen_t n) const { return Rcpp::List(no_init(n)); }
+
+  Status Ingest_all_nulls(SEXP data, R_xlen_t start, R_xlen_t n) const {
+    // nothing to do, list contain NULL by default
+    return Status::OK();
+  }
+
+  Status Ingest_some_nulls(SEXP data, const std::shared_ptr<arrow::Array>& array,
+                           R_xlen_t start, R_xlen_t n) const {
+    using internal::checked_cast;
+    auto list_array = checked_cast<arrow::ListArray*>(array.get());
+    auto values_array = list_array->values();
+
+    auto ingest_one = [&](R_xlen_t i) {
+      auto slice =
+          values_array->Slice(list_array->value_offset(i), list_array->value_length(i));
+      SET_VECTOR_ELT(data, i + start, Array__as_vector(slice));
+    };
+
+    if (array->null_count()) {
+      internal::BitmapReader bitmap_reader(array->null_bitmap()->data(), array->offset(),
+                                           n);
+
+      for (R_xlen_t i = 0; i < n; i++, bitmap_reader.Next()) {
+        if (bitmap_reader.IsSet()) ingest_one(i);
+      }
+
+    } else {
+      for (R_xlen_t i = 0; i < n; i++) {
+        ingest_one(i);
+      }
+    }
+
+    return Status::OK();
+  }
+};
+
 class Converter_Int64 : public Converter {
  public:
   explicit Converter_Int64(const ArrayVector& arrays) : Converter(arrays) {}
@@ -658,9 +699,13 @@ std::shared_ptr<Converter> Converter::Make(const ArrayVector& arrays) {
     case Type::DECIMAL:
       return std::make_shared<arrow::r::Converter_Decimal>(arrays);
 
+      // nested
     case Type::STRUCT:
       return std::make_shared<arrow::r::Converter_Struct>(arrays);
 
+    case Type::LIST:
+      return std::make_shared<arrow::r::Converter_List>(arrays);
+
     default:
       break;
   }

r/src/datatype.cpp

@@ -281,4 +281,16 @@ int StructType__GetFieldIndex(const std::shared_ptr<arrow::StructType>& type,
   return type->GetFieldIndex(name);
 }
 
+// [[arrow::export]]
+std::shared_ptr<arrow::Field> ListType__value_field(
+    const std::shared_ptr<arrow::ListType>& type) {
+  return type->value_field();
+}
+
+// [[arrow::export]]
+std::shared_ptr<arrow::DataType> ListType__value_type(
+    const std::shared_ptr<arrow::ListType>& type) {
+  return type->value_type();
+}
+
 #endif

r/tests/testthat/test-DataType.R

@@ -297,6 +297,8 @@ test_that("list type works as expected", {
     x$children(),
     list(field("item", int32()))
   )
+  expect_equal(x$value_type, int32())
+  expect_equal(x$value_field, field("item", int32()))
 })
 
 test_that("struct type works as expected", {