@nxtedition/rocksdb 13.5.7 → 13.5.9

package/deps/rocksdb/rocksdb/utilities/persistent_cache/persistent_cache_test.h

@@ -8,7 +8,6 @@
 // found in the LICENSE file. See the AUTHORS file for names of contributors.
 #pragma once
 
-
 #include <functional>
 #include <limits>
 #include <list>
@@ -281,4 +280,3 @@ class PersistentCacheDBTest : public DBTestBase {
 };
 
 }  // namespace ROCKSDB_NAMESPACE
-

package/deps/rocksdb/rocksdb/utilities/persistent_cache/persistent_cache_tier.cc

@@ -162,4 +162,3 @@ bool PersistentTieredCache::IsCompressed() {
 }
 
 }  // namespace ROCKSDB_NAMESPACE
-

package/deps/rocksdb/rocksdb/utilities/persistent_cache/persistent_cache_tier.h

@@ -5,7 +5,6 @@
 //
 #pragma once
 
-
 #include <limits>
 #include <list>
 #include <map>
@@ -337,4 +336,3 @@ class PersistentTieredCache : public PersistentCacheTier {
 };
 
 }  // namespace ROCKSDB_NAMESPACE
-

package/deps/rocksdb/rocksdb/utilities/persistent_cache/volatile_tier_impl.cc

@@ -135,4 +135,3 @@ bool VolatileCacheTier::Evict() {
 }
 
 }  // namespace ROCKSDB_NAMESPACE
-

package/deps/rocksdb/rocksdb/utilities/persistent_cache/volatile_tier_impl.h

@@ -5,7 +5,6 @@
 //
 #pragma once
 
-
 #include <atomic>
 #include <limits>
 #include <sstream>
@@ -136,4 +135,3 @@ class VolatileCacheTier : public PersistentCacheTier {
 };
 
 }  // namespace ROCKSDB_NAMESPACE
-

package/deps/rocksdb/rocksdb/utilities/secondary_index/faiss_ivf_index.cc

@@ -3,15 +3,43 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
 
-#include "utilities/secondary_index/faiss_ivf_index.h"
-
 #include <cassert>
+#include <optional>
+#include <stdexcept>
+#include <utility>
 
+#include "faiss/IndexIVF.h"
 #include "faiss/invlists/InvertedLists.h"
