@nxtedition/rocksdb 13.1.5 → 13.3.0

package/deps/rocksdb/rocksdb/util/udt_util.cc

@@ -139,9 +139,17 @@ ToggleUDT CompareComparator(const Comparator* new_comparator,
 
 TimestampRecoveryHandler::TimestampRecoveryHandler(
     const UnorderedMap<uint32_t, size_t>& running_ts_sz,
-    const UnorderedMap<uint32_t, size_t>& record_ts_sz)
+    const UnorderedMap<uint32_t, size_t>& record_ts_sz, bool seq_per_batch,
+    bool batch_per_txn)
     : running_ts_sz_(running_ts_sz),
       record_ts_sz_(record_ts_sz),
+      // Write after commit currently uses one seq per key (instead of per
+      // batch). So seq_per_batch being false indicates write_after_commit
+      // approach.
+      write_after_commit_(!seq_per_batch),
+      // WriteUnprepared can write multiple WriteBatches per transaction, so
+      // batch_per_txn being false indicates write_before_prepare.
+      write_before_prepare_(!batch_per_txn),
       new_batch_(new WriteBatch()),
       handler_valid_(true),
       new_batch_diff_from_orig_batch_(false) {}
@@ -258,6 +266,43 @@ Status TimestampRecoveryHandler::PutBlobIndexCF(uint32_t cf, const Slice& key,
   return WriteBatchInternal::PutBlobIndex(new_batch_.get(), cf, new_key, value);
 }
 
