feat: add support of the command JSON.DEBUG MEMORY

src/commands/cmd_json.cc

@@ -624,6 +624,37 @@ class CommandJsonMSet : public Commander {
   }
 };
 
+class CommandJsonDebug : public Commander {
+ public:
+  Status Execute(Server *svr, Connection *conn, std::string *output) override {
+    redis::Json json(svr->storage, conn->GetNamespace());
+
+    std::string path = "$";
+
+    if (!util::EqualICase(args_[1], "memory")) {
+      return {Status::RedisExecErr, "ERR wrong number of arguments for 'json.debug' command"};
+    }
+
+    if (args_.size() == 4) {
+      path = args_[3];
+    } else if (args_.size() > 4) {
+      return {Status::RedisExecErr, "The number of arguments is more than expected"};
+    }
+
+    std::vector<std::string> results;
+    auto s = json.DebugMemory(args_[2], path, &results);
+
+    if (s.IsNotFound()) {
+      *output = conn->NilString();
+      return Status::OK();
+    }
+
+    if (!s.ok()) return {Status::RedisExecErr, s.ToString()};
+
+    *output = redis::ArrayOfBulkStrings(results);
+    return Status::OK();
+  }
+};
 REDIS_REGISTER_COMMANDS(MakeCmdAttr<CommandJsonSet>("json.set", 4, "write", 1, 1, 1),
                         MakeCmdAttr<CommandJsonGet>("json.get", -2, "read-only", 1, 1, 1),
                         MakeCmdAttr<CommandJsonInfo>("json.info", 2, "read-only", 1, 1, 1),
@@ -647,6 +678,7 @@ REDIS_REGISTER_COMMANDS(MakeCmdAttr<CommandJsonSet>("json.set", 4, "write", 1, 1
                         MakeCmdAttr<CommandJsonStrAppend>("json.strappend", -3, "write", 1, 1, 1),
                         MakeCmdAttr<CommandJsonStrLen>("json.strlen", -2, "read-only", 1, 1, 1),
                         MakeCmdAttr<CommandJsonMGet>("json.mget", -3, "read-only", 1, -2, 1),
-                        MakeCmdAttr<CommandJsonMSet>("json.mset", -4, "write", 1, -3, 3), );
+                        MakeCmdAttr<CommandJsonMSet>("json.mset", -4, "write", 1, -3, 3),
+                        MakeCmdAttr<CommandJsonDebug>("json.debug", -3, "read-only", 1, 2, 1));
 
 }  // namespace redis

src/types/json.h

@@ -217,6 +217,42 @@ struct JsonValue {
     return results;
   }
 
+  StatusOr<std::vector<std::string>> GetBytes(std::string_view path, JsonStorageFormat format,
+                                              int max_nesting_depth = std::numeric_limits<int>::max()) const {
+    std::vector<std::string> results;
+    try {
+      jsoncons::jsonpath::json_query(value, path, [&](const std::string & /*path*/, const jsoncons::json &origin) {
+        if (!origin.empty()) {
+          Status s;
+          std::string buffer;
+          std::error_code ec;
+          if (format == JsonStorageFormat::JSON) {
+            jsoncons::json_options options;
+            options.max_nesting_depth(max_nesting_depth);
+            jsoncons::compact_json_string_encoder encoder{buffer, options};
+            origin.dump(encoder, ec);
+          } else if (format == JsonStorageFormat::CBOR) {
+            jsoncons::cbor::cbor_options options;
+            options.max_nesting_depth(max_nesting_depth);
+            jsoncons::cbor::basic_cbor_encoder<jsoncons::string_sink<std::string>> encoder{buffer, options};
+            origin.dump(encoder, ec);
+          }
+          if (ec) {
+            throw std::system_error(ec);
+          }
+          results.emplace_back(std::to_string(buffer.size()));
+        } else {
+          results.emplace_back(std::to_string(0));
+        }
+      });
+    } catch (const jsoncons::jsonpath::jsonpath_error &e) {
+      return {Status::NotOK, e.what()};
+    } catch (const std::system_error &e) {
+      return {Status::NotOK, e.what()};
+    }
+    return results;
+  }
+
   StatusOr<JsonValue> Get(std::string_view path) const {
     try {
       return jsoncons::jsonpath::json_query(value, path);

src/types/redis_json.cc

@@ -627,4 +627,25 @@ std::vector<rocksdb::Status> Json::readMulti(const std::vector<Slice> &ns_keys,
   return statuses;
 }
 
+rocksdb::Status Json::DebugMemory(const std::string &user_key, const std::string &path,
+                                  std::vector<std::string> *results) {
+  auto ns_key = AppendNamespacePrefix(user_key);
+  JsonMetadata metadata;
+  if (path == "$") {
+    std::string bytes;
+    Slice rest;
+    auto s = GetMetadata(GetOptions{}, {kRedisJson}, ns_key, &bytes, &metadata, &rest);
+    if (!s.ok()) return s;
+    results->emplace_back(std::to_string(rest.size()));
+  } else {
+    JsonValue json_val;
+    auto s = read(ns_key, &metadata, &json_val);
+    if (!s.ok()) return s;
+    auto str_bytes = json_val.GetBytes(path, metadata.format, storage_->GetConfig()->json_max_nesting_depth);
+    if (!str_bytes) return rocksdb::Status::InvalidArgument(str_bytes.Msg());
+    *results = std::move(*str_bytes);
+  }
+  return rocksdb::Status::OK();
+}
+
 }  // namespace redis

src/types/redis_json.h

@@ -68,6 +68,7 @@ class Json : public Database {
                                     std::vector<JsonValue> &results);
   rocksdb::Status MSet(const std::vector<std::string> &user_keys, const std::vector<std::string> &paths,
                        const std::vector<std::string> &values);
+  rocksdb::Status DebugMemory(const std::string &user_key, const std::string &path, std::vector<std::string> *results);
 
  private:
   rocksdb::Status write(Slice ns_key, JsonMetadata *metadata, const JsonValue &json_val);

tests/gocase/unit/type/json/json_test.go

@@ -627,6 +627,17 @@ func TestJson(t *testing.T) {
 		EqualJSON(t, `[{"a": 4, "b": 5, "nested": {"a": 6}, "c": null}]`, rdb.Do(ctx, "JSON.GET", "a1", "$").Val())
 		EqualJSON(t, `[4]`, rdb.Do(ctx, "JSON.GET", "a1", "$.a").Val())
 	})
+
+	t.Run("JSON.DEBUG MEMORY basics", func(t *testing.T) {
+		var result1 = make([]interface{}, 0)
+		result1 = append(result1, int64(4))
+		require.NoError(t, rdb.Do(ctx, "JSON.SET", "a", "$", `{"a":"foo", "nested": {"a": "hello"}, "nested2": {"a": 31}}`).Err())
+		require.Equal(t, rdb.Do(ctx, "JSON.DEBUG", "MEMORY", "a", "$.a").Val(), result1)
+		var result2 = make([]interface{}, 0)
+		result2 = append(result2, int64(4), int64(6), int64(2))
+		require.Equal(t, rdb.Do(ctx, "JSON.DEBUG", "MEMORY", "a", "$..a").Val(), result2)
+		require.ErrorIs(t, rdb.Do(ctx, "JSON.DEBUG", "MEMORY", "not_exists", "$").Err(), redis.Nil)
+	})
 }
 
 func EqualJSON(t *testing.T, expected string, actual interface{}) {