s/AppendToCurrent/ExtendCurrent/

cpp/src/arrow/array/array_binary_test.cc

@@ -473,7 +473,7 @@ class TestStringBuilder : public TestBuilder {
     CheckStringArray(*result_, strings, is_valid, reps);
   }
 
-  void TestAppendToCurrent() {
+  void TestExtendCurrent() {
     std::vector<std::string> strings = {"", "bbbb", "aaaaa", "", "ccc"};
     std::vector<uint8_t> is_valid = {1, 1, 1, 0, 1};
 
@@ -486,7 +486,7 @@ class TestStringBuilder : public TestBuilder {
           ASSERT_OK(builder_->AppendNull());
         } else if (strings[i].length() > 3) {
           ASSERT_OK(builder_->Append(strings[i].substr(0, 3)));
-          ASSERT_OK(builder_->AppendToCurrent(strings[i].substr(3)));
+          ASSERT_OK(builder_->ExtendCurrent(strings[i].substr(3)));
         } else {
           ASSERT_OK(builder_->Append(strings[i]));
         }
@@ -501,7 +501,7 @@ class TestStringBuilder : public TestBuilder {
     CheckStringArray(*result_, strings, is_valid, reps);
   }
 
-  void TestAppendToCurrentUnsafe() {
+  void TestExtendCurrentUnsafe() {
     std::vector<std::string> strings = {"", "bbbb", "aaaaa", "", "ccc"};
     std::vector<uint8_t> is_valid = {1, 1, 1, 0, 1};
 
@@ -521,7 +521,7 @@ class TestStringBuilder : public TestBuilder {
           builder_->UnsafeAppendNull();
         } else if (strings[i].length() > 3) {
           builder_->UnsafeAppend(strings[i].substr(0, 3));
-          builder_->UnsafeAppendToCurrent(strings[i].substr(3));
+          builder_->UnsafeExtendCurrent(strings[i].substr(3));
         } else {
           builder_->UnsafeAppend(strings[i]);
         }
@@ -672,10 +672,10 @@ TYPED_TEST(TestStringBuilder, TestScalarAppend) { this->TestScalarAppend(); }
 
 TYPED_TEST(TestStringBuilder, TestScalarAppendUnsafe) { this->TestScalarAppendUnsafe(); }
 
-TYPED_TEST(TestStringBuilder, TestAppendToCurrent) { this->TestAppendToCurrent(); }
+TYPED_TEST(TestStringBuilder, TestExtendCurrent) { this->TestExtendCurrent(); }
 
-TYPED_TEST(TestStringBuilder, TestAppendToCurrentUnsafe) {
-  this->TestAppendToCurrentUnsafe();
+TYPED_TEST(TestStringBuilder, TestExtendCurrentUnsafe) {
+  this->TestExtendCurrentUnsafe();
 }
 
 TYPED_TEST(TestStringBuilder, TestVectorAppend) { this->TestVectorAppend(); }

cpp/src/arrow/array/builder_binary.h

@@ -77,10 +77,10 @@ class BaseBinaryBuilder : public ArrayBuilder {
     return Append(value.data(), static_cast<offset_type>(value.size()));
   }
 
-  /// Append to the last appended value
+  /// Extend the last appended value by appending more data at the end
   ///
   /// Unlike Append, this does not create a new offset.
-  Status AppendToCurrent(const uint8_t* value, offset_type length) {
+  Status ExtendCurrent(const uint8_t* value, offset_type length) {
     // Safety check for UBSAN.
     if (ARROW_PREDICT_TRUE(length > 0)) {
       ARROW_RETURN_NOT_OK(ValidateOverflow(length));
@@ -89,9 +89,9 @@ class BaseBinaryBuilder : public ArrayBuilder {
     return Status::OK();
   }
 
-  Status AppendToCurrent(util::string_view value) {
-    return AppendToCurrent(reinterpret_cast<const uint8_t*>(value.data()),
-                           static_cast<offset_type>(value.size()));
+  Status ExtendCurrent(util::string_view value) {
+    return ExtendCurrent(reinterpret_cast<const uint8_t*>(value.data()),
+                         static_cast<offset_type>(value.size()));
   }
 
   Status AppendNulls(int64_t length) final {
@@ -150,14 +150,14 @@ class BaseBinaryBuilder : public ArrayBuilder {
     UnsafeAppend(value.data(), static_cast<offset_type>(value.size()));
   }
 
-  /// Like AppendToCurrent, but do not check capacity
-  void UnsafeAppendToCurrent(const uint8_t* value, offset_type length) {
+  /// Like ExtendCurrent, but do not check capacity
+  void UnsafeExtendCurrent(const uint8_t* value, offset_type length) {
     value_data_builder_.UnsafeAppend(value, length);
   }
 
-  void UnsafeAppendToCurrent(util::string_view value) {
-    UnsafeAppendToCurrent(reinterpret_cast<const uint8_t*>(value.data()),
-                          static_cast<offset_type>(value.size()));
+  void UnsafeExtendCurrent(util::string_view value) {
+    UnsafeExtendCurrent(reinterpret_cast<const uint8_t*>(value.data()),
+                        static_cast<offset_type>(value.size()));
   }
 
   void UnsafeAppendNull() {

cpp/src/arrow/compute/kernels/scalar_string.cc

@@ -2655,8 +2655,8 @@ struct BinaryJoin {
       }
       builder->UnsafeAppend(strings.GetView(j_start));
       for (int64_t j = j_start + 1; j < j_end; ++j) {
-        builder->UnsafeAppendToCurrent(separators.GetView(i));
-        builder->UnsafeAppendToCurrent(strings.GetView(j));
+        builder->UnsafeExtendCurrent(separators.GetView(i));
+        builder->UnsafeExtendCurrent(strings.GetView(j));
       }
     }
 

cpp/src/arrow/compute/kernels/test_util.cc

@@ -35,8 +35,6 @@ namespace compute {
 
 namespace {
 
-using DatumVector = std::vector<Datum>;
-
 template <typename T>
 DatumVector GetDatums(const std::vector<T>& inputs) {
   std::vector<Datum> datums;

cpp/src/arrow/compute/kernels/test_util.h

@@ -43,6 +43,8 @@ using internal::checked_cast;
 
 namespace compute {
 
+using DatumVector = std::vector<Datum>;
+
 template <typename Type, typename T>
 std::shared_ptr<Array> _MakeArray(const std::shared_ptr<DataType>& type,
                                   const std::vector<T>& values,
@@ -93,7 +95,7 @@ void CheckScalar(std::string func_name, const ScalarVector& inputs,
                  std::shared_ptr<Scalar> expected,
                  const FunctionOptions* options = nullptr);
 
-void CheckScalar(std::string func_name, const ArrayVector& inputs,
+void CheckScalar(std::string func_name, const DatumVector& inputs,
                  std::shared_ptr<Array> expected,
                  const FunctionOptions* options = nullptr);