+Status TimestampRecoveryHandler::MarkBeginPrepare(bool unprepare) {
+  // Transaction policy change requires empty WAL and User-defined timestamp is
+  // only supported for write committed txns.
+  // WriteBatch::Iterate has will handle this based on
+  // handler->WriteAfterCommit() and handler->WriteBeforePrepare().
+  if (unprepare) {
+    return Status::InvalidArgument(
+        "Handle user defined timestamp setting change is not supported for"
+        "write unprepared policy. The WAL must be emptied.");
+  }
+  return WriteBatchInternal::InsertBeginPrepare(new_batch_.get(),
+                                                write_after_commit_,
+                                                /* unprepared_batch */ false);
+}
+
+Status TimestampRecoveryHandler::MarkEndPrepare(const Slice& name) {
+  return WriteBatchInternal::InsertEndPrepare(new_batch_.get(), name);
+}
+
+Status TimestampRecoveryHandler::MarkCommit(const Slice& name) {
+  return WriteBatchInternal::MarkCommit(new_batch_.get(), name);
+}
+
+Status TimestampRecoveryHandler::MarkCommitWithTimestamp(
+    const Slice& name, const Slice& commit_ts) {
+  return WriteBatchInternal::MarkCommitWithTimestamp(new_batch_.get(), name,
+                                                     commit_ts);
+}
+
+Status TimestampRecoveryHandler::MarkRollback(const Slice& name) {
+  return WriteBatchInternal::MarkRollback(new_batch_.get(), name);
+}
+
+Status TimestampRecoveryHandler::MarkNoop(bool /*empty_batch*/) {
+  return WriteBatchInternal::InsertNoop(new_batch_.get());
+}
+
 Status TimestampRecoveryHandler::ReconcileTimestampDiscrepancy(
     uint32_t cf, const Slice& key, std::string* new_key_buf, Slice* new_key) {
   assert(handler_valid_);
@@ -304,8 +349,8 @@ Status HandleWriteBatchTimestampSizeDifference(
     const WriteBatch* batch,
     const UnorderedMap<uint32_t, size_t>& running_ts_sz,
     const UnorderedMap<uint32_t, size_t>& record_ts_sz,
-    TimestampSizeConsistencyMode check_mode,
-    std::unique_ptr<WriteBatch>* new_batch) {
+    TimestampSizeConsistencyMode check_mode, bool seq_per_batch,
+    bool batch_per_txn, std::unique_ptr<WriteBatch>* new_batch) {
   // Quick path to bypass checking the WriteBatch.
   if (AllRunningColumnFamiliesConsistent(running_ts_sz, record_ts_sz)) {
     return Status::OK();
@@ -318,7 +363,8 @@ Status HandleWriteBatchTimestampSizeDifference(
   } else if (need_recovery) {
     assert(new_batch);
     SequenceNumber sequence = WriteBatchInternal::Sequence(batch);
-    TimestampRecoveryHandler recovery_handler(running_ts_sz, record_ts_sz);
+    TimestampRecoveryHandler recovery_handler(running_ts_sz, record_ts_sz,
+                                              seq_per_batch, batch_per_txn);
     status = batch->Iterate(&recovery_handler);
     if (!status.ok()) {
       return status;

package/deps/rocksdb/rocksdb/util/udt_util.h

@@ -105,7 +105,8 @@ class UserDefinedTimestampSizeRecord {
 class TimestampRecoveryHandler : public WriteBatch::Handler {
  public:
   TimestampRecoveryHandler(const UnorderedMap<uint32_t, size_t>& running_ts_sz,
-                           const UnorderedMap<uint32_t, size_t>& record_ts_sz);
+                           const UnorderedMap<uint32_t, size_t>& record_ts_sz,
+                           bool seq_per_batch, bool batch_per_txn);
 
   ~TimestampRecoveryHandler() override {}
 
@@ -135,19 +136,18 @@ class TimestampRecoveryHandler : public WriteBatch::Handler {
   Status PutBlobIndexCF(uint32_t cf, const Slice& key,
                         const Slice& value) override;
 
-  Status MarkBeginPrepare(bool) override { return Status::OK(); }
+  Status MarkBeginPrepare(bool unprepare) override;
 
-  Status MarkEndPrepare(const Slice&) override { return Status::OK(); }
+  Status MarkEndPrepare(const Slice& name) override;
 
-  Status MarkCommit(const Slice&) override { return Status::OK(); }
+  Status MarkCommit(const Slice& name) override;
 
-  Status MarkCommitWithTimestamp(const Slice&, const Slice&) override {
-    return Status::OK();
-  }
+  Status MarkCommitWithTimestamp(const Slice& name,
+                                 const Slice& commit_ts) override;
 
-  Status MarkRollback(const Slice&) override { return Status::OK(); }
+  Status MarkRollback(const Slice& name) override;
 
-  Status MarkNoop(bool /*empty_batch*/) override { return Status::OK(); }
+  Status MarkNoop(bool empty_batch) override;
 
   std::unique_ptr<WriteBatch>&& TransferNewBatch() {
     assert(new_batch_diff_from_orig_batch_);
@@ -155,6 +155,16 @@ class TimestampRecoveryHandler : public WriteBatch::Handler {
     return std::move(new_batch_);
   }
 
+ protected:
+  Handler::OptionState WriteBeforePrepare() const override {
+    return write_before_prepare_ ? Handler::OptionState::kEnabled
+                                 : Handler::OptionState::kDisabled;
+  }
+  Handler::OptionState WriteAfterCommit() const override {
+    return write_after_commit_ ? Handler::OptionState::kEnabled
+                               : Handler::OptionState::kDisabled;
+  }
+
  private:
   Status ReconcileTimestampDiscrepancy(uint32_t cf, const Slice& key,
                                        std::string* new_key_buf,
@@ -168,6 +178,9 @@ class TimestampRecoveryHandler : public WriteBatch::Handler {
   // in the WAL. This only contains non-zero user-defined timestamp size.
   const UnorderedMap<uint32_t, size_t>& record_ts_sz_;
 
+  bool write_after_commit_;
+  bool write_before_prepare_;
+
   std::unique_ptr<WriteBatch> new_batch_;
   // Handler is valid upon creation and becomes invalid after its `new_batch_`
   // is transferred.
@@ -220,8 +233,8 @@ Status HandleWriteBatchTimestampSizeDifference(
     const WriteBatch* batch,
     const UnorderedMap<uint32_t, size_t>& running_ts_sz,
     const UnorderedMap<uint32_t, size_t>& record_ts_sz,
-    TimestampSizeConsistencyMode check_mode,
-    std::unique_ptr<WriteBatch>* new_batch = nullptr);
+    TimestampSizeConsistencyMode check_mode, bool seq_per_batch,
+    bool batch_per_txn, std::unique_ptr<WriteBatch>* new_batch = nullptr);
 
 // This util function is used when opening an existing column family and
 // processing its VersionEdit. It does a sanity check for the column family's

package/deps/rocksdb/rocksdb/util/udt_util_test.cc

@@ -226,11 +226,13 @@ TEST_F(HandleTimestampSizeDifferenceTest, AllColumnFamiliesConsistent) {
   // All `check_mode` pass with OK status and `batch` not checked or updated.
   ASSERT_OK(HandleWriteBatchTimestampSizeDifference(
       &batch, running_ts_sz, record_ts_sz,
-      TimestampSizeConsistencyMode::kVerifyConsistency));
+      TimestampSizeConsistencyMode::kVerifyConsistency,
+      /* seq_per_batch */ false, /* batch_per_txn */ true));
   std::unique_ptr<WriteBatch> new_batch(nullptr);
   ASSERT_OK(HandleWriteBatchTimestampSizeDifference(
       &batch, running_ts_sz, record_ts_sz,
-      TimestampSizeConsistencyMode::kReconcileInconsistency, &new_batch));
+      TimestampSizeConsistencyMode::kReconcileInconsistency,
+      /* seq_per_batch */ false, /* batch_per_txn */ true, &new_batch));
   ASSERT_TRUE(new_batch.get() == nullptr);
 }
 
@@ -245,11 +247,13 @@ TEST_F(HandleTimestampSizeDifferenceTest,
   // All `check_mode` pass with OK status and `batch` not checked or updated.
   ASSERT_OK(HandleWriteBatchTimestampSizeDifference(
       &batch, running_ts_sz, record_ts_sz,
-      TimestampSizeConsistencyMode::kVerifyConsistency));
+      TimestampSizeConsistencyMode::kVerifyConsistency,
+      /* seq_per_batch */ false, /* batch_per_txn */ true));
   std::unique_ptr<WriteBatch> new_batch(nullptr);
   ASSERT_OK(HandleWriteBatchTimestampSizeDifference(
       &batch, running_ts_sz, record_ts_sz,
-      TimestampSizeConsistencyMode::kReconcileInconsistency, &new_batch));
+      TimestampSizeConsistencyMode::kReconcileInconsistency,
+      /* seq_per_batch */ false, /* batch_per_txn */ true, &new_batch));
   ASSERT_TRUE(new_batch.get() == nullptr);
 }
 
@@ -263,11 +267,13 @@ TEST_F(HandleTimestampSizeDifferenceTest, InvolvedColumnFamiliesConsistent) {
   // All `check_mode` pass with OK status and `batch` not updated.
   ASSERT_OK(HandleWriteBatchTimestampSizeDifference(
       &batch, running_ts_sz, record_ts_sz,
-      TimestampSizeConsistencyMode::kVerifyConsistency));
+      TimestampSizeConsistencyMode::kVerifyConsistency,
+      /* seq_per_batch */ false, /* batch_per_txn */ true));
   std::unique_ptr<WriteBatch> new_batch(nullptr);
   ASSERT_OK(HandleWriteBatchTimestampSizeDifference(
       &batch, running_ts_sz, record_ts_sz,
-      TimestampSizeConsistencyMode::kReconcileInconsistency, &new_batch));
+      TimestampSizeConsistencyMode::kReconcileInconsistency,
+      /* seq_per_batch */ false, /* batch_per_txn */ true, &new_batch));
   ASSERT_TRUE(new_batch.get() == nullptr);
 }
 
