try implementation the other direction

Author: paleolimbot

r/R/as-array.R

@@ -488,9 +488,9 @@ storage_decimal_for_decimal <- function(numbers, scale) {
   if (scale > 0) {
     rounded_formatted <- sprintf("%0.*f", scale, numbers)
     rounded_formatted[is.na(numbers)] <- NA_character_
+    rounded_formatted
   } else {
     rounded_formatted <- as.character(round(numbers, scale))
+    gsub(paste0("0{", -scale, "}$"), "", rounded_formatted)
   }
-
-  rounded_formatted
 }

r/R/convert-array.R

@@ -161,15 +161,16 @@ convert_array.double <- function(array, to, ...) {
   schema <- infer_nanoarrow_schema(array)
   parsed <- nanoarrow_schema_parse(schema)
   if (parsed$type == "decimal128") {
-    assert_arrow_installed(
-      sprintf(
-        "convert %s array to object of type double",
-        nanoarrow_schema_formatted(schema)
-      )
-    )
-
-    arrow_array <- as_arrow_array.nanoarrow_array(array)
-    arrow_array$as_vector()
+    # assert_arrow_installed(
+    #   sprintf(
+    #     "convert %s array to object of type double",
+    #     nanoarrow_schema_formatted(schema)
+    #   )
+    # )
+    #
+    # arrow_array <- as_arrow_array.nanoarrow_array(array)
+    # arrow_array$as_vector()
+    NextMethod()
   } else {
     NextMethod()
   }

r/src/convert_array.c

@@ -23,7 +23,6 @@
 
 #include "altrep.h"
 #include "array.h"
-#include "array_view.h"
 #include "convert.h"
 #include "util.h"
 

r/src/materialize_dbl.h

@@ -21,12 +21,16 @@
 #include <R.h>
 #include <Rinternals.h>
 
+#include "buffer.h"
 #include "materialize_common.h"
 #include "nanoarrow.h"
 
 // bit64::as.integer64(2^53)
 #define MAX_DBL_AS_INTEGER 9007199254740992
 
+static inline int nanoarrow_decimal_to_chr(struct ArrowDecimal* item,
+                                           struct ArrowBuffer* buffer, int scale);
+
 static inline int nanoarrow_materialize_dbl(struct RConverter* converter) {
   if (converter->src.array_view->array->dictionary != NULL) {
     return ENOTSUP;
@@ -109,6 +113,43 @@ static inline int nanoarrow_materialize_dbl(struct RConverter* converter) {
       }
       break;
 
+    case NANOARROW_TYPE_DECIMAL32:
+    case NANOARROW_TYPE_DECIMAL64:
+    case NANOARROW_TYPE_DECIMAL128:
+    case NANOARROW_TYPE_DECIMAL256: {
+      struct ArrowDecimal item;
+      ArrowDecimalInit(&item, converter->schema_view.decimal_bitwidth,
+                       converter->schema_view.decimal_precision,
+                       converter->schema_view.decimal_scale);
+
+      // Buffer to manage the building of the digits output
+      SEXP buffer_xptr = PROTECT(buffer_owning_xptr());
+      struct ArrowBuffer* digits = (struct ArrowBuffer*)R_ExternalPtrAddr(buffer_xptr);
+
+      // A length one character() we'll use as input to Rf_asReal()
+      SEXP decimal_as_chr = PROTECT(Rf_allocVector(STRSXP, 1));
+
+      for (R_xlen_t i = 0; i < dst->length; i++) {
+        if (is_valid != NULL && !ArrowBitGet(is_valid, raw_src_offset + i)) {
+          result[dst->offset + i] = NA_REAL;
+          continue;
+        }
+
+        ArrowArrayViewGetDecimalUnsafe(src->array_view, src->offset + i, &item);
+        int status = nanoarrow_decimal_to_chr(&item, digits, item.scale);
+        if (status != NANOARROW_OK) {
+          UNPROTECT(2);
+          return status;
+        }
+
+        SET_STRING_ELT(decimal_as_chr, i,
+                       Rf_mkCharLen((char*)digits->data, (int)digits->size_bytes));
+        result[dst->offset + i] = Rf_asReal(decimal_as_chr);
+      }
+      UNPROTECT(2);
+      return NANOARROW_OK;
+    }
+
     default:
       return EINVAL;
   }
@@ -121,4 +162,47 @@ static inline int nanoarrow_materialize_dbl(struct RConverter* converter) {
   return NANOARROW_OK;
 }
 
+static inline int nanoarrow_decimal_to_chr(struct ArrowDecimal* item,
+                                           struct ArrowBuffer* buffer, int scale) {
+  buffer->size_bytes = 0;
+  NANOARROW_RETURN_NOT_OK(ArrowDecimalAppendDigitsToBuffer(item, buffer));
+
+  if (scale <= 0) {
+    // e.g., digits are -12345 and scale is -2 -> -1234500
+    // Just add zeros to the end
+    for (int i = scale; i <= 0; i++) {
+      NANOARROW_RETURN_NOT_OK(ArrowBufferAppendInt8(buffer, '0'));
+    }
+    return NANOARROW_OK;
+  }
+
+  int is_negative = buffer->data[0] == '-';
+  int64_t num_digits = buffer->size_bytes - is_negative;
+  if (num_digits <= scale) {
+    // e.g., digits are -12345 and scale is 6 -> -0.012345
+    // Insert "0.<some zeros>" between the (maybe) negative sign and the digits
+    int num_zeros_after_decimal = scale - num_digits;
+    NANOARROW_RETURN_NOT_OK(
+        ArrowBufferResize(buffer, buffer->size_bytes + num_zeros_after_decimal + 2, 0));
+
+    uint8_t* digits_start = buffer->data + is_negative;
+    memmove(digits_start + num_zeros_after_decimal + 2, digits_start, num_digits);
+    *digits_start++ = '0';
+    *digits_start++ = '.';
+    for (int i = 0; i < num_zeros_after_decimal; i++) {
+      *digits_start++ = '0';
+    }
+
+  } else {
+    // e.g., digits are -12345 and scale is 4 -> -1.2345
+    // Insert a decimal point before scale digits of output
+    NANOARROW_RETURN_NOT_OK(ArrowBufferResize(buffer, buffer->size_bytes + 1, 0));
+    uint8_t* decimal_point_to_be = buffer->data + buffer->size_bytes - 1 - scale;
+    memmove(decimal_point_to_be + 1, decimal_point_to_be, scale);
+    *decimal_point_to_be = '.';
+  }
+
+  return NANOARROW_OK;
+}
+
 #endif