Add method transaction::has_key()

Add a method to check if transaction has appended a given key
in its sr_key_set.

include/wsrep/sr_key_set.hpp

@@ -36,6 +36,7 @@ namespace wsrep
             : root_()
         { }
         void insert(const wsrep::key& key);
+        bool contains(const wsrep::key& key) const;
         const branch_type& root() const { return root_; }
         void clear();
         bool empty() const { return root_.empty(); }

include/wsrep/transaction.hpp

@@ -171,6 +171,8 @@ namespace wsrep
 
         int append_key(const wsrep::key&);
 
+        bool has_key(const wsrep::key&) const;
+
         int append_data(const wsrep::const_buffer&);
 
         int after_row();

src/sr_key_set.cpp

@@ -37,6 +37,26 @@ void wsrep::sr_key_set::insert(const wsrep::key& key)
                             key.key_parts()[1].size()));
 }
 
+bool wsrep::sr_key_set::contains(const wsrep::key& key) const
+{
+    assert(key.size() >= 2);
+    if (key.size() < 2)
+    {
+        throw wsrep::runtime_error("Invalid key size");
+    }
+
+    std::string key_part_1(static_cast<const char*>(key.key_parts()[0].data()),
+                           key.key_parts()[0].size());
+    std::string key_part_2(static_cast<const char*>(key.key_parts()[1].data()),
+                           key.key_parts()[1].size());
+
+    auto it(root_.find(key_part_1));
+    if (it == root_.end())
+        return false;
+    leaf_type leafs(it->second);
+    return (leafs.find(key_part_2) != leafs.end());
+}
+
 void wsrep::sr_key_set::clear()
 {
     root_.clear();

src/transaction.cpp

@@ -253,6 +253,12 @@ int wsrep::transaction::append_key(const wsrep::key& key)
     }
 }
 
+bool wsrep::transaction::has_key(const wsrep::key& key) const
+{
+    assert(active());
+    return sr_keys_.contains(key);
+}
+
 int wsrep::transaction::append_data(const wsrep::const_buffer& data)
 {
     assert(active());

test/CMakeLists.txt

@@ -14,6 +14,7 @@ set(TEST_SOURCES
   nbo_test.cpp
   rsu_test.cpp
   server_context_test.cpp
+  sr_key_set_test.cpp
   toi_test.cpp
   transaction_test.cpp
   transaction_test_2pc.cpp

test/sr_key_set_test.cpp

@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2024 Codership Oy <info@codership.com>
+ *
+ * This file is part of wsrep-lib.
+ *
+ * Wsrep-lib is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Wsrep-lib is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with wsrep-lib.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "wsrep/key.hpp"
+#include "wsrep/sr_key_set.hpp"
+#include <boost/test/unit_test.hpp>
+
+static void append_key_parts(wsrep::key& key,
+                             const std::vector<std::string>& parts)
+{
+    for (const std::string& part : parts)
+    {
+        key.append_key_part(part.c_str(), part.length());
+    }
+}
+
+BOOST_AUTO_TEST_CASE(sr_key_set_test_contains)
+{
+    wsrep::sr_key_set key_set;
+
+    { // contains same key
+        wsrep::key key(wsrep::key::exclusive);
+        std::vector<std::string> parts = { "1", "2" };
+        append_key_parts(key, parts);
+        BOOST_REQUIRE(!key_set.contains(key));
+        key_set.insert(key);
+        BOOST_REQUIRE(key_set.contains(key));
+    }
+
+    { // contains same key with different type
+        wsrep::key key(wsrep::key::shared);
+        std::vector<std::string> parts = { "1", "2" };
+        append_key_parts(key, parts);
+        BOOST_REQUIRE(key_set.contains(key));
+    }
+
+    { // contains same key with one more level
+        wsrep::key key(wsrep::key::shared);
+        std::vector<std::string> parts = { "1", "2", "3" };
+        append_key_parts(key, parts);
+        BOOST_REQUIRE(key_set.contains(key));
+    }
+
+    { // does not contain different key first at first level
+        wsrep::key key(wsrep::key::shared);
+        std::vector<std::string> parts = { "different", "2" };
+        append_key_parts(key, parts);
+        BOOST_REQUIRE(!key_set.contains(key));
+    }
+
+    { // does not contain different key part at second level
+        wsrep::key key(wsrep::key::shared);
+        std::vector<std::string> parts = { "1", "different" };
+        append_key_parts(key, parts);
+        BOOST_REQUIRE(!key_set.contains(key));
+    }
+}