Add the support of the json.arrappend command

src/commands/cmd_json.cc

@@ -52,7 +52,37 @@ class CommandJsonGet : public Commander {
   }
 };
 
+class CommandJsonArrAppend : public Commander {
+ public:
+  Status Execute(Server *svr, Connection *conn, std::string *output) override {
+    redis::Json json(svr->storage, conn->GetNamespace());
+
+    std::vector<uint64_t> result_count;
+
+    auto s = json.ArrAppend(args_[1], args_[2], {args_.begin() + 3, args_.end()}, result_count);
+    if (!s.ok()) return {Status::RedisExecErr, s.ToString()};
+
+    if(result_count.empty()) {
+      result_count.emplace_back(0);
+    }
+
+    std::vector<std::string> result_values;
+    result_values.reserve(result_count.size());
+    for(auto c : result_count) {
+      if(c != 0) {
+        result_values.emplace_back("(integer) " + std::to_string(c));
+      } else {
+        result_values.emplace_back();
+      }
+    }
+
+    *output = redis::MultiBulkString(result_values, true);
+    return Status::OK();
+  }
+};
+
 REDIS_REGISTER_COMMANDS(MakeCmdAttr<CommandJsonSet>("json.set", -3, "write", 1, 1, 1),
-                        MakeCmdAttr<CommandJsonGet>("json.get", -2, "read-only", 1, 1, 1), );
+                        MakeCmdAttr<CommandJsonGet>("json.get", -2, "read-only", 1, 1, 1),
+                        MakeCmdAttr<CommandJsonArrAppend>("json.arrappend", -4, "write", 1, 1, 1), );
 
 }  // namespace redis

src/types/json.h

@@ -73,6 +73,25 @@ struct JsonValue {
     }
   }
 
+  Status ArrAppend(std::string_view path, const std::vector<jsoncons::json> &append_values,
+                   std::vector<uint64_t> &result_count) {
+    try {
+      std::vector<std::string> paths;
+      jsoncons::jsonpath::json_replace(value, path, [&append_values, &result_count]
+                                       (const std::string &path, jsoncons::json &val) {
+        if(val.is_array()) {
+          val.insert(val.array_range().end(), append_values.begin(), append_values.end());
+          result_count.emplace_back(val.size());
+        } else {
+          result_count.emplace_back(0);
+        }
+      });
+    } catch (const jsoncons::jsonpath::jsonpath_error &e) {
+      return {Status::NotOK, e.what()};
+    }
+    return Status::OK();
+  }
+
   JsonValue(const JsonValue &) = default;
   JsonValue(JsonValue &&) = default;
 

src/types/redis_json.cc

@@ -117,4 +117,38 @@ rocksdb::Status Json::Get(const std::string &user_key, const std::vector<std::st
   return rocksdb::Status::OK();
 }
 
+rocksdb::Status Json::ArrAppend(const std::string &user_key, const std::string &path,
+                                const std::vector<std::string> &values,
+                                std::vector<uint64_t> &result_count) {
+  auto ns_key = AppendNamespacePrefix(user_key);
+
+  std::vector<jsoncons::json> append_values;
+  for(auto &v : values) {
+    auto value_res = JsonValue::FromString(v);
+    if(!value_res) return rocksdb::Status::InvalidArgument(value_res.Msg());
+    auto value = *std::move(value_res);
+    append_values.emplace_back(value.value);
+  }
+
+  LockGuard guard(storage_->GetLockManager(), ns_key);
+
+  std::string bytes;
+  JsonMetadata metadata;
+  Slice rest;
+  auto s = GetMetadata(kRedisJson, ns_key, &bytes, &metadata, &rest);
+  if (!s.ok()) return s;
+
+  if (metadata.format != JsonStorageFormat::JSON)
+    return rocksdb::Status::NotSupported("JSON storage format not supported");
+
+  auto value_res = JsonValue::FromString(rest.ToStringView());
+  if(!value_res) return rocksdb::Status::Corruption(value_res.Msg());
+  auto value = *std::move(value_res);
+
+  auto append_res = value.ArrAppend(path, append_values, result_count);
+  if(!append_res) return rocksdb::Status::InvalidArgument(append_res.Msg());
+
+  return write(ns_key, &metadata, value);
+}
+
 }  // namespace redis