@@ -282,13 +288,15 @@ TEST_F(HandleTimestampSizeDifferenceTest,
   // families.
   ASSERT_TRUE(HandleWriteBatchTimestampSizeDifference(
                   &batch, running_ts_sz, record_ts_sz,
-                  TimestampSizeConsistencyMode::kVerifyConsistency)
+                  TimestampSizeConsistencyMode::kVerifyConsistency,
+                  /* seq_per_batch */ false, /* batch_per_txn */ true)
                   .IsInvalidArgument());
 
   std::unique_ptr<WriteBatch> new_batch(nullptr);
   ASSERT_OK(HandleWriteBatchTimestampSizeDifference(
       &batch, running_ts_sz, record_ts_sz,
-      TimestampSizeConsistencyMode::kReconcileInconsistency, &new_batch));
+      TimestampSizeConsistencyMode::kReconcileInconsistency,
+      /* seq_per_batch */ false, /* batch_per_txn */ true, &new_batch));
   ASSERT_TRUE(new_batch.get() != nullptr);
   CheckContentsWithTimestampStripping(batch, *new_batch, sizeof(uint64_t),
                                       std::nullopt /* dropped_cf */);
@@ -307,13 +315,15 @@ TEST_F(HandleTimestampSizeDifferenceTest,
   // families.
   ASSERT_TRUE(HandleWriteBatchTimestampSizeDifference(
                   &batch, running_ts_sz, record_ts_sz,
-                  TimestampSizeConsistencyMode::kVerifyConsistency)
+                  TimestampSizeConsistencyMode::kVerifyConsistency,
+                  /* seq_per_batch */ false, /* batch_per_txn */ true)
                   .IsInvalidArgument());
 
   std::unique_ptr<WriteBatch> new_batch(nullptr);
   ASSERT_OK(HandleWriteBatchTimestampSizeDifference(
       &batch, running_ts_sz, record_ts_sz,
-      TimestampSizeConsistencyMode::kReconcileInconsistency, &new_batch));
+      TimestampSizeConsistencyMode::kReconcileInconsistency,
+      /* seq_per_batch */ false, /* batch_per_txn */ true, &new_batch));
   ASSERT_TRUE(new_batch.get() != nullptr);
   CheckContentsWithTimestampPadding(batch, *new_batch, sizeof(uint64_t));
 }
