You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@kvrocks.apache.org by hu...@apache.org on 2023/06/13 04:48:29 UTC

[incubator-kvrocks] branch unstable updated: Add support of the new command SINTERCARD(Redis 7) (#1444)

This is an automated email from the ASF dual-hosted git repository.

hulk pushed a commit to branch unstable
in repository https://gitbox.apache.org/repos/asf/incubator-kvrocks.git


The following commit(s) were added to refs/heads/unstable by this push:
     new ad704f57 Add support of the new command SINTERCARD(Redis 7) (#1444)
ad704f57 is described below

commit ad704f57311a9ca734171f0582fcfd67ca091baa
Author: clundro <in...@outlook.com>
AuthorDate: Tue Jun 13 12:48:24 2023 +0800

    Add support of the new command SINTERCARD(Redis 7) (#1444)
---
 src/commands/cmd_set.cc                | 69 ++++++++++++++++++++++++++++++++++
 src/commands/error_constants.h         |  1 +
 src/types/redis_set.cc                 | 46 +++++++++++++++++++++++
 src/types/redis_set.h                  |  1 +
 tests/cppunit/types/set_test.cc        | 45 +++++++++++++++++++++-
 tests/gocase/unit/type/set/set_test.go | 69 ++++++++++++++++++++++++++++++++++
 6 files changed, 230 insertions(+), 1 deletion(-)

diff --git a/src/commands/cmd_set.cc b/src/commands/cmd_set.cc
index d6a09430..c066e372 100644
--- a/src/commands/cmd_set.cc
+++ b/src/commands/cmd_set.cc
@@ -18,6 +18,8 @@
  *
  */
 
+#include <cstdint>
+
 #include "commander.h"
 #include "commands/scan_base.h"
 #include "error_constants.h"
@@ -292,6 +294,72 @@ class CommandSInter : public Commander {
   }
 };
 
+/*
+ * description:
+ *    syntax:   `SINTERCARD numkeys key [key ...] [LIMIT limit]`
+ *
+ *    limit:    the valid limit is an non-negative integer.
+ */
+class CommandSInterCard : public Commander {
+ public:
+  Status Parse(const std::vector<std::string> &args) override {
+    auto parse_numkey = ParseInt<int>(args[1], 10);
+    if (!parse_numkey) {
+      return {Status::RedisParseErr, errValueNotInteger};
+    }
+
+    if (*parse_numkey <= 0) {
+      return {Status::RedisParseErr, errValueMustBePositive};
+    }
+    numkeys_ = *parse_numkey;
+
+    // command: for example, SINTERCARD 2 key1 key2 LIMIT 1
+    auto arg_sz = args.size();
+    if (arg_sz == numkeys_ + 4 && util::ToLower(args[numkeys_ + 2]) == "limit") {
+      auto parse_limit = ParseInt<int>(args[numkeys_ + 3], 10);
+      if (!parse_limit) {
+        return {Status::RedisParseErr, errValueNotInteger};
+      }
+      if (*parse_limit < 0) {
+        return {Status::RedisParseErr, errLimitIsNegative};
+      }
+      limit_ = *parse_limit;
+      return Commander::Parse(args);
+    }
+
+    if (arg_sz != numkeys_ + 2) {
+      return {Status::RedisParseErr, errWrongNumOfArguments};
+    }
+    return Commander::Parse(args);
+  }
+
+  Status Execute(Server *svr, Connection *conn, std::string *output) override {
+    std::vector<Slice> keys;
+    for (size_t i = 2; i < numkeys_ + 2; i++) {
+      keys.emplace_back(args_[i]);
+    }
+
+    redis::Set set_db(svr->storage, conn->GetNamespace());
+    uint64_t ret = 0;
+    auto s = set_db.InterCard(keys, limit_, &ret);
+    if (!s.ok()) {
+      return {Status::RedisExecErr, s.ToString()};
+    }
+
+    *output = redis::Integer(ret);
+    return Status::OK();
+  }
+
+  static CommandKeyRange Range(const std::vector<std::string> &args) {
+    int num_key = *ParseInt<int>(args[1], 10);
+    return {2, 1 + num_key, 1};
+  }
+
+ private:
+  uint64_t numkeys_ = 0;
+  uint64_t limit_ = 0;
+};
+
 class CommandSDiffStore : public Commander {
  public:
   Status Execute(Server *svr, Connection *conn, std::string *output) override {
@@ -380,6 +448,7 @@ REDIS_REGISTER_COMMANDS(MakeCmdAttr<CommandSAdd>("sadd", -3, "write", 1, 1, 1),
                         MakeCmdAttr<CommandSDiff>("sdiff", -2, "read-only", 1, -1, 1),
                         MakeCmdAttr<CommandSUnion>("sunion", -2, "read-only", 1, -1, 1),
                         MakeCmdAttr<CommandSInter>("sinter", -2, "read-only", 1, -1, 1),
+                        MakeCmdAttr<CommandSInterCard>("sintercard", -3, "read-only", CommandSInterCard::Range),
                         MakeCmdAttr<CommandSDiffStore>("sdiffstore", -3, "write", 1, -1, 1),
                         MakeCmdAttr<CommandSUnionStore>("sunionstore", -3, "write", 1, -1, 1),
                         MakeCmdAttr<CommandSInterStore>("sinterstore", -3, "write", 1, -1, 1),
diff --git a/src/commands/error_constants.h b/src/commands/error_constants.h
index bfba200a..94858289 100644
--- a/src/commands/error_constants.h
+++ b/src/commands/error_constants.h
@@ -32,6 +32,7 @@ inline constexpr const char *errNoSuchKey = "no such key";
 inline constexpr const char *errUnbalancedStreamList =
     "Unbalanced XREAD list of streams: for each stream key an ID or '$' must be specified.";
 inline constexpr const char *errTimeoutIsNegative = "timeout is negative";
+inline constexpr const char *errLimitIsNegative = "LIMIT can't be negative";
 inline constexpr const char *errLimitOptionNotAllowed =
     "syntax error, LIMIT cannot be used without the special ~ option";
 inline constexpr const char *errZSetLTGTNX = "GT, LT, and/or NX options at the same time are not compatible";
diff --git a/src/types/redis_set.cc b/src/types/redis_set.cc
index de5f1e8d..0a26c9f9 100644
--- a/src/types/redis_set.cc
+++ b/src/types/redis_set.cc
@@ -358,6 +358,52 @@ rocksdb::Status Set::Inter(const std::vector<Slice> &keys, std::vector<std::stri
   return rocksdb::Status::OK();
 }
 
+rocksdb::Status Set::InterCard(const std::vector<Slice> &keys, uint64_t limit, uint64_t *cardinality) {
+  *cardinality = 0;
+
+  std::map<std::string, size_t> member_counters;
+  std::vector<std::string> target_members;
+
+  auto s = Members(keys[0], &target_members);
+  if (!s.ok() || target_members.empty()) return s;
+  for (const auto &member : target_members) {
+    member_counters[member] = 1;
+  }
+  if (limit == 0) {
+    limit = target_members.size();
+  }
+
+  size_t keys_size = keys.size();
+  if (keys_size == 1) {
+    *cardinality = std::min(static_cast<uint64_t>(target_members.size()), limit);
+    return rocksdb::Status::OK();
+  }
+
+  bool limit_reached = false;
+  for (size_t i = 1; i < keys_size; i++) {
+    s = Members(keys[i], &target_members);
+    if (!s.ok() || target_members.empty()) {
+      return s;
+    }
+
+    for (const auto &member : target_members) {
+      auto iter = member_counters.find(member);
+      if (iter == member_counters.end()) continue;
+      if (++iter->second == keys_size) {
+        *cardinality += 1;
+        if (--limit == 0) {
+          limit_reached = true;
+          break;
+        }
+      }
+    }
+
+    if (limit_reached) break;
+  }
+
+  return rocksdb::Status::OK();
+}
+
 rocksdb::Status Set::DiffStore(const Slice &dst, const std::vector<Slice> &keys, uint64_t *saved_cnt) {
   *saved_cnt = 0;
   std::vector<std::string> members;
diff --git a/src/types/redis_set.h b/src/types/redis_set.h
index 28ab85de..739c3077 100644
--- a/src/types/redis_set.h
+++ b/src/types/redis_set.h
@@ -43,6 +43,7 @@ class Set : public SubKeyScanner {
   rocksdb::Status Diff(const std::vector<Slice> &keys, std::vector<std::string> *members);
   rocksdb::Status Union(const std::vector<Slice> &keys, std::vector<std::string> *members);
   rocksdb::Status Inter(const std::vector<Slice> &keys, std::vector<std::string> *members);
+  rocksdb::Status InterCard(const std::vector<Slice> &keys, uint64_t limit, uint64_t *cardinality);
   rocksdb::Status Overwrite(Slice user_key, const std::vector<std::string> &members);
   rocksdb::Status DiffStore(const Slice &dst, const std::vector<Slice> &keys, uint64_t *saved_cnt);
   rocksdb::Status UnionStore(const Slice &dst, const std::vector<Slice> &keys, uint64_t *save_cnt);
diff --git a/tests/cppunit/types/set_test.cc b/tests/cppunit/types/set_test.cc
index 26dbb438..c6d78b75 100644
--- a/tests/cppunit/types/set_test.cc
+++ b/tests/cppunit/types/set_test.cc
@@ -178,19 +178,62 @@ TEST_F(RedisSetTest, Union) {
 
 TEST_F(RedisSetTest, Inter) {
   uint64_t ret = 0;
-  std::string k1 = "key1", k2 = "key2", k3 = "key3";
+  std::string k1 = "key1", k2 = "key2", k3 = "key3", k4 = "key4", k5 = "key5";
   rocksdb::Status s = set_->Add(k1, {"a", "b", "c", "d"}, &ret);
   EXPECT_EQ(ret, 4);
   set_->Add(k2, {"c"}, &ret);
   EXPECT_EQ(ret, 1);
   set_->Add(k3, {"a", "c", "e"}, &ret);
   EXPECT_EQ(ret, 3);
+  set_->Add(k5, {"a"}, &ret);
+  EXPECT_EQ(ret, 1);
   std::vector<std::string> members;
   set_->Inter({k1, k2, k3}, &members);
   EXPECT_EQ(1, members.size());
+  members.clear();
+  set_->Inter({k1, k2, k4}, &members);
+  EXPECT_EQ(0, members.size());
+  set_->Inter({k1, k4, k5}, &members);
+  EXPECT_EQ(0, members.size());
+  set_->Del(k1);
+  set_->Del(k2);
+  set_->Del(k3);
+  set_->Del(k4);
+  set_->Del(k5);
+}
+
+TEST_F(RedisSetTest, InterCard) {
+  uint64_t ret = 0;
+  std::string k1 = "key1", k2 = "key2", k3 = "key3", k4 = "key4";
+  rocksdb::Status s = set_->Add(k1, {"a", "b", "c", "d"}, &ret);
+  EXPECT_EQ(ret, 4);
+  set_->Add(k2, {"c", "d", "e"}, &ret);
+  EXPECT_EQ(ret, 3);
+  set_->Add(k3, {"e", "f"}, &ret);
+  EXPECT_EQ(ret, 2);
+  set_->InterCard({k1, k2}, 0, &ret);
+  EXPECT_EQ(ret, 2);
+  set_->InterCard({k1, k2}, 1, &ret);
+  EXPECT_EQ(ret, 1);
+  set_->InterCard({k1, k2}, 3, &ret);
+  EXPECT_EQ(ret, 2);
+  set_->InterCard({k2, k3}, 1, &ret);
+  EXPECT_EQ(ret, 1);
+  set_->InterCard({k1, k3}, 5, &ret);
+  EXPECT_EQ(ret, 0);
+  set_->InterCard({k1, k4}, 5, &ret);
+  EXPECT_EQ(ret, 0);
+  set_->InterCard({k1}, 0, &ret);
+  EXPECT_EQ(ret, 4);
+  for (uint32_t i = 1; i < 20; i++) {
+    set_->InterCard({k1}, i, &ret);
+    uint64_t val = (i >= 4) ? 4 : i;
+    EXPECT_EQ(ret, val);
+  }
   set_->Del(k1);
   set_->Del(k2);
   set_->Del(k3);
+  set_->Del(k4);
 }
 
 TEST_F(RedisSetTest, Overwrite) {
diff --git a/tests/gocase/unit/type/set/set_test.go b/tests/gocase/unit/type/set/set_test.go
index b7fa08d0..61ecc2a1 100644
--- a/tests/gocase/unit/type/set/set_test.go
+++ b/tests/gocase/unit/type/set/set_test.go
@@ -229,6 +229,34 @@ func TestSet(t *testing.T) {
 			}
 		})
 
+		t.Run("SINTERCARD with a single set - "+dstype, func(t *testing.T) {
+			cmd1 := rdb.SInter(ctx, "set1")
+			require.NoError(t, cmd1.Err())
+			for j := 1; j < 20; j++ {
+				cmd2 := rdb.SInterCard(ctx, int64(j), "set1")
+				require.NoError(t, cmd2.Err())
+				if j > len(cmd1.Val()) {
+					require.EqualValues(t, cmd2.Val(), len(cmd1.Val()))
+				} else {
+					require.EqualValues(t, cmd2.Val(), j)
+				}
+			}
+		})
+
+		t.Run("SINTERCARD with two sets - "+dstype, func(t *testing.T) {
+			cmd1 := rdb.SInter(ctx, "set1", "set2")
+			require.NoError(t, cmd1.Err())
+			for j := 1; j < 20; j++ {
+				cmd2 := rdb.SInterCard(ctx, int64(j), "set1", "set2")
+				require.NoError(t, cmd2.Err())
+				if j > len(cmd1.Val()) {
+					require.EqualValues(t, cmd2.Val(), len(cmd1.Val()))
+				} else {
+					require.EqualValues(t, cmd2.Val(), j)
+				}
+			}
+		})
+
 		t.Run("SINTERSTORE with two sets - "+dstype, func(t *testing.T) {
 			require.NoError(t, rdb.SInterStore(ctx, "setres", "set1", "set2").Err())
 			cmd := rdb.SMembers(ctx, "setres")
@@ -282,6 +310,20 @@ func TestSet(t *testing.T) {
 			}
 		})
 
+		t.Run("SINTERCARD with three sets - "+dstype, func(t *testing.T) {
+			cmd1 := rdb.SInter(ctx, "set1", "set2", "set3")
+			require.NoError(t, cmd1.Err())
+			for j := 1; j < 20; j++ {
+				cmd2 := rdb.SInterCard(ctx, int64(j), "set1", "set2", "set3")
+				require.NoError(t, cmd2.Err())
+				if j > len(cmd1.Val()) {
+					require.EqualValues(t, cmd2.Val(), len(cmd1.Val()))
+				} else {
+					require.EqualValues(t, cmd2.Val(), j)
+				}
+			}
+		})
+
 		t.Run("SINTERSTORE with three sets - "+dstype, func(t *testing.T) {
 			require.NoError(t, rdb.SInterStore(ctx, "setres", "set1", "set2", "set3").Err())
 			cmd := rdb.SMembers(ctx, "setres")
@@ -399,6 +441,33 @@ func TestSet(t *testing.T) {
 		require.EqualValues(t, []string{}, rdb.SInter(ctx, "set1", "set2", "key3").Val())
 	})
 
+	t.Run("SINTERCARD with wrong args", func(t *testing.T) {
+		CreateSet(t, rdb, ctx, "set1", []interface{}{"foo", "2"})
+		CreateSet(t, rdb, ctx, "set2", []interface{}{"a", "b", "2"})
+
+		// numkey should be a positive integer.
+		require.ErrorContains(t, rdb.Do(ctx, "sintercard", "3.5", "set1").Err(), "is not an integer")
+		require.ErrorContains(t, rdb.Do(ctx, "sintercard", "-1", "set1").Err(), "must be positive")
+		require.ErrorContains(t, rdb.Do(ctx, "sintercard", "0", "set1").Err(), "must be positive")
+
+		require.ErrorContains(t, rdb.Do(ctx, "sintercard", "1", "set1", "set2").Err(), "wrong number of arguments")
+		require.ErrorContains(t, rdb.Do(ctx, "sintercard", "1", "set1", "set2", "LIMIT", "2").Err(), "wrong number of arguments")
+
+		// The limit argument should be a positive integer.
+		require.ErrorContains(t, rdb.Do(ctx, "sintercard", "2", "set1", "set2", "LIMIT", "-1").Err(), "can't be negative")
+		require.ErrorContains(t, rdb.Do(ctx, "sintercard", "2", "set1", "set2", "LIMIT", "1.5").Err(), "is not an integer")
+	})
+
+	t.Run("SINTERCARD should return zero with empty sets", func(t *testing.T) {
+		require.NoError(t, rdb.Del(ctx, "set1", "set2", "set3").Err())
+		require.NoError(t, rdb.SAdd(ctx, "set1", "a", "b", "c").Err())
+		require.NoError(t, rdb.SAdd(ctx, "set2", "b", "c", "d").Err())
+		for j := 1; j < 20; j++ {
+			require.EqualValues(t, 0, rdb.SInterCard(ctx, int64(j), "set1", "set2", "key3").Val())
+		}
+		require.EqualValues(t, 0, rdb.SInterCard(ctx, 0, "set3").Val())
+	})
+
 	t.Run("SINTER with same integer elements but different encoding", func(t *testing.T) {
 		require.NoError(t, rdb.Del(ctx, "set1", "set2").Err())
 		require.NoError(t, rdb.SAdd(ctx, "set1", 1, 2, 3).Err())