@nxtedition/rocksdb 13.5.8 → 13.5.9

package/deps/rocksdb/rocksdb/include/rocksdb/utilities/debug.h

@@ -5,7 +5,6 @@
 
 #pragma once
 
-
 #include "rocksdb/db.h"
 #include "rocksdb/types.h"
 
@@ -34,13 +33,12 @@ struct KeyVersion {
 // copied to memory, if the range covers too many keys, the memory usage
 // may be huge. `max_num_ikeys` can be used to cap the memory usage.
 // The result is inserted into the provided vector, `key_versions`.
-Status GetAllKeyVersions(DB* db, Slice begin_key, Slice end_key,
+Status GetAllKeyVersions(DB* db, OptSlice begin_key, OptSlice end_key,
                          size_t max_num_ikeys,
                          std::vector<KeyVersion>* key_versions);
 
-Status GetAllKeyVersions(DB* db, ColumnFamilyHandle* cfh, Slice begin_key,
-                         Slice end_key, size_t max_num_ikeys,
+Status GetAllKeyVersions(DB* db, ColumnFamilyHandle* cfh, OptSlice begin_key,
+                         OptSlice end_key, size_t max_num_ikeys,
                          std::vector<KeyVersion>* key_versions);
 
 }  // namespace ROCKSDB_NAMESPACE
-

package/deps/rocksdb/rocksdb/include/rocksdb/utilities/env_mirror.h

@@ -18,7 +18,6 @@
 
 #pragma once
 
-
 #include <algorithm>
 #include <iostream>
 #include <vector>
@@ -176,4 +175,3 @@ class EnvMirror : public EnvWrapper {
 };
 
 }  // namespace ROCKSDB_NAMESPACE
-

package/deps/rocksdb/rocksdb/include/rocksdb/utilities/ldb_cmd.h

@@ -5,7 +5,6 @@
 //
 #pragma once
 
-
 #include <stdio.h>
 #include <stdlib.h>
 
@@ -331,7 +330,7 @@ class LDBCommandRunner {
 
   // Returns the status code to return. 0 is no error.
   static int RunCommand(
-      int argc, char const* const* argv, Options options,
+      int argc, char const* const* argv, const Options& options,
       const LDBOptions& ldb_options,
       const std::vector<ColumnFamilyDescriptor>* column_families);
 };

package/deps/rocksdb/rocksdb/include/rocksdb/utilities/memory_util.h

@@ -3,7 +3,6 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
 
-
 #pragma once
 
 #include <map>

package/deps/rocksdb/rocksdb/include/rocksdb/utilities/object_registry.h

@@ -5,7 +5,6 @@
 
 #pragma once
 
-
 #include <functional>
 #include <map>
 #include <memory>
@@ -163,7 +162,7 @@ class ObjectLibrary {
     size_t slength_;  // The minimum required length to match the separators
     std::vector<std::pair<std::string, Quantifier>>
         separators_;  // What to match
-  };                  // End class Entry
+  };  // End class Entry
 
  private:
   // An Entry containing a FactoryFunc for creating new Objects

package/deps/rocksdb/rocksdb/include/rocksdb/utilities/options_util.h

@@ -6,7 +6,6 @@
 // This file contains utility functions for RocksDB Options.
 #pragma once
 
-
 #include <string>
 #include <vector>
 

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

@@ -6,10 +6,12 @@
 
 #pragma once
 
+#include <memory>
 #include <optional>
 #include <string>
 #include <variant>
 
+#include "rocksdb/iterator.h"
 #include "rocksdb/rocksdb_namespace.h"
 #include "rocksdb/slice.h"
 #include "rocksdb/status.h"