@@ -331,7 +341,8 @@ TEST_F(HandleTimestampSizeDifferenceTest,
   // and all related entries copied over to the new WriteBatch.
   ASSERT_OK(HandleWriteBatchTimestampSizeDifference(
       &batch, running_ts_sz, record_ts_sz,
-      TimestampSizeConsistencyMode::kReconcileInconsistency, &new_batch));
+      TimestampSizeConsistencyMode::kReconcileInconsistency,
+      /* seq_per_batch */ false, /* batch_per_txn */ true, &new_batch));
 
   ASSERT_TRUE(new_batch.get() != nullptr);
   CheckContentsWithTimestampStripping(batch, *new_batch, sizeof(uint64_t),
@@ -346,12 +357,14 @@ TEST_F(HandleTimestampSizeDifferenceTest, UnrecoverableInconsistency) {
 
   ASSERT_TRUE(HandleWriteBatchTimestampSizeDifference(
                   &batch, running_ts_sz, record_ts_sz,
-                  TimestampSizeConsistencyMode::kVerifyConsistency)
+                  TimestampSizeConsistencyMode::kVerifyConsistency,
+                  /* seq_per_batch */ false, /* batch_per_txn */ true)
                   .IsInvalidArgument());
 
   ASSERT_TRUE(HandleWriteBatchTimestampSizeDifference(
                   &batch, running_ts_sz, record_ts_sz,
-                  TimestampSizeConsistencyMode::kReconcileInconsistency)
+                  TimestampSizeConsistencyMode::kReconcileInconsistency,
+                  /* seq_per_batch */ false, /* batch_per_txn */ true)
                   .IsInvalidArgument());
 }
 

package/deps/rocksdb/rocksdb/utilities/memory/memory_test.cc

@@ -34,15 +34,6 @@ class MemoryTest : public testing::Test {
     }
   }
 
-  void GetCachePointersFromTableFactory(
-      const TableFactory* factory,
-      std::unordered_set<const Cache*>* cache_set) {
-    const auto bbto = factory->GetOptions<BlockBasedTableOptions>();
-    if (bbto != nullptr) {
-      cache_set->insert(bbto->block_cache.get());
-    }
-  }
-
   void GetCachePointers(const std::vector<DB*>& dbs,
                         std::unordered_set<const Cache*>* cache_set) {
     cache_set->clear();
@@ -61,13 +52,8 @@ class MemoryTest : public testing::Test {
       cache_set->insert(db->GetDBOptions().row_cache.get());
 
       // Cache from table factories
-      std::unordered_map<std::string, const ImmutableCFOptions*> iopts_map;
       if (db_impl != nullptr) {
-        ASSERT_OK(db_impl->TEST_GetAllImmutableCFOptions(&iopts_map));
-      }
-      for (const auto& pair : iopts_map) {
-        GetCachePointersFromTableFactory(pair.second->table_factory.get(),
-                                         cache_set);
+        db_impl->TEST_GetAllBlockCaches(cache_set);
       }
     }
   }
@@ -266,4 +252,3 @@ int main(int argc, char** argv) {
   return 0;
 #endif
 }
-

package/deps/rocksdb/rocksdb/utilities/options/options_util_test.cc

