work

Author: rok

cpp/src/arrow/integration/json_integration.cc

@@ -17,6 +17,8 @@
 
 #include "arrow/integration/json_integration.h"
 
+#include <simdjson.h>
+
 #include <cstddef>
 #include <cstdint>
 #include <memory>

cpp/src/arrow/integration/json_internal.cc

@@ -17,6 +17,8 @@
 
 #include "arrow/integration/json_internal.h"
 
+#include <simdjson.h>
+
 #include <cstdint>
 #include <cstdlib>
 #include <iomanip>

cpp/src/arrow/integration/json_internal.h

@@ -22,6 +22,8 @@
 #include <string>
 #include <string_view>
 
+#include <simdjson.h>
+
 #include "arrow/ipc/type_fwd.h"
 #include "arrow/json/json_util.h"
 #include "arrow/result.h"

cpp/src/arrow/json/json_util.h

@@ -17,14 +17,13 @@
 
 #pragma once
 
+#include <charconv>
 #include <cstdint>
 #include <cstdio>
 #include <sstream>
 #include <string>
 #include <string_view>
 
-#include <simdjson.h>
-
 #include "arrow/util/visibility.h"
 
 namespace arrow {
@@ -78,115 +77,111 @@ inline std::string EscapeJsonString(std::string_view s) {
   return ss.str();
 }
 
-/// \brief JSON writer wrapper using simdjson
-///
-/// This class wraps simdjson's mini_formatter to provide a convenient API
-/// with automatic comma insertion between elements.
+/// \brief JSON writer with automatic comma insertion between elements.
 class JsonWriter {
  public:
   JsonWriter() = default;
 
   void StartObject() {
     MaybeComma();
-    formatter_.start_object();
+    buffer_ += '{';
     needs_comma_ = false;
   }
 
   void EndObject() {
-    formatter_.end_object();
+    buffer_ += '}';
     needs_comma_ = true;
   }
 
   void StartArray() {
     MaybeComma();
-    formatter_.start_array();
+    buffer_ += '[';
     needs_comma_ = false;
   }
 
   void EndArray() {
-    formatter_.end_array();
+    buffer_ += ']';
     needs_comma_ = true;
   }
 
   void Key(std::string_view key) {
     MaybeComma();
-    formatter_.key(key);
+    buffer_ += EscapeJsonString(key);
+    buffer_ += ':';
     needs_comma_ = false;
   }
 
   void String(std::string_view value) {
     MaybeComma();
-    formatter_.string(value);
+    buffer_ += EscapeJsonString(value);
     needs_comma_ = true;
   }
 
   void Bool(bool value) {
     MaybeComma();
-    if (value) {
-      formatter_.true_atom();
-    } else {
-      formatter_.false_atom();
-    }
+    buffer_ += value ? "true" : "false";
     needs_comma_ = true;
   }
 
   void Int(int32_t value) {
     MaybeComma();
-    formatter_.number(static_cast<int64_t>(value));
+    buffer_ += std::to_string(value);
     needs_comma_ = true;
   }
 
   void Int64(int64_t value) {
     MaybeComma();
-    formatter_.number(value);
+    buffer_ += std::to_string(value);
     needs_comma_ = true;
   }
 
   void Uint(uint32_t value) {
     MaybeComma();
-    formatter_.number(static_cast<uint64_t>(value));
+    buffer_ += std::to_string(value);
     needs_comma_ = true;
   }
 
   void Uint64(uint64_t value) {
     MaybeComma();
-    formatter_.number(value);
+    buffer_ += std::to_string(value);
     needs_comma_ = true;
   }
 
   void Double(double value) {
     MaybeComma();
-    formatter_.number(value);
+    char buf[32];
+    auto result = std::to_chars(buf, buf + sizeof(buf), value);
+    buffer_.append(buf, result.ptr - buf);
     needs_comma_ = true;
   }
 
   void Null() {
     MaybeComma();
-    formatter_.null_atom();
+    buffer_ += "null";
     needs_comma_ = true;
   }
 
   /// Write a raw character (for unquoted values like decimal numbers)
-  void RawChar(char c) { formatter_.one_char(c); }
+  void RawChar(char c) { buffer_ += c; }
 
   /// Mark that a raw value was written (for comma tracking)
   void MarkValueWritten() { needs_comma_ = true; }
 
-  std::string_view GetString() const { return formatter_.str(); }
+  std::string_view GetString() const { return buffer_; }
 
   void Clear() {
-    formatter_.clear();
+    buffer_.clear();
     needs_comma_ = false;
   }
 
  private:
   void MaybeComma() {
     if (needs_comma_) {
-      formatter_.comma();
+      buffer_ += ',';
     }
   }
 
-  simdjson::internal::mini_formatter formatter_;
+  std::string buffer_;
   bool needs_comma_ = false;
 };