GH-51013: [C++] Replace RapidJSON in JSON test utilities

cpp/src/arrow/CMakeLists.txt

@@ -732,8 +732,8 @@ else()
 endif()
 
 set(ARROW_TESTING_SHARED_LINK_LIBS arrow_shared ${ARROW_GTEST_GTEST})
-set(ARROW_TESTING_SHARED_PRIVATE_LINK_LIBS arrow::flatbuffers RapidJSON)
-set(ARROW_TESTING_STATIC_LINK_LIBS arrow::flatbuffers RapidJSON arrow_static
+set(ARROW_TESTING_SHARED_PRIVATE_LINK_LIBS arrow::flatbuffers arrow::simdjson)
+set(ARROW_TESTING_STATIC_LINK_LIBS arrow::flatbuffers arrow::simdjson arrow_static
  ${ARROW_GTEST_GTEST})
 if(ARROW_ENABLE_THREADING)
  list(APPEND ARROW_TESTING_SHARED_PRIVATE_LINK_LIBS arrow::Boost::process)

cpp/src/arrow/json/CMakeLists.txt

@@ -35,7 +35,9 @@ add_arrow_benchmark(parser_benchmark
  PREFIX
  "arrow-json"
  EXTRA_LINK_LIBS
- RapidJSON)
+ RapidJSON
+ simdjson::simdjson)
+
 arrow_install_all_headers("arrow/json")
 
 # pkg-config support

cpp/src/arrow/json/parser_benchmark.cc

@@ -38,10 +38,14 @@ std::string GenerateTestData(const Input& input, int num_rows,
  std::default_random_engine engine(kSeed);
  std::string json;
  for (int i = 0; i < num_rows; ++i) {
- StringBuffer sb;
- Writer writer(sb);
+ Writer writer;
  ABORT_NOT_OK(Generate(input, engine, &writer, options));
- json += pretty ? PrettyPrint(sb.GetString()) : sb.GetString();
+
+ auto json_result = writer.GetString();
+ ABORT_NOT_OK(json_result.status());
+ auto json_view = std::move(json_result).ValueOrDie();
+
+ json += pretty ? PrettyPrint(json_view) : json_view;
  json += "\n";
  }
  return json;

cpp/src/arrow/json/parser_test.cc

@@ -321,5 +321,17 @@ TEST(BlockParser, AdHoc) {
  R"([{"c":true, "d": "1991-02-03"}, {"c":false, "d":"2019-04-01"}])"});
 }
 
+TEST(JsonTest, PrettyPrintEscapesObjectKeys) {
+ const std::string input = R"({"a\"b":1,"a\\b":2})";
+
+ const std::string expected =
+ "{\n"
+ " \"a\\\"b\": 1,\n"
+ " \"a\\\\b\": 2\n"
+ "}";
+
+ EXPECT_EQ(PrettyPrint(input), expected);
+}
+
 } // namespace json
 } // namespace arrow

cpp/src/arrow/json/reader_test.cc

@@ -24,6 +24,7 @@
 
 #include "arrow/io/interfaces.h"
 #include "arrow/io/slow.h"
+#include "arrow/json/json_writer_internal.h"
 #include "arrow/json/options.h"
 #include "arrow/json/reader.h"
 #include "arrow/json/test_common.h"