@@ -179,6 +179,8 @@ class DummyTableFactory : public TableFactory {
   }
 
   std::string GetPrintableOptions() const override { return ""; }
+
+  std::unique_ptr<TableFactory> Clone() const override { return nullptr; }
 };
 
 class DummyMergeOperator : public MergeOperator {

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

@@ -0,0 +1,214 @@
+//  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).
+
+#include "utilities/secondary_index/faiss_ivf_index.h"
+
+#include <cassert>
+
+#include "faiss/invlists/InvertedLists.h"
+#include "util/coding.h"
+
+namespace ROCKSDB_NAMESPACE {
+
+class FaissIVFIndex::Adapter : public faiss::InvertedLists {
+ public:
+  Adapter(size_t num_lists, size_t code_size)
+      : faiss::InvertedLists(num_lists, code_size) {
+    use_iterator = true;
+  }
+
+  // Non-iterator-based read interface; not implemented/used since use_iterator
+  // is true
+  size_t list_size(size_t /* list_no */) const override {
+    assert(false);
+    return 0;
+  }
+
+  const uint8_t* get_codes(size_t /* list_no */) const override {
+    assert(false);
+    return nullptr;
+  }
+
+  const faiss::idx_t* get_ids(size_t /* list_no */) const override {
+    assert(false);
+    return nullptr;
+  }
+
+  // Iterator-based read interface; not yet implemented
+  faiss::InvertedListsIterator* get_iterator(
+      size_t /* list_no */,
+      void* /* inverted_list_context */ = nullptr) const override {
+    // TODO: implement this
+
+    assert(false);
+    return nullptr;
+  }
+
+  // Write interface; only add_entry is implemented/required for now
+  size_t add_entry(size_t /* list_no */, faiss::idx_t /* id */,
+                   const uint8_t* code,
+                   void* inverted_list_context = nullptr) override {
+    std::string* const code_str =
+        static_cast<std::string*>(inverted_list_context);
+    assert(code_str);
+
+    code_str->assign(reinterpret_cast<const char*>(code), code_size);
+
+    return 0;
+  }
+
+  size_t add_entries(size_t /* list_no */, size_t /* num_entries */,
+                     const faiss::idx_t* /* ids */,
+                     const uint8_t* /* code */) override {
+    assert(false);
+    return 0;
+  }
+
+  void update_entry(size_t /* list_no */, size_t /* offset */,
+                    faiss::idx_t /* id */, const uint8_t* /* code */) override {
+    assert(false);
+  }
+
+  void update_entries(size_t /* list_no */, size_t /* offset */,
+                      size_t /* num_entries */, const faiss::idx_t* /* ids */,
+                      const uint8_t* /* code */) override {
+    assert(false);
+  }
+
+  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;
+}
+
+FaissIVFIndex::FaissIVFIndex(std::unique_ptr<faiss::IndexIVF>&& index,
+                             std::string primary_column_name)
+    : adapter_(std::make_unique<Adapter>(index->nlist, index->code_size)),
+      index_(std::move(index)),
+      primary_column_name_(std::move(primary_column_name)) {
+  assert(index_);
+  assert(index_->quantizer);
+
+  index_->replace_invlists(adapter_.get());
+}
+
+FaissIVFIndex::~FaissIVFIndex() = default;
+
+void FaissIVFIndex::SetPrimaryColumnFamily(ColumnFamilyHandle* column_family) {
+  assert(column_family);
+  primary_column_family_ = column_family;
+}
+
+void FaissIVFIndex::SetSecondaryColumnFamily(
+    ColumnFamilyHandle* column_family) {
+  assert(column_family);
+  secondary_column_family_ = column_family;
+}
+
+ColumnFamilyHandle* FaissIVFIndex::GetPrimaryColumnFamily() const {
+  return primary_column_family_;
+}
+
+ColumnFamilyHandle* FaissIVFIndex::GetSecondaryColumnFamily() const {
+  return secondary_column_family_;
+}
+
+Slice FaissIVFIndex::GetPrimaryColumnName() const {
+  return primary_column_name_;
+}
+
+Status FaissIVFIndex::UpdatePrimaryColumnValue(
+    const Slice& /* primary_key */, const Slice& primary_column_value,
+    std::optional<std::variant<Slice, std::string>>* updated_column_value)
+    const {
+  assert(updated_column_value);
+
+  if (primary_column_value.size() != index_->d * sizeof(float)) {
+    return Status::InvalidArgument(
+        "Incorrectly sized vector passed to FaissIVFIndex");
+  }
+
+  constexpr faiss::idx_t n = 1;
+  faiss::idx_t label = -1;
+
+  try {
+    index_->quantizer->assign(
+        n, reinterpret_cast<const float*>(primary_column_value.data()), &label);
+  } catch (const std::exception& e) {
+    return Status::InvalidArgument(e.what());
+  }
+
+  if (label < 0 || label >= index_->nlist) {
+    return Status::InvalidArgument(
+        "Unexpected label returned by coarse quantizer");
+  }
+
+  updated_column_value->emplace(SerializeLabel(label));
+
+  return Status::OK();
+}
+
+Status FaissIVFIndex::GetSecondaryKeyPrefix(
+    const Slice& /* primary_key */, const Slice& primary_column_value,
+    std::variant<Slice, std::string>* secondary_key_prefix) const {
+  assert(secondary_key_prefix);
+
+  [[maybe_unused]] const faiss::idx_t label =
+      DeserializeLabel(primary_column_value);
+  assert(label >= 0);
+  assert(label < index_->nlist);
+
+  *secondary_key_prefix = primary_column_value;
+
+  return Status::OK();
+}
+
+Status FaissIVFIndex::GetSecondaryValue(
+    const Slice& /* primary_key */, const Slice& primary_column_value,
+    const Slice& original_column_value,
+    std::optional<std::variant<Slice, std::string>>* secondary_value) const {
+  assert(secondary_value);
+
+  const faiss::idx_t label = DeserializeLabel(primary_column_value);
+  assert(label >= 0);
+  assert(label < index_->nlist);
+
+  constexpr faiss::idx_t n = 1;
+  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);
+  } catch (const std::exception& e) {
+    return Status::InvalidArgument(e.what());
+  }
+
+  if (code_str.size() != index_->code_size) {
+    return Status::InvalidArgument(
+        "Unexpected code returned by fine quantizer");
+  }
+
+  secondary_value->emplace(std::move(code_str));
+
+  return Status::OK();
+}
+
+}  // namespace ROCKSDB_NAMESPACE

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

