ARROW-8024: [R] Bindings for BinaryType and FixedSizeBinaryType

r/NAMESPACE

@@ -142,6 +142,7 @@ export(TimeUnit)
 export(Type)
 export(UnionDataset)
 export(arrow_available)
+export(binary)
 export(bool)
 export(boolean)
 export(buffer)

r/R/type.R

@@ -140,6 +140,8 @@ Float32 <- R6Class("Float32", inherit = FixedWidthType)
 Float64 <- R6Class("Float64", inherit = FixedWidthType)
 Boolean <- R6Class("Boolean", inherit = FixedWidthType)
 Utf8 <- R6Class("Utf8", inherit = DataType)
+Binary <- R6Class("Binary", inherit = DataType)
+FixedSizeBinary <- R6Class("FixedSizeBinary", inherit = FixedWidthType)
 
 DateType <- R6Class("DateType",
   inherit = FixedWidthType,
@@ -202,6 +204,9 @@ NestedType <- R6Class("NestedType", inherit = DataType)
 #' either "s" or "ms", while `time64()` can be "us" or "ns". `timestamp()` can
 #' take any of those four values.
 #' @param timezone For `timestamp()`, an optional time zone string.
+#' @param byte_width For `binary()`, an optional integer width to create a
+#' `FixedSizeBinary` type. The default `NULL` results in a `BinaryType` with
+#' variable width.
 #' @param precision For `decimal()`, precision
 #' @param scale For `decimal()`, scale
 #' @param type For `list_of()`, a data type to make a list-of-type
@@ -280,6 +285,16 @@ bool <- boolean
 #' @export
 utf8 <- function() shared_ptr(Utf8, Utf8__initialize())
 
+#' @rdname data-type
+#' @export
+binary <- function(byte_width = NULL) {
+  if (is.null(byte_width)) {
+    shared_ptr(Binary, Binary__initialize())
+  } else {
+    shared_ptr(FixedSizeBinary, FixedSizeBinary__initialize(byte_width))
+  }
+}
+
 #' @rdname data-type
 #' @export
 string <- utf8

r/src/datatype.cpp

@@ -73,6 +73,9 @@ std::shared_ptr<arrow::DataType> Boolean__initialize() { return arrow::boolean()
 // [[arrow::export]]
 std::shared_ptr<arrow::DataType> Utf8__initialize() { return arrow::utf8(); }
 
+// [[arrow::export]]
+std::shared_ptr<arrow::DataType> Binary__initialize() { return arrow::binary(); }
+
 // [[arrow::export]]
 std::shared_ptr<arrow::DataType> Date32__initialize() { return arrow::date32(); }
 
@@ -85,11 +88,20 @@ std::shared_ptr<arrow::DataType> Null__initialize() { return arrow::null(); }
 // [[arrow::export]]
 std::shared_ptr<arrow::DataType> Decimal128Type__initialize(int32_t precision,
                                                             int32_t scale) {
-  return arrow::decimal(precision, scale);
+  // Use the builder that validates inputs
+  std::shared_ptr<arrow::DataType> out;
+  STOP_IF_NOT_OK(arrow::Decimal128Type::Make(precision, scale, &out));
+  return out;
 }
 
 // [[arrow::export]]
 std::shared_ptr<arrow::DataType> FixedSizeBinary__initialize(int32_t byte_width) {
+  if (byte_width == NA_INTEGER) {
+    Rcpp::stop("'byte_width' cannot be NA");
+  }
+  if (byte_width < 1) {
+    Rcpp::stop("'byte_width' must be > 0");
+  }
   return arrow::fixed_size_binary(byte_width);
 }
 

r/tests/testthat/test-data-type.R

@@ -379,12 +379,36 @@ test_that("DictionaryType validation", {
     dictionary(utf8(), int32()),
     "Dictionary index type should be signed integer, got string"
   )
+  expect_error(dictionary(4, utf8()), 'index_type must be a "DataType"')
+  expect_error(dictionary(int8(), "strings"), 'value_type must be a "DataType"')
 })
 
 test_that("decimal type and validation", {
   expect_error(decimal(), 'argument "precision" is missing, with no default')
   expect_error(decimal("four"), '"precision" must be an integer')
   expect_error(decimal(4), 'argument "scale" is missing, with no default')
   expect_error(decimal(4, "two"), '"scale" must be an integer')
+  expect_error(decimal(NA, 2), '"precision" must be an integer')
+  expect_error(decimal(0, 2), "Invalid: Decimal precision out of range: 0")
+  expect_error(decimal(100, 2), "Invalid: Decimal precision out of range: 100")
+  expect_error(decimal(4, NA), '"scale" must be an integer')
+
   expect_is(decimal(4, 2), "Decimal128Type")
+
+})
+
+test_that("Binary", {
+  expect_is(binary(), "Binary")
+  expect_equal(binary()$ToString(), "binary")
+})
+
+test_that("FixedSizeBinary", {
+  expect_is(binary(4), "FixedSizeBinary")
+  expect_equal(binary(4)$ToString(), "fixed_size_binary[4]")
+
+  # input validation
+  expect_error(binary(NA), "'byte_width' cannot be NA")
+  expect_error(binary(-1), "'byte_width' must be > 0")
+  expect_error(binary("four"), class = "Rcpp::not_compatible")
+  expect_error(binary(c(2, 4)), class = "Rcpp::not_compatible")
 })