+#include "rocksdb/utilities/secondary_index_faiss.h"
+#include "util/autovector.h"
 #include "util/coding.h"
 
 namespace ROCKSDB_NAMESPACE {
 
+namespace {
+
+std::string SerializeLabel(faiss::idx_t label) {
+  std::string label_str;
+  PutVarsignedint64(&label_str, label);
+
+  return label_str;
+}
+
+faiss::idx_t DeserializeLabel(Slice label_slice) {
+  faiss::idx_t label = -1;
+  [[maybe_unused]] const bool ok = GetVarsignedint64(&label_slice, &label);
+  assert(ok);
+
+  return label;
+}
+
+}  // namespace
+
+struct FaissIVFIndex::KNNContext {
+  SecondaryIndexIterator* it;
+  autovector<std::string> keys;
+};
+
 class FaissIVFIndex::Adapter : public faiss::InvertedLists {
  public:
   Adapter(size_t num_lists, size_t code_size)
@@ -36,14 +64,14 @@ class FaissIVFIndex::Adapter : public faiss::InvertedLists {
     return nullptr;
   }
 
-  // Iterator-based read interface; not yet implemented
+  // Iterator-based read interface
   faiss::InvertedListsIterator* get_iterator(
-      size_t /* list_no */,
-      void* /* inverted_list_context */ = nullptr) const override {
-    // TODO: implement this
+      size_t list_no, void* inverted_list_context = nullptr) const override {
+    KNNContext* const knn_context =
+        static_cast<KNNContext*>(inverted_list_context);
+    assert(knn_context);
 
-    assert(false);
-    return nullptr;
+    return new IteratorAdapter(knn_context, list_no, code_size);
   }
 
   // Write interface; only add_entry is implemented/required for now
@@ -80,22 +108,72 @@ class FaissIVFIndex::Adapter : public faiss::InvertedLists {
   void resize(size_t /* list_no */, size_t /* new_size */) override {
     assert(false);
   }
-};
-
-std::string FaissIVFIndex::SerializeLabel(faiss::idx_t label) {
-  std::string label_str;
-  PutVarsignedint64(&label_str, label);
-
-  return label_str;
-}
 
-faiss::idx_t FaissIVFIndex::DeserializeLabel(Slice label_slice) {
-  faiss::idx_t label = -1;
-  [[maybe_unused]] const bool ok = GetVarsignedint64(&label_slice, &label);
-  assert(ok);
-
-  return label;
-}
+ private:
+  class IteratorAdapter : public faiss::InvertedListsIterator {
+   public:
+    IteratorAdapter(KNNContext* knn_context, size_t list_no, size_t code_size)
+        : knn_context_(knn_context),
+          it_(knn_context_->it),
+          code_size_(code_size) {
+      assert(knn_context_);
+      assert(it_);
+
+      const std::string label = SerializeLabel(list_no);
+      it_->Seek(label);
+      Update();
+    }
+
+    bool is_available() const override { return id_and_codes_.has_value(); }
+
+    void next() override {
+      it_->Next();
+      Update();
+    }
+
+    std::pair<faiss::idx_t, const uint8_t*> get_id_and_codes() override {
+      assert(is_available());
+
+      return *id_and_codes_;
+    }
+
+   private:
+    void Update() {
+      id_and_codes_.reset();
+
+      const Status status = it_->status();
+      if (!status.ok()) {
+        throw std::runtime_error(status.ToString());
+      }
+
+      if (!it_->Valid()) {
+        return;
+      }
+
+      if (!it_->PrepareValue()) {
+        throw std::runtime_error(
+            "Failed to prepare value during iteration in FaissIVFIndex");
+      }
+
+      const Slice value = it_->value();
+      if (value.size() != code_size_) {
+        throw std::runtime_error(
+            "Code with unexpected size encountered during iteration in "
+            "FaissIVFIndex");
+      }
+
+      const faiss::idx_t id = knn_context_->keys.size();
+      knn_context_->keys.emplace_back(it_->key().ToString());
+
+      id_and_codes_.emplace(id, reinterpret_cast<const uint8_t*>(value.data()));
+    }
+
+    KNNContext* knn_context_;
+    SecondaryIndexIterator* it_;
+    size_t code_size_;
+    std::optional<std::pair<faiss::idx_t, const uint8_t*>> id_and_codes_;
+  };
+};
 
 FaissIVFIndex::FaissIVFIndex(std::unique_ptr<faiss::IndexIVF>&& index,
                              std::string primary_column_name)
@@ -105,6 +183,7 @@ FaissIVFIndex::FaissIVFIndex(std::unique_ptr<faiss::IndexIVF>&& index,
   assert(index_);
   assert(index_->quantizer);
 
+  index_->parallel_mode = 0;
   index_->replace_invlists(adapter_.get());
 }
 
@@ -139,7 +218,9 @@ Status FaissIVFIndex::UpdatePrimaryColumnValue(
     const {
   assert(updated_column_value);
 
-  if (primary_column_value.size() != index_->d * sizeof(float)) {
+  const float* const embedding =
+      ConvertSliceToFloats(primary_column_value, index_->d);
+  if (!embedding) {
     return Status::InvalidArgument(
         "Incorrectly sized vector passed to FaissIVFIndex");
   }
@@ -148,8 +229,7 @@ Status FaissIVFIndex::UpdatePrimaryColumnValue(
   faiss::idx_t label = -1;
 
   try {
-    index_->quantizer->assign(
-        n, reinterpret_cast<const float*>(primary_column_value.data()), &label);
+    index_->quantizer->assign(n, embedding, &label);
   } catch (const std::exception& e) {
     return Status::InvalidArgument(e.what());
   }
@@ -179,6 +259,11 @@ Status FaissIVFIndex::GetSecondaryKeyPrefix(
   return Status::OK();
 }
 
+Status FaissIVFIndex::FinalizeSecondaryKeyPrefix(
+    std::variant<Slice, std::string>* /* secondary_key_prefix */) const {
+  return Status::OK();
+}
+
 Status FaissIVFIndex::GetSecondaryValue(
     const Slice& /* primary_key */, const Slice& primary_column_value,
     const Slice& original_column_value,
@@ -190,20 +275,23 @@ Status FaissIVFIndex::GetSecondaryValue(
   assert(label < index_->nlist);
 
   constexpr faiss::idx_t n = 1;
+
+  const float* const embedding =
+      ConvertSliceToFloats(original_column_value, index_->d);
+  assert(embedding);
+
   constexpr faiss::idx_t* xids = nullptr;
   std::string code_str;
 
   try {
-    index_->add_core(
-        n, reinterpret_cast<const float*>(original_column_value.data()), xids,
-        &label, &code_str);
+    index_->add_core(n, embedding, xids, &label, &code_str);
   } catch (const std::exception& e) {
-    return Status::InvalidArgument(e.what());
+    return Status::Corruption(e.what());
   }
 
   if (code_str.size() != index_->code_size) {
-    return Status::InvalidArgument(
-        "Unexpected code returned by fine quantizer");
+    return Status::Corruption(
+        "Code with unexpected size returned by fine quantizer");
   }
 
   secondary_value->emplace(std::move(code_str));
@@ -211,4 +299,67 @@ Status FaissIVFIndex::GetSecondaryValue(
   return Status::OK();
 }
 
+Status FaissIVFIndex::FindKNearestNeighbors(
+    SecondaryIndexIterator* it, const Slice& target, size_t neighbors,
+    size_t probes, std::vector<std::pair<std::string, float>>* result) const {
+  if (!it) {
+    return Status::InvalidArgument("Secondary index iterator must be provided");
+  }
+
+  const float* const embedding = ConvertSliceToFloats(target, index_->d);
+  if (!embedding) {
+    return Status::InvalidArgument(
+        "Incorrectly sized vector passed to FaissIVFIndex");
+  }
+
+  if (!neighbors) {
+    return Status::InvalidArgument("Invalid number of neighbors");
+  }
+
+  if (!probes) {
+    return Status::InvalidArgument("Invalid number of probes");
+  }
+
+  if (!result) {
+    return Status::InvalidArgument("Result parameter must be provided");
+  }
+
+  result->clear();
+
+  std::vector<float> distances(neighbors, 0.0f);
+  std::vector<faiss::idx_t> ids(neighbors, -1);
+
+  KNNContext knn_context{it, {}};
+
+  faiss::SearchParametersIVF params;
+  params.nprobe = probes;
+  params.inverted_list_context = &knn_context;
+
+  constexpr faiss::idx_t n = 1;
+
+  try {
+    index_->search(n, embedding, neighbors, distances.data(), ids.data(),
+                   &params);
+  } catch (const std::exception& e) {
+    return Status::Corruption(e.what());
+  }
+
+  result->reserve(neighbors);
+
+  for (size_t i = 0; i < neighbors; ++i) {
+    if (ids[i] < 0) {
+      break;
+    }
+
+    if (ids[i] >= knn_context.keys.size()) {
+      result->clear();
+      return Status::Corruption("Unexpected id returned by FAISS");
+    }
+
+    result->emplace_back(knn_context.keys[ids[i]], distances[i]);
+  }
+
+  return Status::OK();
+}
+
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/utilities/secondary_index/faiss_ivf_index_test.cc

@@ -3,8 +3,6 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
 
-#include "utilities/secondary_index/faiss_ivf_index.h"
-
 #include <charconv>
 #include <memory>
 #include <string>
@@ -13,6 +11,7 @@
 #include "faiss/IndexFlat.h"
 #include "faiss/IndexIVFFlat.h"
 #include "faiss/utils/random.h"
+#include "rocksdb/utilities/secondary_index_faiss.h"
 #include "rocksdb/utilities/transaction_db.h"
 #include "test_util/testharness.h"
 #include "util/coding.h"
@@ -33,7 +32,9 @@ TEST(FaissIVFIndexTest, Basic) {
 
   index->train(num_vectors, embeddings.data());
 
-  index->nprobe = 2;
+  const std::string primary_column_name = "embedding";
+  auto faiss_ivf_index =
+      std::make_shared<FaissIVFIndex>(std::move(index), primary_column_name);
 
   const std::string db_name = test::PerThreadDBPath("faiss_ivf_index_test");
   EXPECT_OK(DestroyDB(db_name, Options()));
@@ -42,9 +43,7 @@ TEST(FaissIVFIndexTest, Basic) {
   options.create_if_missing = true;
 
   TransactionDBOptions txn_db_options;
-  const std::string primary_column_name = "embedding";
-  txn_db_options.secondary_indices.emplace_back(
-      std::make_shared<FaissIVFIndex>(std::move(index), primary_column_name));
+  txn_db_options.secondary_indices.emplace_back(faiss_ivf_index);
 
   TransactionDB* db = nullptr;
   ASSERT_OK(TransactionDB::Open(options, txn_db_options, db_name, &db));
@@ -65,6 +64,8 @@ TEST(FaissIVFIndexTest, Basic) {
   secondary_index->SetPrimaryColumnFamily(cfh1);
   secondary_index->SetSecondaryColumnFamily(cfh2);
 
+  // Write the embeddings to the primary column family, indexing them in the
+  // process
   {
     std::unique_ptr<Transaction> txn(db->BeginTransaction(WriteOptions()));
 
@@ -75,13 +76,13 @@ TEST(FaissIVFIndexTest, Basic) {
           cfh1, primary_key,
           WideColumns{
               {primary_column_name,
-               Slice(reinterpret_cast<const char*>(embeddings.data() + i * dim),
-                     dim * sizeof(float))}}));
+               ConvertFloatsToSlice(embeddings.data() + i * dim, dim)}}));
     }
 
     ASSERT_OK(txn->Commit());
   }
 
+  // Verify the raw index data in the secondary column family
   {
     size_t num_found = 0;
 
@@ -102,10 +103,8 @@ TEST(FaissIVFIndexTest, Basic) {
 
       // Since we use IndexIVFFlat, there is no fine quantization, so the code
       // is actually just the original embedding
-      ASSERT_EQ(
-          it->value(),
-          Slice(reinterpret_cast<const char*>(embeddings.data() + id * dim),
-                dim * sizeof(float)));
+      ASSERT_EQ(it->value(),
+                ConvertFloatsToSlice(embeddings.data() + id * dim, dim));
 
       ++num_found;
     }
@@ -113,6 +112,253 @@ TEST(FaissIVFIndexTest, Basic) {
     ASSERT_OK(it->status());
     ASSERT_EQ(num_found, num_vectors);
   }
+
+  // Query the index with some of the original embeddings
+  std::unique_ptr<Iterator> underlying_it(db->NewIterator(ReadOptions(), cfh2));
+  auto secondary_it = std::make_unique<SecondaryIndexIterator>(
+      faiss_ivf_index.get(), std::move(underlying_it));
+
+  auto get_id = [](const Slice& key) -> faiss::idx_t {
+    faiss::idx_t id = -1;
+
+    if (std::from_chars(key.data(), key.data() + key.size(), id).ec !=
+        std::errc()) {
+      return -1;
+    }
+
+    return id;
+  };
+
+  constexpr size_t neighbors = 8;
+
+  auto verify = [&](faiss::idx_t id) {
+    // Search for a vector from the original set; we expect to find the vector
+    // itself as the closest match, since we're performing an exhaustive search
+    std::vector<std::pair<std::string, float>> result;
+    ASSERT_OK(faiss_ivf_index->FindKNearestNeighbors(
+        secondary_it.get(),
+        ConvertFloatsToSlice(embeddings.data() + id * dim, dim), neighbors,
+        num_lists, &result));
+
+    ASSERT_EQ(result.size(), neighbors);
+
+    const faiss::idx_t first_id = get_id(result[0].first);
+
+    ASSERT_GE(first_id, 0);
+    ASSERT_LT(first_id, num_vectors);
+    ASSERT_EQ(first_id, id);
+
+    ASSERT_EQ(result[0].second, 0.0f);
+
+    // Iterate over the rest of the results
+    for (size_t i = 1; i < neighbors; ++i) {
+      const faiss::idx_t other_id = get_id(result[i].first);
+      ASSERT_GE(other_id, 0);
+      ASSERT_LT(other_id, num_vectors);
+      ASSERT_NE(other_id, id);
+
+      ASSERT_GE(result[i].second, result[i - 1].second);
+    }
+  };
+
+  verify(0);
+  verify(16);
+  verify(32);
+  verify(64);
+
+  // Sanity checks
+  {
+    // No secondary index iterator
+    constexpr SecondaryIndexIterator* bad_secondary_it = nullptr;
+    std::vector<std::pair<std::string, float>> result;
+    ASSERT_TRUE(faiss_ivf_index
+                    ->FindKNearestNeighbors(
+                        bad_secondary_it,
+                        ConvertFloatsToSlice(embeddings.data(), dim), neighbors,
+                        num_lists, &result)
+                    .IsInvalidArgument());
+  }
+
+  {
+    // Invalid target
+    std::vector<std::pair<std::string, float>> result;
+    ASSERT_TRUE(faiss_ivf_index
+                    ->FindKNearestNeighbors(secondary_it.get(), "foo",
+                                            neighbors, num_lists, &result)
+                    .IsInvalidArgument());
+  }
+
+  {
+    // Invalid value for neighbors
+    constexpr size_t bad_neighbors = 0;
+    std::vector<std::pair<std::string, float>> result;
+    ASSERT_TRUE(faiss_ivf_index
+                    ->FindKNearestNeighbors(
+                        secondary_it.get(),
+                        ConvertFloatsToSlice(embeddings.data(), dim),
+                        bad_neighbors, num_lists, &result)
+                    .IsInvalidArgument());
+  }
+
+  {
+    // Invalid value for neighbors
+    constexpr size_t bad_probes = 0;
+    std::vector<std::pair<std::string, float>> result;
+    ASSERT_TRUE(faiss_ivf_index
+                    ->FindKNearestNeighbors(
+                        secondary_it.get(),
+                        ConvertFloatsToSlice(embeddings.data(), dim), neighbors,
+                        bad_probes, &result)
+                    .IsInvalidArgument());
+  }
+
+  {
+    // No result parameter
+    constexpr std::vector<std::pair<std::string, float>>* bad_result = nullptr;
+    ASSERT_TRUE(faiss_ivf_index
+                    ->FindKNearestNeighbors(
+                        secondary_it.get(),
+                        ConvertFloatsToSlice(embeddings.data(), dim), neighbors,
+                        num_lists, bad_result)
+                    .IsInvalidArgument());
+  }
+}
+
+TEST(FaissIVFIndexTest, Compare) {
+  // Train two copies of the same index; hand over one to FaissIVFIndex and use
+  // the other one as a baseline for comparison
+  constexpr size_t dim = 128;
+  auto quantizer_cmp = std::make_unique<faiss::IndexFlatL2>(dim);
+  auto quantizer = std::make_unique<faiss::IndexFlatL2>(dim);
+
+  constexpr size_t num_lists = 16;
+  auto index_cmp = std::make_unique<faiss::IndexIVFFlat>(quantizer_cmp.get(),
+                                                         dim, num_lists);
+  auto index =
+      std::make_unique<faiss::IndexIVFFlat>(quantizer.get(), dim, num_lists);
+
+  {
+    constexpr faiss::idx_t num_train = 1024;
+    std::vector<float> embeddings_train(dim * num_train);
+    faiss::float_rand(embeddings_train.data(), dim * num_train, 42);
+
+    index_cmp->train(num_train, embeddings_train.data());
+    index->train(num_train, embeddings_train.data());
+  }
+
+  auto faiss_ivf_index = std::make_shared<FaissIVFIndex>(
+      std::move(index), kDefaultWideColumnName.ToString());
+
+  const std::string db_name = test::PerThreadDBPath("faiss_ivf_index_test");
+  EXPECT_OK(DestroyDB(db_name, Options()));
+
+  Options options;
+  options.create_if_missing = true;
+
+  TransactionDBOptions txn_db_options;
+  txn_db_options.secondary_indices.emplace_back(faiss_ivf_index);
+
+  TransactionDB* db = nullptr;
+  ASSERT_OK(TransactionDB::Open(options, txn_db_options, db_name, &db));
+
+  std::unique_ptr<TransactionDB> db_guard(db);
+
+  ColumnFamilyOptions cf1_opts;
+  ColumnFamilyHandle* cfh1 = nullptr;
+  ASSERT_OK(db->CreateColumnFamily(cf1_opts, "cf1", &cfh1));
+  std::unique_ptr<ColumnFamilyHandle> cfh1_guard(cfh1);
+
+  ColumnFamilyOptions cf2_opts;
+  ColumnFamilyHandle* cfh2 = nullptr;
+  ASSERT_OK(db->CreateColumnFamily(cf2_opts, "cf2", &cfh2));
+  std::unique_ptr<ColumnFamilyHandle> cfh2_guard(cfh2);
+
+  const auto& secondary_index = txn_db_options.secondary_indices.back();
+  secondary_index->SetPrimaryColumnFamily(cfh1);
+  secondary_index->SetSecondaryColumnFamily(cfh2);
+
+  // Add the same set of database vectors to both indices
+  constexpr faiss::idx_t num_db = 4096;
+
+  {
+    std::vector<float> embeddings_db(dim * num_db);
+    faiss::float_rand(embeddings_db.data(), dim * num_db, 123);
+
+    for (faiss::idx_t i = 0; i < num_db; ++i) {
+      const float* const embedding = embeddings_db.data() + i * dim;
+
+      index_cmp->add(1, embedding);
+
+      const std::string primary_key = std::to_string(i);
+      ASSERT_OK(db->Put(WriteOptions(), cfh1, primary_key,
+                        ConvertFloatsToSlice(embedding, dim)));
+    }
+  }
+
+  // Search both indices with the same set of query vectors and make sure the
+  // results match
+  {
+    constexpr faiss::idx_t num_query = 32;
+    std::vector<float> embeddings_query(dim * num_query);
+    faiss::float_rand(embeddings_query.data(), dim * num_query, 456);
+
+    std::unique_ptr<Iterator> underlying_it(
+        db->NewIterator(ReadOptions(), cfh2));
+    auto secondary_it = std::make_unique<SecondaryIndexIterator>(
+        faiss_ivf_index.get(), std::move(underlying_it));
+
+    auto get_id = [](const Slice& key) -> faiss::idx_t {
+      faiss::idx_t id = -1;
+
+      if (std::from_chars(key.data(), key.data() + key.size(), id).ec !=
+          std::errc()) {
+        return -1;
+      }
+
+      return id;
+    };
+
+    for (size_t neighbors : {1, 2, 4}) {
+      for (size_t probes : {1, 2, 4}) {
+        for (faiss::idx_t i = 0; i < num_query; ++i) {
+          const float* const embedding = embeddings_query.data() + i * dim;
+
+          std::vector<float> distances(neighbors, 0.0f);
+          std::vector<faiss::idx_t> ids(neighbors, -1);
+
+          faiss::SearchParametersIVF params;
+          params.nprobe = probes;
+
+          index_cmp->search(1, embedding, neighbors, distances.data(),
+                            ids.data(), &params);
+
+          size_t result_size_cmp = 0;
+          for (faiss::idx_t id_cmp : ids) {
+            if (id_cmp < 0) {
+              break;
+            }
+
+            ++result_size_cmp;
+          }
+
+          std::vector<std::pair<std::string, float>> result;
+          ASSERT_OK(faiss_ivf_index->FindKNearestNeighbors(
+              secondary_it.get(), ConvertFloatsToSlice(embedding, dim),
+              neighbors, probes, &result));
+
+          ASSERT_EQ(result.size(), result_size_cmp);
+
+          for (size_t j = 0; j < result.size(); ++j) {
+            const faiss::idx_t id = get_id(result[j].first);
+            ASSERT_GE(id, 0);
+            ASSERT_LT(id, num_db);
+            ASSERT_EQ(id, ids[j]);
+            ASSERT_EQ(result[j].second, distances[j]);
+          }
+        }
+      }
+    }
+  }
 }
 
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/utilities/secondary_index/secondary_index_helper.h

@@ -0,0 +1,33 @@
+//  Copyright (c) Meta Platforms, Inc. and affiliates.
+//
+//  This source code is licensed under both the GPLv2 (found in the
+//  COPYING file in the root directory) and Apache 2.0 License
+//  (found in the LICENSE.Apache file in the root directory).
+
+#pragma once
+
+#include <string>
+#include <variant>
+
+#include "rocksdb/rocksdb_namespace.h"
+#include "rocksdb/slice.h"
+#include "util/overload.h"
+
+namespace ROCKSDB_NAMESPACE {
+
+class SecondaryIndexHelper {
+ public:
+  static Slice AsSlice(const std::variant<Slice, std::string>& var) {
+    return std::visit([](const auto& value) -> Slice { return value; }, var);
+  }
+
+  static std::string AsString(const std::variant<Slice, std::string>& var) {
+    return std::visit(
+        overload{
+            [](const Slice& value) -> std::string { return value.ToString(); },
+            [](const std::string& value) -> std::string { return value; }},
+        var);
+  }
+};
+
+}  // namespace ROCKSDB_NAMESPACE