ARROW-6235: [R] Implement conversion from arrow::BinaryArray to R character vector

r/NAMESPACE

@@ -186,6 +186,9 @@ export(int16)
 export(int32)
 export(int64)
 export(int8)
+export(large_binary)
+export(large_list_of)
+export(large_utf8)
 export(last_col)
 export(list_of)
 export(map_batches)

r/R/array.R

@@ -93,6 +93,8 @@ Array <- R6Class("Array",
         shared_ptr(StructArray, self$pointer())
       } else if (type_id == Type$LIST) {
         shared_ptr(ListArray, self$pointer())
+      } else if (type_id == Type$LARGE_LIST){
+        shared_ptr(LargeListArray, self$pointer())
       } else {
         self
       }
@@ -230,6 +232,22 @@ ListArray <- R6Class("ListArray", inherit = Array,
   )
 )
 
+#' @rdname array
+#' @usage NULL
+#' @format NULL
+#' @export
+LargeListArray <- R6Class("LargeListArray", inherit = Array,
+  public = list(
+    values = function() Array$create(LargeListArray__values(self)),
+    value_length = function(i) LargeListArray__value_length(self, i),
+    value_offset = function(i) LargeListArray__value_offset(self, i),
+    raw_value_offsets = function() LargeListArray__raw_value_offsets(self)
+  ),
+  active = list(
+    value_type = function() DataType$create(LargeListArray__value_type(self))
+  )
+)
+
 #' @export
 length.Array <- function(x) x$length()
 

r/R/enums.R

@@ -71,7 +71,13 @@ Type <- enum("Type::type",
   SPARSE_UNION = 26L,
   DENSE_UNION = 27L,
   DICTIONARY = 28L,
-  MAP = 29L
+  MAP = 29L,
+  EXTENSION = 30L,
+  FIXED_SIZE_LIST = 31L,
+  DURATION = 32L,
+  LARGE_STRING = 33L,
+  LARGE_BINARY = 34L,
+  LARGE_LIST = 35L
 )
 
 #' @rdname enums

r/R/list.R

@@ -28,3 +28,15 @@ ListType <- R6Class("ListType",
 #' @rdname data-type
 #' @export
 list_of <- function(type) shared_ptr(ListType, list__(type))
+
+LargeListType <- R6Class("LargeListType",
+  inherit = NestedType,
+  active = list(
+    value_field = function() shared_ptr(Field, LargeListType__value_field(self)),
+    value_type = function() DataType$create(LargeListType__value_type(self))
+  )
+)
+
+#' @rdname data-type
+#' @export
+large_list_of <- function(type) shared_ptr(LargeListType, large_list__(type))

r/R/type.R

@@ -60,7 +60,7 @@ DataType <- R6Class("DataType",
         FLOAT = float32(),
         DOUBLE = float64(),
         STRING = utf8(),
-        BINARY = stop("Type BINARY not implemented yet"),
+        BINARY = binary(),
         DATE32 = date32(),
         DATE64 = date64(),
         TIMESTAMP = shared_ptr(Timestamp, self$pointer()),
@@ -73,7 +73,13 @@ DataType <- R6Class("DataType",
         SPARSE_UNION = stop("Type SPARSE_UNION not implemented yet"),
         DENSE_UNION = stop("Type DENSE_UNION not implemented yet"),
         DICTIONARY = shared_ptr(DictionaryType, self$pointer()),
-        MAP = stop("Type MAP not implemented yet")
+        MAP = stop("Type MAP not implemented yet"),
+        EXTENSION = stop("Type EXTENSION not implemented yet"),
+        FIXED_SIZE_LIST = stop("Type FIXED_SIZE_LIST not implemented yet"),
+        DURATION = stop("Type DURATION not implemented yet"),
+        LARGE_STRING = large_utf8(),
+        LARGE_BINARY = large_binary(),
+        LARGE_LIST = shared_ptr(LargeListType, self$pointer())
       )
     }
   ),
@@ -141,8 +147,10 @@ Float32 <- R6Class("Float32", inherit = FixedWidthType)
 Float64 <- R6Class("Float64", inherit = FixedWidthType)
 Boolean <- R6Class("Boolean", inherit = FixedWidthType)
 Utf8 <- R6Class("Utf8", inherit = DataType)
+LargeUtf8 <- R6Class("LargeUtf8", inherit = DataType)
 Binary <- R6Class("Binary", inherit = DataType)
 FixedSizeBinary <- R6Class("FixedSizeBinary", inherit = FixedWidthType)
+LargeBinary <- R6Class("LargeBinary", inherit = DataType)
 
 DateType <- R6Class("DateType",
   inherit = FixedWidthType,
@@ -286,6 +294,10 @@ bool <- boolean
 #' @export
 utf8 <- function() shared_ptr(Utf8, Utf8__initialize())
 
+#' @rdname data-type
+#' @export
+large_utf8 <- function() shared_ptr(LargeUtf8, LargeUtf8__initialize())
+
 #' @rdname data-type
 #' @export
 binary <- function(byte_width = NULL) {
@@ -296,6 +308,12 @@ binary <- function(byte_width = NULL) {
   }
 }
 
+#' @rdname data-type
+#' @export
+large_binary <- function() {
+  shared_ptr(LargeBinary, LargeBinary__initialize())
+}
+
 #' @rdname data-type
 #' @export
 string <- utf8

r/src/array.cpp

@@ -206,29 +206,60 @@ std::shared_ptr<arrow::DataType> ListArray__value_type(
   return array->value_type();
 }
 
+// [[arrow::export]]
+std::shared_ptr<arrow::DataType> LargeListArray__value_type(
+    const std::shared_ptr<arrow::LargeListArray>& 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]]
+std::shared_ptr<arrow::Array> LargeListArray__values(
+    const std::shared_ptr<arrow::LargeListArray>& 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]]
+int64_t LargeListArray__value_length(const std::shared_ptr<arrow::LargeListArray>& 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]]
+int64_t LargeListArray__value_offset(const std::shared_ptr<arrow::LargeListArray>& 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());
 }
 
+// [[arrow::export]]
+Rcpp::IntegerVector LargeListArray__raw_value_offsets(
+    const std::shared_ptr<arrow::LargeListArray>& array) {
+  auto offsets = array->raw_value_offsets();
+  return Rcpp::IntegerVector(offsets, offsets + array->length());
+}
+
 #endif