@@ -550,10 +551,14 @@ class StreamingReaderTestBase {
  auto options = GenerateOptions::Defaults();
  options.null_probability = 0;
  for (int i = 0; i < num_rows; ++i) {
- StringBuffer string_buffer;
- Writer writer(string_buffer);
+ Writer writer;
  ABORT_NOT_OK(Generate(data_fields, engine, &writer, options));
- std::string json = string_buffer.GetString();
+
+ auto json_result = writer.GetString();
+ ABORT_NOT_OK(json_result.status());
+ auto json_view = std::move(json_result).ValueOrDie();
+ std::string json(json_view);
+
  rows[i] = Join({"{\"i\":", std::to_string(i), ",\"d\":", json, "}\n"});
  max_row_size = std::max(max_row_size, rows[i].size());
  }

cpp/src/arrow/json/test_common.h

@@ -25,35 +25,31 @@
 #include <utility>
 #include <vector>
 
+#include <simdjson.h>
+
 #include "arrow/array.h"
 #include "arrow/array/builder_binary.h"
 #include "arrow/io/memory.h"
 #include "arrow/json/converter.h"
+#include "arrow/json/json_writer_internal.h"
 #include "arrow/json/options.h"
 #include "arrow/json/parser.h"
-#include "arrow/json/rapidjson_defs.h"
+#include "arrow/result.h"
 #include "arrow/testing/gtest_util.h"
 #include "arrow/testing/random.h"
 #include "arrow/type.h"
 #include "arrow/util/checked_cast.h"
+#include "arrow/util/simdjson_internal.h"
 #include "arrow/visit_type_inline.h"
 
-#include "rapidjson/document.h"
-#include "rapidjson/prettywriter.h"
-#include "rapidjson/reader.h"
-#include "rapidjson/writer.h"
-
 namespace arrow {
 
 using internal::checked_cast;
 
 namespace json {
 
-namespace rj = arrow::rapidjson;
-
-using rj::StringBuffer;
 using std::string_view;
-using Writer = rj::Writer<StringBuffer>;
+using Writer = JsonWriter;
 
 struct GenerateOptions {
  // Probability of a field being written
@@ -87,35 +83,43 @@ inline static Status Generate(
 
 template <typename Engine>
 struct GenerateImpl {
- Status Visit(const NullType&) { return OK(writer.Null()); }
+ Status Visit(const NullType&) {
+ writer.Null();
+ return Status::OK();
+ }
 
  Status Visit(const BooleanType&) {
- return OK(writer.Bool(std::uniform_int_distribution<uint16_t>{}(e) & 1));
+ writer.Bool(std::uniform_int_distribution<uint16_t>{}(e) & 1);
+ return Status::OK();
  }
 
  template <typename T>
  enable_if_physical_unsigned_integer<T, Status> Visit(const T&) {
  auto val = std::uniform_int_distribution<>{}(e);
- return OK(writer.Uint64(static_cast<typename T::c_type>(val)));
+ writer.Uint64(static_cast<typename T::c_type>(val));
+ return Status::OK();
  }
 
  template <typename T>
  enable_if_physical_signed_integer<T, Status> Visit(const T&) {
  auto val = std::uniform_int_distribution<>{}(e);
- return OK(writer.Int64(static_cast<typename T::c_type>(val)));
+ writer.Int64(static_cast<typename T::c_type>(val));
+ return Status::OK();
  }
 
  template <typename T>
  enable_if_physical_floating_point<T, Status> Visit(const T&) {
  auto val = std::normal_distribution<typename T::c_type>{0, 1 << 10}(e);
- return OK(writer.Double(val));
+ writer.Double(val);
+ return Status::OK();
  }
 
  Status GenerateUtf8(const DataType&) {
  auto num_codepoints = std::poisson_distribution<>{4}(e);
  auto seed = std::uniform_int_distribution<uint32_t>{}(e);
  std::string s = RandomUtf8String(seed, num_codepoints);
- return OK(writer.String(s));
+ writer.String(s);
+ return Status::OK();
  }
 
  template <typename T>
@@ -132,7 +136,8 @@ struct GenerateImpl {
  for (int i = 0; i < size; ++i) {
  RETURN_NOT_OK(Generate(t.value_type(), e, &writer, options));
  }
- return OK(writer.EndArray(size));
+ writer.EndArray();
+ return Status::OK();
  }
 
  Status Visit(const ListViewType& t) { return NotImplemented(t); }
@@ -162,7 +167,7 @@ struct GenerateImpl {
  }
 
  Engine& e;
-rj::Writer<rj::StringBuffer>& writer;
+ Writer& writer;
  const GenerateOptions& options;
 };
 
@@ -180,12 +185,9 @@ inline static Status Generate(const std::shared_ptr<DataType>& type, Engine& e,
 template <typename Engine>
 inline static Status Generate(const std::vector<std::shared_ptr<Field>>& fields,
  Engine& e, Writer* writer, const GenerateOptions& options) {
- RETURN_NOT_OK(OK(writer->StartObject()));
-
- int num_fields = 0;
+ writer->StartObject();
  auto write_field = [&](const Field& f) {
- ++num_fields;
- writer->Key(f.name().c_str());
+ writer->Key(f.name());
  return Generate(f.type(), e, writer, options);
  };
 
@@ -210,7 +212,8 @@ inline static Status Generate(const std::vector<std::shared_ptr<Field>>& fields,
  }
  }
 
- return OK(writer->EndObject(num_fields));
+ writer->EndObject();
+ return Status::OK();
 }
 
 inline static Status MakeStream(string_view src_str,
@@ -258,14 +261,26 @@ inline static Status ParseFromString(ParseOptions options, string_view src_str,
 }
 
 static inline std::string PrettyPrint(string_view one_line) {
-rj::Document document;
+simdjson::ondemand::parser parser;
 
  // Must pass size to avoid ASAN issues.
- document.Parse(one_line.data(), one_line.size());
- rj::StringBuffer sb;
- rj::PrettyWriter<rj::StringBuffer> writer(sb);
- document.Accept(writer);
- return sb.GetString();
+ simdjson::padded_string json(one_line.data(), one_line.size());
+
+ auto document_result =
+ internal::ResolveSimdjsonResult(parser.iterate(json), "Failed to parse JSON");
+ ABORT_NOT_OK(document_result.status());
+ auto document = std::move(document_result).ValueOrDie();
+
+ auto value_result =
+ internal::ResolveSimdjsonResult(document.get_value(), "Failed to get JSON value");
+ ABORT_NOT_OK(value_result.status());
+ auto value = std::move(value_result).ValueOrDie();
+
+ std::string result;
+ result.reserve(one_line.size());
+
+ ABORT_NOT_OK(internal::PrettyPrintJsonValue(value, &result));
+ return result;
 }
 
 template <typename T>

cpp/src/arrow/meson.build

@@ -755,6 +755,7 @@ if needs_testing
  filesystem_dep,
  gmock_dep,
  gtest_dep,
+ simdjson_dep,
  ],
  )
 

cpp/src/arrow/testing/gtest_util.cc

@@ -53,7 +53,6 @@
 #include "arrow/ipc/reader.h"
 #include "arrow/ipc/writer.h"
 #include "arrow/json/from_string.h"
-#include "arrow/json/rapidjson_defs.h" // IWYU pragma: keep
 #include "arrow/pretty_print.h"
 #include "arrow/record_batch.h"
 #include "arrow/status.h"
@@ -65,13 +64,10 @@
 #include "arrow/util/future.h"
 #include "arrow/util/io_util.h"
 #include "arrow/util/logging_internal.h"
+#include "arrow/util/simdjson_internal.h"
 #include "arrow/util/thread_pool.h"
 #include "arrow/util/windows_compatibility.h"
 
-#include <rapidjson/document.h>
-
-namespace rj = arrow::rapidjson;
-
 namespace arrow {
 
 using internal::checked_cast;
@@ -445,24 +441,24 @@ std::shared_ptr<Tensor> TensorFromJSON(const std::shared_ptr<DataType>& type,
  std::string_view dim_names) {
  std::shared_ptr<Array> array = arrow::ArrayFromJSON(type, data);
 
-rj::Document json_shape;
- json_shape.Parse(shape.data(), shape.length());
-std::vector<int64_t> shape_vector;
-for (auto& x : json_shape.GetArray()) {
-shape_vector.emplace_back(x.GetInt64());
-}
- rj::Document json_strides;
- json_strides.Parse(strides.data(), strides.length());
-std::vector<int64_t> strides_vector;
-for (auto& x : json_strides.GetArray()) {
-strides_vector.emplace_back(x.GetInt64());
- }
-rj::Document json_dim_names;
-json_dim_names.Parse(dim_names.data(), dim_names.length());
-std::vector<std::string> dim_names_vector;
-for (auto& x : json_dim_names.GetArray()) {
-dim_names_vector.emplace_back(x.GetString());
- }
+simdjson::dom::parser parser;
+
+auto json_shape =
+ internal::ResolveSimdjsonResult(parser.parse(shape), "Failed to parse shape")
+ .ValueOrDie();
+auto shape_vector = internal::GetJsonIntArray(json_shape, "shape").ValueOrDie();
+
+auto json_strides =
+ internal::ResolveSimdjsonResult(parser.parse(strides), "Failed to parse strides")
+ .ValueOrDie();
+auto strides_vector = internal::GetJsonIntArray(json_strides, "strides").ValueOrDie();
+
+auto json_dim_names = internal::ResolveSimdjsonResult(parser.parse(dim_names),
+ "Failed to parse dimension names")
+ .ValueOrDie();
+ auto dim_names_vector =
+ internal::GetJsonStringArray(json_dim_names, "dimension names").ValueOrDie();
+
  return *Tensor::Make(type, array->data()->buffers[1], shape_vector, strides_vector,
  dim_names_vector);
 }

cpp/src/arrow/testing/gtest_util_test.cc

@@ -179,6 +179,23 @@ TEST_F(TestTensorFromJSON, FromJSON) {
  EXPECT_TRUE(tensor_expected->Equals(*result));
 }
 
+TEST_F(TestTensorFromJSON, FromJSONWithStridesAndDimNames) {
+ std::vector<int64_t> shape = {2, 3};
+ std::vector<int64_t> strides = {sizeof(int64_t) * 3, sizeof(int64_t)};
+ std::vector<std::string> dim_names = {"row", "column"};
+ std::vector<int64_t> values = {1, 2, 3, 4, 5, 6};
+ auto data = Buffer::Wrap(values);
+
+ std::shared_ptr<Tensor> tensor_expected;
+ ASSERT_OK_AND_ASSIGN(tensor_expected,
+ Tensor::Make(int64(), data, shape, strides, dim_names));
+
+ std::shared_ptr<Tensor> result = TensorFromJSON(int64(), "[1, 2, 3, 4, 5, 6]", "[2, 3]",
+ "[24, 8]", R"(["row", "column"])");
+
+ EXPECT_TRUE(tensor_expected->Equals(*result));
+}
+
 TEST(AssertTestWithinUlp, Basics) {
  AssertWithinUlp(123.4567, 123.45670000000015, 11);
  AssertWithinUlp(123.456f, 123.456085f, 11);