@@ -0,0 +1,60 @@
+//  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 <memory>
+#include <string>
+
+#include "faiss/IndexIVF.h"
+#include "rocksdb/utilities/secondary_index.h"
+
+namespace ROCKSDB_NAMESPACE {
+
+// A SecondaryIndex implementation that wraps a FAISS inverted file index.
+class FaissIVFIndex : public SecondaryIndex {
+ public:
+  explicit FaissIVFIndex(std::unique_ptr<faiss::IndexIVF>&& index,
+                         std::string primary_column_name);
+  ~FaissIVFIndex() override;
+
+  void SetPrimaryColumnFamily(ColumnFamilyHandle* column_family) override;
+  void SetSecondaryColumnFamily(ColumnFamilyHandle* column_family) override;
+
+  ColumnFamilyHandle* GetPrimaryColumnFamily() const override;
+  ColumnFamilyHandle* GetSecondaryColumnFamily() const override;
+
+  Slice GetPrimaryColumnName() const override;
+
+  Status UpdatePrimaryColumnValue(
+      const Slice& primary_key, const Slice& primary_column_value,
+      std::optional<std::variant<Slice, std::string>>* updated_column_value)
+      const override;
+
+  Status GetSecondaryKeyPrefix(
+      const Slice& primary_key, const Slice& primary_column_value,
+      std::variant<Slice, std::string>* secondary_key_prefix) const override;
+
+  Status GetSecondaryValue(const Slice& primary_key,
+                           const Slice& primary_column_value,
+                           const Slice& original_column_value,
+                           std::optional<std::variant<Slice, std::string>>*
+                               secondary_value) const override;
+
+ private:
+  class Adapter;
+
+  static std::string SerializeLabel(faiss::idx_t label);
+  static faiss::idx_t DeserializeLabel(Slice label_slice);
+
+  std::unique_ptr<Adapter> adapter_;
+  std::unique_ptr<faiss::IndexIVF> index_;
+  std::string primary_column_name_;
+  ColumnFamilyHandle* primary_column_family_{};
+  ColumnFamilyHandle* secondary_column_family_{};
+};
+
+}  // namespace ROCKSDB_NAMESPACE