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())