server(JSON): Remove parse method which used default heap

There were two parse methods, one which used the default heap and the
other which used a thread local mi heap.

The former one is removed here. The reason is to prepare for using a
stateless allocator.

The allocator is part of the type of the json object. A stateless
allocator must not hold state of its own and simply forward requests to
a memory resource pointer accessed from a static storage.

In such a model, having two memory resources does not work because two
allocators using different heaps are not interchangeable.

It is possible to use two different types, but in that case the json
object types become different, and it becomes impossible to work with
them transparently.

The switch to mi heap everywhere can cause one problem during
accounting. The JSONAutoUpdater class uses memory usage before and after
parsing to figure out how many bytes are used by a given object. If the
objects parsed by the method which is removed in this PR are
interspersed with JSONAutoUpdater, then this can cause a problem with
accounting.

At present there are no such cases in the code.

Signed-off-by: Abhijat Malviya <[email protected]>

Author: abhijat

src/server/json_family.cc

@@ -470,17 +470,12 @@ std::optional<std::string> ConvertJsonPathToJsonPointer(string_view json_path) {
   return pointer;
 }
 
-// Use this method on the coordinator thread
-std::optional<JsonType> JsonFromString(std::string_view input) {
-  return dfly::JsonFromString(input, PMR_NS::get_default_resource());
-}
-
-/* Use this method on the shard thread
+/*
 
    If you do memory tracking, make sure to initialize it before calling this method, and reset the
    result before invoking SetJsonSize. Note that even after calling std::move on an optional, it may
    still hold the JSON value, which can lead to incorrect memory tracking. */
-std::optional<JsonType> ShardJsonFromString(std::string_view input) {
+std::optional<JsonType> ParseJSONFromString(std::string_view input) {
   return dfly::JsonFromString(input, CompactObj::memory_resource());
 }
 
@@ -501,7 +496,7 @@ OpStatus SetFullJson(const OpArgs& op_args, string_view key, string_view json_st
   JsonAutoUpdater updater(op_args, key, *std::move(it_res),
                           {.disable_indexing = true, .update_on_delete = false});
 
-  std::optional<JsonType> parsed_json = ShardJsonFromString(json_str);
+  std::optional<JsonType> parsed_json = ParseJSONFromString(json_str);
   if (!parsed_json) {
     VLOG(1) << "got invalid JSON string '" << json_str << "' cannot be saved";
     if (type == OBJ_JSON) {
@@ -548,7 +543,7 @@ OpResult<bool> SetPartialJson(const OpArgs& op_args, string_view key,
      The reason being, that we are applying this multiple times for each match we found.
      So for example if we have an array that this expression will match each entry in it then the
      assign here is called N times. */
-  std::optional<JsonType> parsed_json = ShardJsonFromString(json_str);
+  std::optional<JsonType> parsed_json = ParseJSONFromString(json_str);
   if (!parsed_json) {
     VLOG(1) << "got invalid JSON string '" << json_str << "' cannot be saved";
     return OpStatus::INVALID_JSON;
@@ -845,7 +840,7 @@ OpResult<std::string> OpJsonGet(const OpArgs& op_args, string_view key,
   } else if (it->second.ObjType() == OBJ_STRING) {
     string tmp;
     it->second.GetString(&tmp);
-    auto parsed_json = ShardJsonFromString(tmp);
+    auto parsed_json = ParseJSONFromString(tmp);
     if (!parsed_json) {
       return OpStatus::WRONG_TYPE;
     }
@@ -1586,7 +1581,7 @@ OpStatus OpMSet(const OpArgs& op_args, const ShardArgs& args) {
 // implemented yet.
 OpStatus OpMerge(const OpArgs& op_args, string_view key, string_view path,
                  const WrappedJsonPath& json_path, std::string_view json_str) {
-  std::optional<JsonType> parsed_json = ShardJsonFromString(json_str);
+  std::optional<JsonType> parsed_json = ParseJSONFromString(json_str);
   if (!parsed_json) {
     VLOG(1) << "got invalid JSON string '" << json_str << "' cannot be saved";
     return OpStatus::INVALID_JSON;
@@ -1826,7 +1821,7 @@ void JsonFamily::ArrIndex(CmdArgList args, const CommandContext& cmd_cntx) {
   auto* builder = static_cast<RedisReplyBuilder*>(cmd_cntx.rb);
   WrappedJsonPath json_path = GET_OR_SEND_UNEXPECTED(ParseJsonPath(path));
 
-  optional<JsonType> search_value = JsonFromString(parser.Next());
+  optional<JsonType> search_value = ParseJSONFromString(parser.Next());
   if (!search_value) {
     builder->SendError(kSyntaxErr);
     return;
@@ -1875,7 +1870,7 @@ void JsonFamily::ArrInsert(CmdArgList args, const CommandContext& cmd_cntx) {
 
   vector<JsonType> new_values;
   for (size_t i = 3; i < args.size(); i++) {
-    optional<JsonType> val = JsonFromString(ArgS(args, i));
+    optional<JsonType> val = ParseJSONFromString(ArgS(args, i));
     if (!val) {
       builder->SendError(kSyntaxErr);
       return;
@@ -1905,7 +1900,7 @@ void JsonFamily::ArrAppend(CmdArgList args, const CommandContext& cmd_cntx) {
   // TODO: there is a bug here, because we parse json using the allocator from
   // the coordinator thread, and we pass it to the shard thread, which is not safe.
   for (size_t i = 2; i < args.size(); ++i) {
-    optional<JsonType> converted_val = JsonFromString(ArgS(args, i));
+    optional<JsonType> converted_val = ParseJSONFromString(ArgS(args, i));
     if (!converted_val) {
       builder->SendError(kSyntaxErr);
       return;
@@ -2000,7 +1995,7 @@ void JsonFamily::StrAppend(CmdArgList args, const CommandContext& cmd_cntx) {
   WrappedJsonPath json_path = GET_OR_SEND_UNEXPECTED(ParseJsonPath(path));
 
   // We try parsing the value into json string object first.
-  optional<JsonType> parsed_json = JsonFromString(value);
+  optional<JsonType> parsed_json = ParseJSONFromString(value);
   if (!parsed_json || !parsed_json->is_string()) {
     return builder->SendError("expected string value", kSyntaxErrType);
   };