working for integers

Author: paleolimbot

r/src/init.c

@@ -92,6 +92,7 @@ extern SEXP nanoarrow_c_schema_set_dictionary(SEXP schema_mut_xptr, SEXP diction
 extern SEXP nanoarrow_c_preserved_count(void);
 extern SEXP nanoarrow_c_preserved_empty(void);
 extern SEXP nanoarrow_c_preserve_and_release_on_other_thread(SEXP obj);
+extern SEXP nanoarrow_c_convert_array2(SEXP array_xptr, SEXP ptype_sexp);
 extern SEXP nanoarrow_c_version(void);
 extern SEXP nanoarrow_c_version_runtime(void);
 
@@ -166,6 +167,7 @@ static const R_CallMethodDef CallEntries[] = {
     {"nanoarrow_c_preserved_empty", (DL_FUNC)&nanoarrow_c_preserved_empty, 0},
     {"nanoarrow_c_preserve_and_release_on_other_thread",
      (DL_FUNC)&nanoarrow_c_preserve_and_release_on_other_thread, 1},
+    {"nanoarrow_c_convert_array2", (DL_FUNC)&nanoarrow_c_convert_array2, 2},
     {"nanoarrow_c_version", (DL_FUNC)&nanoarrow_c_version, 0},
     {"nanoarrow_c_version_runtime", (DL_FUNC)&nanoarrow_c_version_runtime, 0},
     {NULL, NULL, 0}};

r/src/vctr_builder.cc

@@ -22,15 +22,16 @@
 #include <memory>
 #include <vector>
 
+#include "array.h"
 #include "materialize.h"
 #include "nanoarrow.h"
 #include "nanoarrow/r.h"
 
 #include "vctr_builder.h"
 #include "vctr_builder_base.h"
+#include "vctr_builder_list_of.h"
 #include "vctr_builder_primitive.h"
 #include "vctr_builder_rcrd.h"
-#include "vctr_builder_list_of.h"
 
 // These conversions are the default R-native type guesses for
 // an array that don't require extra information from the ptype (e.g.,
@@ -276,3 +277,31 @@ SEXP nanoarrow_c_infer_ptype(SEXP schema_xptr) {
   UNPROTECT(2);
   return ptype_sexp;
 }
+
+SEXP nanoarrow_c_convert_array2(SEXP array_xptr, SEXP ptype_sexp) {
+  ArrowArray* array = nanoarrow_array_from_xptr(array_xptr);
+  SEXP schema_xptr = PROTECT(array_xptr_get_schema(array_xptr));
+  SEXP builder_xptr = PROTECT(nanoarrow_vctr_builder_init(schema_xptr, ptype_sexp));
+  auto builder = reinterpret_cast<VctrBuilder*>(R_ExternalPtrAddr(builder_xptr));
+
+  ArrowError error;
+  ArrowErrorInit(&error);
+
+  int result = builder->Reserve(array->length, &error);
+  if (result != NANOARROW_OK) {
+    Rf_error("builder->Reserve() failed: %s", error.message);
+  }
+
+  result = builder->PushNext(array, &error);
+  if (result != NANOARROW_OK) {
+    Rf_error("builder->PushNext() failed: %s", error.message);
+  }
+
+  result = builder->Finish(&error);
+  if (result != NANOARROW_OK) {
+    Rf_error("builder->Finish() failed: %s", error.message);
+  }
+
+  UNPROTECT(2);
+  return builder->GetValue();
+}

r/src/vctr_builder.h

@@ -54,6 +54,8 @@ SEXP nanoarrow_vctr_builder_init(SEXP schema_xptr, SEXP ptype_sexp);
 
 SEXP nanoarrow_c_infer_ptype(SEXP schema_xptr);
 
+SEXP nanoarrow_c_convert_array2(SEXP array_xptr, SEXP ptype_sexp);
+
 #ifdef __cplusplus
 }
 #endif

r/src/vctr_builder_base.h