src/types/redis_json.h

@@ -34,6 +34,9 @@ class Json : public Database {
 
   rocksdb::Status Set(const std::string &user_key, const std::string &path, const std::string &value);
   rocksdb::Status Get(const std::string &user_key, const std::vector<std::string> &paths, JsonValue *result);
+  rocksdb::Status ArrAppend(const std::string &user_key, const std::string &path,
+                            const std::vector<std::string> &values,
+                            std::vector<uint64_t> &result_count);
 
  private:
   rocksdb::Status write(Slice ns_key, JsonMetadata *metadata, const JsonValue &json_val);

tests/cppunit/types/json_test.cc

@@ -119,3 +119,42 @@ TEST_F(RedisJsonTest, Get) {
   ASSERT_TRUE(json_->Get(key_, {"$..x", "$..y", "$..z"}, &json_val_).ok());
   ASSERT_EQ(json_val_.Dump(), R"({"$..x":[{"y":1},4],"$..y":[[2,{"z":3}],1],"$..z":[{"a":{"x":4}},3]})");
 }
+
+TEST_F(RedisJsonTest, ArrAppend) {
+  std::vector<uint64_t> res;
+
+  ASSERT_TRUE(json_->Set(key_, "$", R"({"x":1,"y":[]})").ok());
+  ASSERT_TRUE(json_->ArrAppend(key_, "$.x", {"1"}, res).ok());
+  ASSERT_EQ(res.size(), 1);
+  ASSERT_EQ(res[0], 0);
+  ASSERT_TRUE(json_->Get(key_, {}, &json_val_).ok());
+  ASSERT_EQ(json_val_.Dump(), R"({"x":1,"y":[]})");
+  res.clear();
+
+  ASSERT_TRUE(json_->Set(key_, "$", R"({"x":[1,2,{"z":3}],"y":[]})").ok());
+  ASSERT_TRUE(json_->ArrAppend(key_, "$.x", {"1"}, res).ok());
+  ASSERT_EQ(res.size(), 1);
+  ASSERT_EQ(res[0], 4);
+  ASSERT_TRUE(json_->Get(key_, {}, &json_val_).ok());
+  ASSERT_EQ(json_val_.Dump(), R"({"x":[1,2,{"z":3},1],"y":[]})");
+  res.clear();
+
+  ASSERT_TRUE(json_->ArrAppend(key_, "$..y", {"1", "2", "3"}, res).ok());
+  ASSERT_EQ(res.size(), 1);
+  ASSERT_EQ(res[0], 3);
+  ASSERT_TRUE(json_->Get(key_, {}, &json_val_).ok());
+  ASSERT_EQ(json_val_.Dump(), R"({"x":[1,2,{"z":3},1],"y":[1,2,3]})");
+  res.clear();
+
+  ASSERT_TRUE(json_->Set(key_, "$.x[2]", R"({"x":[1,2,{"z":3,"y":[]}],"y":[{"y":1}]})").ok());
+  ASSERT_TRUE(json_->ArrAppend(key_, "$..y", {"1", "2", "3"}, res).ok());
+  ASSERT_EQ(res.size(), 4);
+  std::sort(res.begin(), res.end());
+  ASSERT_EQ(res[0], 0);
+  ASSERT_EQ(res[1], 3);
+  ASSERT_EQ(res[2], 4);
+  ASSERT_EQ(res[3], 6);
+  ASSERT_TRUE(json_->Get(key_, {}, &json_val_).ok());
+  ASSERT_EQ(json_val_.Dump(), R"({"x":[1,2,{"x":[1,2,{"y":[1,2,3],"z":3}],"y":[{"y":1},1,2,3]},1],"y":[1,2,3,1,2,3]})");
+  res.clear();
+}