@@ -18,10 +20,8 @@ namespace ROCKSDB_NAMESPACE {
 
 class ColumnFamilyHandle;
 
-//       / \     UNDER CONSTRUCTION
-//      / ! \    UNDER CONSTRUCTION
-//     /-----\   UNDER CONSTRUCTION
-
+// EXPERIMENTAL
+//
 // A secondary index is an additional data structure built over a set of primary
 // key-values that enables efficiently querying key-values by value instead of
 // key. Both plain and wide-column key-values can be indexed, the latter on a
@@ -49,6 +49,7 @@ class ColumnFamilyHandle;
 // Note: the methods of SecondaryIndex implementations are expected to be
 // thread-safe with the exception of Set{Primary,Secondary}ColumnFamily (which
 // are not expected to be called after initialization).
+
 class SecondaryIndex {
  public:
   virtual ~SecondaryIndex() = default;
@@ -77,14 +78,24 @@ class SecondaryIndex {
   // called by the transaction layer when adding or removing secondary index
   // entries (which have the form <secondary_key_prefix><primary_key> ->
   // <secondary_value>) and should be deterministic. The output parameter
-  // secondary_key_prefix is expected to be based on primary_column_value,
-  // potentially with some additional metadata to prevent ambiguities (e.g.
-  // index id or length indicator). Returning a non-OK status rolls back all
-  // operations in the transaction related to this primary key-value.
+  // secondary_key_prefix is expected to be based on primary_key and/or
+  // primary_column_value. Returning a non-OK status rolls back all operations
+  // in the transaction related to this primary key-value.
   virtual Status GetSecondaryKeyPrefix(
       const Slice& primary_key, const Slice& primary_column_value,
       std::variant<Slice, std::string>* secondary_key_prefix) const = 0;
 
+  // Finalize the secondary key prefix, for instance by adding some metadata to
+  // prevent ambiguities (e.g. index id or length indicator). This method is
+  // called by the transaction layer when adding or removing secondary index
+  // entries (which have the form <secondary_key_prefix><primary_key> ->
+  // <secondary_value>) and also when querying the index (in which case it is
+  // called with the search target). The method should be deterministic.
+  // Returning a non-OK status rolls back all operations in the transaction
+  // related to this primary key-value.
+  virtual Status FinalizeSecondaryKeyPrefix(
+      std::variant<Slice, std::string>* secondary_key_prefix) const = 0;
+
   // Get the optional secondary value for a given primary key-value. This method
   // is called by the transaction layer when adding secondary index
   // entries (which have the form <secondary_key_prefix><primary_key> ->
@@ -99,4 +110,81 @@ class SecondaryIndex {
       const = 0;
 };
 
+// SecondaryIndexIterator can be used to find the primary keys for a given
+// search target. It can be used as-is or as a building block. Its interface
+// mirrors most of the Iterator API, with the exception of SeekToFirst,
+// SeekToLast, and SeekForPrev, which are not applicable to secondary indices
+// and thus not present. Querying the index can be performed by calling the
+// returned iterator's Seek API with a search target, and then using Next (and
+// potentially Prev) to iterate through the matching index entries. The iterator
+// exposes primary keys, that is, the secondary key prefix is stripped from the
+// index entries.
+
+class SecondaryIndexIterator {
+ public:
+  // Constructs a SecondaryIndexIterator. The SecondaryIndexIterator takes
+  // ownership of the underlying iterator.
+  // PRE: index is not nullptr
+  // PRE: underlying_it is not nullptr and points to an iterator over the
+  // index's secondary column family
+  SecondaryIndexIterator(const SecondaryIndex* index,
+                         std::unique_ptr<Iterator>&& underlying_it);
+
+  // Returns whether the iterator is valid, i.e. whether it is positioned on a
+  // secondary index entry matching the search target.
+  bool Valid() const;
+
+  // Returns the status of the iterator, which is guaranteed to be OK if the
+  // iterator is valid. Otherwise, it might be non-OK, which indicates an error,
+  // or OK, which means that the iterator has reached the end of the applicable
+  // secondary index entries.
+  Status status() const;
+
+  // Query the index with the given search target.
+  void Seek(const Slice& target);
+
+  // Move the iterator to the next entry.
+  // PRE: Valid()
+  void Next();
+
+  // Move the iterator back to the previous entry.
+  // PRE: Valid()
+  void Prev();
+
+  // Prepare the value of the current entry. Should be called before calling
+  // value() or columns() if the underlying iterator was constructed with the
+  // read option allow_unprepared_value set to true. Returns true upon success.
+  // Returns false and sets the status to non-OK upon failure.
+  // PRE: Valid()
+  bool PrepareValue();
+
+  // Returns the primary key from the current secondary index entry.
+  // PRE: Valid()
+  Slice key() const;
+
+  // Returns the value of the current secondary index entry.
+  // PRE: Valid()
+  Slice value() const;
+
+  // Returns the value of the current secondary index entry as a wide-column
+  // structure.
+  // PRE: Valid()
+  const WideColumns& columns() const;
+
+  // Returns the timestamp of the current secondary index entry.
+  // PRE: Valid()
+  Slice timestamp() const;
+
+  // Queries the given property of the underlying iterator. Returns OK on
+  // success, non-OK on failure.
+  // PRE: Valid()
+  Status GetProperty(std::string prop_name, std::string* prop) const;
+
+ private:
+  const SecondaryIndex* index_;
+  std::unique_ptr<Iterator> underlying_it_;
+  Status status_;
+  std::string prefix_;
+};
+
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/include/rocksdb/utilities/secondary_index_faiss.h

@@ -0,0 +1,117 @@
+//  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 <utility>
+#include <vector>
+
+#include "rocksdb/rocksdb_namespace.h"
+#include "rocksdb/slice.h"
+#include "rocksdb/utilities/secondary_index.h"
+
+namespace faiss {
+struct IndexIVF;
+}
+
+namespace ROCKSDB_NAMESPACE {
+
+// EXPERIMENTAL
+//
+// A SecondaryIndex implementation that wraps a FAISS inverted file based index.
+// Indexes the embedding in the specified primary column using the given
+// pre-trained faiss::IndexIVF object. Can be used to perform
+// K-nearest-neighbors queries.
+
+class FaissIVFIndex : public SecondaryIndex {
+ public:
+  // Constructs a FaissIVFIndex object. Takes ownership of the given
+  // faiss::IndexIVF instance.
+  // PRE: index is not nullptr
+  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 FinalizeSecondaryKeyPrefix(
+      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;
+
+  // Performs a K-nearest-neighbors vector similarity search for the target
+  // using the given secondary index iterator, where K is given by the parameter
+  // neighbors and the number of inverted lists to search is given by the
+  // parameter probes. The resulting primary keys and distances are returned in
+  // the result output parameter. Note that the search may return less than the
+  // requested number of results if the inverted lists probed are exhausted
+  // before finding K items.
+  //
+  // The parameter it should be non-nullptr and point to a secondary index
+  // iterator corresponding to this index. The search target should be of the
+  // correct dimension (i.e. target.size() == dim * sizeof(float), where dim is
+  // the dimensionality of the index), neighbors and probes should be positive,
+  // and result should be non-nullptr.
+  //
+  // Returns OK on success, InvalidArgument if the preconditions above are not
+  // met, or some other non-OK status if there is an error during the search.
+  Status FindKNearestNeighbors(
+      SecondaryIndexIterator* it, const Slice& target, size_t neighbors,
+      size_t probes, std::vector<std::pair<std::string, float>>* result) const;
+
+ private:
+  struct KNNContext;
+  class Adapter;
+
+  std::unique_ptr<Adapter> adapter_;
+  std::unique_ptr<faiss::IndexIVF> index_;
+  std::string primary_column_name_;
+  ColumnFamilyHandle* primary_column_family_{};
+  ColumnFamilyHandle* secondary_column_family_{};
+};
+
+// Helper methods to convert embeddings from a span of floats to Slice or vice
+// versa
+
+// Convert the given span of floats of size dim to a Slice.
+// PRE: embedding points to a contiguous span of floats of size dim
+inline Slice ConvertFloatsToSlice(const float* embedding, size_t dim) {
+  return Slice(reinterpret_cast<const char*>(embedding), dim * sizeof(float));
+}
+
+// Convert the given Slice to a span of floats of size dim.
+// PRE: embedding.size() == dim * sizeof(float)
+// Returns nullptr if the precondition is violated.
+inline const float* ConvertSliceToFloats(const Slice& embedding, size_t dim) {
+  if (embedding.size() != dim * sizeof(float)) {
+    return nullptr;
+  }
+
+  return reinterpret_cast<const float*>(embedding.data());
+}
+
+}  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/{utilities/secondary_index/faiss_ivf_index.h → include/rocksdb/utilities/secondary_index_simple.h}

@@ -6,20 +6,21 @@
 
 #pragma once
 
-#include <memory>
 #include <string>
 
-#include "faiss/IndexIVF.h"
+#include "rocksdb/rocksdb_namespace.h"
 #include "rocksdb/utilities/secondary_index.h"
 
 namespace ROCKSDB_NAMESPACE {
 
-// A SecondaryIndex implementation that wraps a FAISS inverted file index.
-class FaissIVFIndex : public SecondaryIndex {
+// EXPERIMENTAL
+//
+// A simple secondary index implementation that indexes the specified column
+// as-is.
+
+class SimpleSecondaryIndex : public SecondaryIndex {
  public:
-  explicit FaissIVFIndex(std::unique_ptr<faiss::IndexIVF>&& index,
-                         std::string primary_column_name);
-  ~FaissIVFIndex() override;
+  explicit SimpleSecondaryIndex(std::string primary_column_name);
 
   void SetPrimaryColumnFamily(ColumnFamilyHandle* column_family) override;
   void SetSecondaryColumnFamily(ColumnFamilyHandle* column_family) override;
@@ -38,6 +39,9 @@ class FaissIVFIndex : public SecondaryIndex {
       const Slice& primary_key, const Slice& primary_column_value,
       std::variant<Slice, std::string>* secondary_key_prefix) const override;
 
+  Status FinalizeSecondaryKeyPrefix(
+      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,
@@ -45,13 +49,6 @@ class FaissIVFIndex : public SecondaryIndex {
                                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_{};

package/deps/rocksdb/rocksdb/include/rocksdb/utilities/stackable_db.h

@@ -27,6 +27,10 @@ class StackableDB : public DB {
   explicit StackableDB(std::shared_ptr<DB> db)
       : db_(db.get()), shared_db_ptr_(db) {}
 
+  // StackableDB take sole ownership of the underlying db.
+  explicit StackableDB(std::unique_ptr<DB>&& db)
+      : db_(db.get()), shared_db_ptr_(std::move(db)) {}
+
   ~StackableDB() override {
     if (shared_db_ptr_ == nullptr) {
       delete db_;
@@ -285,6 +289,13 @@ class StackableDB : public DB {
     return db_->NewAttributeGroupIterator(options, column_families);
   }
 
+  using DB::NewMultiScan;
+  std::unique_ptr<MultiScan> NewMultiScan(
+      const ReadOptions& opts, ColumnFamilyHandle* column_family,
+      const std::vector<ScanOptions>& scan_opts) override {
+    return db_->NewMultiScan(opts, column_family, scan_opts);
+  }
+
   const Snapshot* GetSnapshot() override { return db_->GetSnapshot(); }
 
   void ReleaseSnapshot(const Snapshot* snapshot) override {
@@ -501,28 +512,24 @@ class StackableDB : public DB {
     return db_->GetFullHistoryTsLow(column_family, ts_low);
   }
 
+  Status GetNewestUserDefinedTimestamp(ColumnFamilyHandle* column_family,
+                                       std::string* newest_timestamp) override {
+    return db_->GetNewestUserDefinedTimestamp(column_family, newest_timestamp);
+  }
+
   Status GetSortedWalFiles(VectorWalPtr& files) override {
     return db_->GetSortedWalFiles(files);
   }
 
   Status GetCurrentWalFile(
-      std::unique_ptr<WalFile>* current_log_file) override {
-    return db_->GetCurrentWalFile(current_log_file);
+      std::unique_ptr<WalFile>* current_wal_file) override {
+    return db_->GetCurrentWalFile(current_wal_file);
   }
 
   Status GetCreationTimeOfOldestFile(uint64_t* creation_time) override {
     return db_->GetCreationTimeOfOldestFile(creation_time);
   }
 
-  // WARNING: This API is planned for removal in RocksDB 7.0 since it does not
-  // operate at the proper level of abstraction for a key-value store, and its
-  // contract/restrictions are poorly documented. For example, it returns non-OK
-  // `Status` for non-bottommost files and files undergoing compaction. Since we
-  // do not plan to maintain it, the contract will likely remain underspecified
-  // until its removal. Any user is encouraged to read the implementation
-  // carefully and migrate away from it when possible.
-  Status DeleteFile(std::string name) override { return db_->DeleteFile(name); }
-
   Status GetDbIdentity(std::string& identity) const override {
     return db_->GetDbIdentity(identity);
   }
@@ -559,6 +566,14 @@ class StackableDB : public DB {
     return db_->GetPropertiesOfTablesInRange(column_family, range, n, props);
   }
 
+  using DB::GetPropertiesOfTablesByLevel;
+  Status GetPropertiesOfTablesByLevel(
+      ColumnFamilyHandle* column_family,
+      std::vector<std::unique_ptr<TablePropertiesCollection>>* props_by_level)
+      override {
+    return db_->GetPropertiesOfTablesByLevel(column_family, props_by_level);
+  }
+
   Status GetUpdatesSince(
       SequenceNumber seq_number, std::unique_ptr<TransactionLogIterator>* iter,
       const TransactionLogIterator::ReadOptions& read_options) override {

package/deps/rocksdb/rocksdb/include/rocksdb/utilities/table_properties_collectors.h

@@ -23,15 +23,20 @@ class CompactOnDeletionCollectorFactory
   // A factory of a table property collector that marks a SST
   // file as need-compaction when it observe at least "D" deletion
   // entries in any "N" consecutive entries, or the ratio of tombstone
-  // entries >= deletion_ratio.
+  // entries >= deletion_ratio for the entire file.
   //
   // @param sliding_window_size "N"
   // @param deletion_trigger "D"
   // @param deletion_ratio, if <= 0 or > 1, disable triggering compaction
   //     based on deletion ratio.
+  // @param min_file_size, a file needs to be at least this size to be marked
+  //     for compaction. See comments above
+  //     TablePropertiesCollector::AddUserKey() for limitations/inaccuracies on
+  //     the file size.
   CompactOnDeletionCollectorFactory(size_t sliding_window_size,
                                     size_t deletion_trigger,
-                                    double deletion_ratio);
+                                    double deletion_ratio,
+                                    uint64_t min_file_size = 0);
 
   ~CompactOnDeletionCollectorFactory() override {}
 
@@ -59,6 +64,12 @@ class CompactOnDeletionCollectorFactory
   }
 
   double GetDeletionRatio() const { return deletion_ratio_.load(); }
+
+  uint64_t GetMinFileSize() const { return min_file_size_.load(); }
+  void SetMinFileSize(uint64_t min_file_size) {
+    min_file_size_.store(min_file_size);
+  }
+
   static const char* kClassName() { return "CompactOnDeletionCollector"; }
   const char* Name() const override { return kClassName(); }
 
@@ -68,6 +79,7 @@ class CompactOnDeletionCollectorFactory
   std::atomic<size_t> sliding_window_size_;
   std::atomic<size_t> deletion_trigger_;
   std::atomic<double> deletion_ratio_;
+  std::atomic<uint64_t> min_file_size_;
 };
 
 // Creates a factory of a table property collector that marks a SST
@@ -85,7 +97,8 @@ class CompactOnDeletionCollectorFactory
 std::shared_ptr<CompactOnDeletionCollectorFactory>
 NewCompactOnDeletionCollectorFactory(size_t sliding_window_size,
                                      size_t deletion_trigger,
-                                     double deletion_ratio = 0);
+                                     double deletion_ratio = 0,
+                                     uint64_t min_file_size = 0);
 
 // A factory of a table property collector that marks a SST file as
 // need-compaction when for the tiering use case, it observes, among all the

package/deps/rocksdb/rocksdb/include/rocksdb/utilities/transaction.h

@@ -750,8 +750,6 @@ class Transaction {
 
   virtual TxnTimestamp GetCommitTimestamp() const { return kMaxTxnTimestamp; }
 
-  virtual bool GetCommitBypassMemTable() const { return false; }
-
  protected:
   explicit Transaction(const TransactionDB* /*db*/) {}
   Transaction() : log_number_(0), txn_state_(STARTED) {}

package/deps/rocksdb/rocksdb/include/rocksdb/utilities/transaction_db.h

@@ -24,9 +24,16 @@ class SecondaryIndex;
 class TransactionDBMutexFactory;
 
 enum TxnDBWritePolicy {
-  WRITE_COMMITTED = 0,  // write only the committed data
-  WRITE_PREPARED,       // write data after the prepare phase of 2pc
-  WRITE_UNPREPARED      // write data before the prepare phase of 2pc
+  // Write data at transaction commit time
+  WRITE_COMMITTED = 0,
+
+  // EXPERIMENTAL: The remaining write policies are not as mature, well
+  // validated, nor as compatible with other features as WRITE_COMMITTED.
+
+  // Write data after the prepare phase of 2pc
+  WRITE_PREPARED,
+  // Write data before the prepare phase of 2pc
+  WRITE_UNPREPARED
 };
 
 constexpr uint32_t kInitialMaxDeadlocks = 5;
@@ -241,14 +248,24 @@ struct TransactionDBOptions {
   // user-defined timestamps so this option only applies in this case.
   bool enable_udt_validation = true;
 
-  //       / \     UNDER CONSTRUCTION
-  //      / ! \    UNDER CONSTRUCTION
-  //     /-----\   UNDER CONSTRUCTION
+  // EXPERIMENTAL
   //
   // The secondary indices to be maintained. See the SecondaryIndex interface
   // for more details.
   std::vector<std::shared_ptr<SecondaryIndex>> secondary_indices;
 
+  // Deprecated, this option has no effect and may be removed in the future.
+  // Use TransactionOptions::large_txn_commit_optimize_threshold instead.
+  //
+  // This option is only valid for write committed. If the number of updates in
+  // a transaction is at least this threshold, then the transaction commit will
+  // skip insertions into memtable as an optimization to reduce commit latency.
+  // See comment for TransactionOptions::commit_bypass_memtable for more detail.
+  // Setting TransactionOptions::commit_bypass_memtable to true takes precedence
+  // over this option.
+  uint32_t txn_commit_bypass_memtable_threshold =
+      std::numeric_limits<uint32_t>::max();
+
  private:
   // 128 entries
   // Should the default value change, please also update wp_snapshot_cache_bits
@@ -349,10 +366,28 @@ struct TransactionOptions {
   // DeleteRange, SingleDelete.
   bool write_batch_track_timestamp_size = false;
 
-  // EXPERIMENTAL
+  // The following three options enable optimizations for large transaction
+  // commit to bypass memtable write.
+  // - If any transaction's commit should bybass memtable write,
+  //  set commit_bypass_memtable to true.
+  // - If only bypass memtable write for transactions with >= n operations,
+  //  set commit_bypass_memtable to false,
+  //  large_txn_commit_optimize_threshold to n, and
+  //  large_txn_commit_optimize_byte_threshold to 0.
+  //  Similarly for only optimize when a transaction's write batch size is >= n.
+  // - If bypass memtable write for transactions with >= n operations or >= x
+  // bytes,
+  //  set commit_bypass_memtable to false,
+  //  large_txn_commit_optimize_threshold to n, and
+  //  large_txn_commit_optimize_byte_threshold to x.
+  //
+  //
+  // EXPERIMENTAL, SUBJECT TO CHANGE
   // Only supports write-committed policy. If set to true, the transaction will
   // skip memtable write and ingest into the DB directly during Commit(). This
   // makes Commit() much faster for transactions with many operations.
+  // Transaction neeeds to call Prepare() before Commit() for this option to
+  // take effect.
   // Transactions with Merge() or PutEntity() is not supported yet.
   //
   // Note that the transaction will be ingested as an immutable memtable for
@@ -364,7 +399,28 @@ struct TransactionOptions {
   // without indexing (e.g. added directly to the transaction underlying
   // write batch through Transaction::GetWriteBatch()->GetWriteBatch())
   // are not supported. They will not be applied to the DB.
+  //
+  // NOTE: since WBWI keep track of the most recent update per key, a Put
+  // followed by a SingleDelete will be written to DB as a SingleDelete. This
+  // can cause flush/compaction to report `num_single_del_mismatch` due to
+  // consecutive SingleDeletes.
   bool commit_bypass_memtable = false;
+
+  // EXPERIMENTAL, SUBJECT TO CHANGE
+  // When the number of updates in a transaction is at least this threshold,
+  // we will enable optimizations for commiting a large transaction. See
+  // comment for `commit_bypass_memtable` for more optimization detail.
+  //
+  // Default: 0 (disabled).
+  uint32_t large_txn_commit_optimize_threshold = 0;
+
+  // EXPERIMENTAL, SUBJECT TO CHANGE
+  // When the size of a transaction's write batch is at least this threshold,
+  // we will enable optimizations for commiting a large transaction. See
+  // comment for `commit_bypass_memtable` for more optimization detail.
+  //
+  // Default: 0 (disabled).
+  uint64_t large_txn_commit_optimize_byte_threshold = 0;
 };
 
 // The per-write optimizations that do not involve transactions. TransactionDB

package/deps/rocksdb/rocksdb/include/rocksdb/utilities/transaction_db_mutex.h

@@ -86,4 +86,3 @@ class TransactionDBMutexFactory {
 };
 
 }  // namespace ROCKSDB_NAMESPACE
-