@@ -77,7 +77,8 @@ struct VctrBuilder {
   // called when the caller cannot safely relinquish ownership of an array (e.g.,
   // convert_array()). Calling this method may longjmp.
   virtual ArrowErrorCode PushNext(const ArrowArray* array, ArrowError* error) {
-    return ENOTSUP;
+    NANOARROW_RETURN_NOT_OK(ArrowArrayViewSetArray(&array_view_, array, error));
+    return NANOARROW_OK;
   }
 
   // Push an array into this builder. The implementation may (but is not required) to take
@@ -99,9 +100,11 @@ struct VctrBuilder {
 
   // Release the final value of the builder. Calling this method may longjmp.
   virtual SEXP GetValue() {
+    SEXP value = PROTECT(value_);
     nanoarrow_release_sexp(value_);
     value_ = R_NilValue;
-    return value_;
+    UNPROTECT(1);
+    return value;
   }
 
   // Get (or allocate if required) the SEXP ptype for this output

r/src/vctr_builder_primitive.h

@@ -44,8 +44,8 @@ class UnspecifiedBuilder : public VctrBuilder {
 
   ArrowErrorCode Reserve(R_xlen_t n, ArrowError* error) override {
     NANOARROW_RETURN_NOT_OK(VctrBuilder::Reserve(n, error));
-    value_ = PROTECT(Rf_allocVector(LGLSXP, n));
-    SetValue(value_);
+    SEXP value = PROTECT(Rf_allocVector(LGLSXP, n));
+    SetValue(value);
     UNPROTECT(1);
     return NANOARROW_OK;
   }
@@ -88,19 +88,21 @@ class IntBuilder : public VctrBuilder {
 
   ArrowErrorCode Reserve(R_xlen_t n, ArrowError* error) override {
     NANOARROW_RETURN_NOT_OK(VctrBuilder::Reserve(n, error));
-    value_ = PROTECT(Rf_allocVector(INTSXP, n));
-    SetValue(value_);
+    SEXP value = PROTECT(Rf_allocVector(INTSXP, n));
+    SetValue(value);
     UNPROTECT(1);
     return NANOARROW_OK;
   }
 
   ArrowErrorCode PushNext(const ArrowArray* array, ArrowError* error) override {
+    NANOARROW_RETURN_NOT_OK(VctrBuilder::PushNext(array, error));
+
     int* result = INTEGER(value_);
     int64_t n_bad_values = 0;
 
     // True for all the types supported here
     const uint8_t* is_valid = array_view_.buffer_views[0].data.as_uint8;
-    int64_t raw_src_offset = array_view_.array->offset;
+    int64_t raw_src_offset = array_view_.offset;
     R_xlen_t length = array->length;
 
     // Fill the buffer
@@ -116,7 +118,7 @@ class IntBuilder : public VctrBuilder {
                length * sizeof(int32_t));
 
         // Set any nulls to NA_INTEGER
-        if (is_valid != NULL && array_view_.array->null_count != 0) {
+        if (is_valid != NULL && array_view_.null_count != 0) {
           for (R_xlen_t i = 0; i < length; i++) {
             if (!ArrowBitGet(is_valid, raw_src_offset + i)) {
               result[value_size_ + i] = NA_INTEGER;
@@ -129,7 +131,7 @@ class IntBuilder : public VctrBuilder {
                              raw_src_offset, length, result + value_size_);
 
         // Set any nulls to NA_LOGICAL
-        if (is_valid != NULL && array_view_.array->null_count != 0) {
+        if (is_valid != NULL && array_view_.null_count != 0) {
           for (R_xlen_t i = 0; i < length; i++) {
             if (!ArrowBitGet(is_valid, raw_src_offset + i)) {
               result[value_size_ + i] = NA_LOGICAL;
@@ -147,7 +149,7 @@ class IntBuilder : public VctrBuilder {
         }
 
         // Set any nulls to NA_INTEGER
-        if (is_valid != NULL && array_view_.array->null_count != 0) {
+        if (is_valid != NULL && array_view_.null_count != 0) {
           for (R_xlen_t i = 0; i < length; i++) {
             if (!ArrowBitGet(is_valid, raw_src_offset + i)) {
               result[value_size_ + i] = NA_INTEGER;
@@ -162,7 +164,7 @@ class IntBuilder : public VctrBuilder {
       case NANOARROW_TYPE_DOUBLE:
         // Loop + bounds check. Because we don't know what memory might be
         // in a null slot, we have to check nulls if there are any.
-        if (is_valid != NULL && array_view_.array->null_count != 0) {
+        if (is_valid != NULL && array_view_.null_count != 0) {
           for (R_xlen_t i = 0; i < length; i++) {
             if (ArrowBitGet(is_valid, raw_src_offset + i)) {
               int64_t value = ArrowArrayViewGetIntUnsafe(&array_view_, i);