@nxtedition/rocksdb 13.1.5 → 13.2.0

package/deps/rocksdb/rocksdb/include/rocksdb/thread_status.h

@@ -64,6 +64,7 @@ struct ThreadStatus {
     OP_VERIFY_FILE_CHECKSUMS,
     OP_GETENTITY,
     OP_MULTIGETENTITY,
+    OP_READ_MANIFEST,
     NUM_OP_TYPES
   };
 

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

@@ -58,6 +58,7 @@ enum class OptionType {
   kEncodedString,
   kTemperature,
   kArray,
+  kStringMap,  // Map of <std::string, std::string>
   kUnknown,
 };
 
@@ -241,42 +242,13 @@ using ValidateFunc = std::function<Status(
 // option type, and offset.
 class OptionTypeInfo {
  public:
-  // A simple "normal", non-mutable Type "type" at offset
-  OptionTypeInfo(int offset, OptionType type)
-      : offset_(offset),
-        parse_func_(nullptr),
-        serialize_func_(nullptr),
-        equals_func_(nullptr),
-        type_(type),
-        verification_(OptionVerificationType::kNormal),
-        flags_(OptionTypeFlags::kNone) {}
-
-  OptionTypeInfo(int offset, OptionType type,
-                 OptionVerificationType verification, OptionTypeFlags flags)
-      : offset_(offset),
-        parse_func_(nullptr),
-        serialize_func_(nullptr),
-        equals_func_(nullptr),
-        type_(type),
-        verification_(verification),
-        flags_(flags) {}
-
-  OptionTypeInfo(int offset, OptionType type,
-                 OptionVerificationType verification, OptionTypeFlags flags,
-                 const ParseFunc& parse_func)
-      : offset_(offset),
-        parse_func_(parse_func),
-        serialize_func_(nullptr),
-        equals_func_(nullptr),
-        type_(type),
-        verification_(verification),
-        flags_(flags) {}
-
-  OptionTypeInfo(int offset, OptionType type,
-                 OptionVerificationType verification, OptionTypeFlags flags,
-                 const ParseFunc& parse_func,
-                 const SerializeFunc& serialize_func,
-                 const EqualsFunc& equals_func)
+  OptionTypeInfo(
+      int offset, OptionType type,
+      OptionVerificationType verification = OptionVerificationType::kNormal,
+      OptionTypeFlags flags = OptionTypeFlags::kNone,
+      const ParseFunc& parse_func = {},
+      const SerializeFunc& serialize_func = {},
+      const EqualsFunc& equals_func = {})
       : offset_(offset),
         parse_func_(parse_func),
         serialize_func_(serialize_func),
@@ -470,24 +442,80 @@ class OptionTypeInfo {
     return info;
   }
 
+  static OptionTypeInfo StringMap(int _offset,
+                                  OptionVerificationType _verification,
+                                  OptionTypeFlags _flags,
+                                  char kv_separator = '=',
+                                  char item_separator = ';') {
+    OptionTypeInfo info(_offset, OptionType::kStringMap, _verification, _flags);
+    info.SetParseFunc(
+        [kv_separator, item_separator](const ConfigOptions&, const std::string&,
+                                       const std::string& value, void* addr) {
+          std::map<std::string, std::string> map;
+          Status s;
+          for (size_t start = 0, end = 0;
+               s.ok() && start < value.size() && end != std::string::npos;
+               start = end + 1) {
+            std::string token;
+            s = OptionTypeInfo::NextToken(value, item_separator, start, &end,
+                                          &token);
+            if (s.ok() && !token.empty()) {
+              size_t pos = token.find(kv_separator);
+              assert(pos != std::string::npos);
+              std::string k = token.substr(0, pos);
+              std::string v = token.substr(pos + 1);
+              std::string decoded_key;
+              std::string decoded_value;
+              (Slice(k)).DecodeHex(&decoded_key);
+              (Slice(v)).DecodeHex(&decoded_value);
+              map.emplace(std::move(decoded_key), std::move(decoded_value));
+            }
+          }
+          if (s.ok()) {
+            *(static_cast<std::map<std::string, std::string>*>(addr)) = map;
+          }
+          return s;
+        });
+    info.SetSerializeFunc(
+        [kv_separator, item_separator](const ConfigOptions&, const std::string&,
+                                       const void* addr, std::string* value) {
+          const auto map =
+              static_cast<const std::map<std::string, std::string>*>(addr);
+          value->append("{");
+          for (const auto& entry : *map) {
+            value->append(Slice(entry.first).ToString(true));
+            *value += kv_separator;
+            value->append(Slice(entry.second).ToString(true));
+            *value += item_separator;
+          }
+          value->append("}");
+          return Status::OK();
+        });
+    info.SetEqualsFunc([](const ConfigOptions&, const std::string&,
+                          const void* addr1, const void* addr2, std::string*) {
+      return (*static_cast<const std::map<std::string, std::string>*>(addr1) ==
+              *static_cast<const std::map<std::string, std::string>*>(addr2));
+    });
+    return info;
+  }
+
   // Create a new std::shared_ptr<Customizable> OptionTypeInfo
   // This function will call the T::CreateFromString method to create a new
   // std::shared_ptr<T> object.
   //
   // @param offset The offset for the Customizable from the base pointer
   // @param ovt How to verify this option
-  // @param flags, Extra flags specifying the behavior of this option
-  // @param _sfunc Optional function for serializing this option
-  // @param _efunc Optional function for comparing this option
+  // @param flags Extra flags specifying the behavior of this option
+  // @param serialize_func Optional function for serializing this option
+  // @param equals_func Optional function for comparing this option
   template <typename T>
-  static OptionTypeInfo AsCustomSharedPtr(int offset,
-                                          OptionVerificationType ovt,
-                                          OptionTypeFlags flags) {
-    OptionTypeInfo info(offset, OptionType::kCustomizable, ovt,
-                        flags | OptionTypeFlags::kShared);
-    return info.SetParseFunc([](const ConfigOptions& opts,
-                                const std::string& name,
-                                const std::string& value, void* addr) {
+  static OptionTypeInfo AsCustomSharedPtr(
+      int offset, OptionVerificationType ovt,
+      OptionTypeFlags flags = OptionTypeFlags::kNone,
+      const SerializeFunc& serialize_func = {},
+      const EqualsFunc& equals_func = {}) {
+    auto parse_func = [](const ConfigOptions& opts, const std::string& name,
+                         const std::string& value, void* addr) {
       auto* shared = static_cast<std::shared_ptr<T>*>(addr);
       if (name == kIdPropName() && value.empty()) {
         shared->reset();
@@ -495,19 +523,10 @@ class OptionTypeInfo {
       } else {
         return T::CreateFromString(opts, value, shared);
       }
-    });
-  }
-
-  template <typename T>
-  static OptionTypeInfo AsCustomSharedPtr(int offset,
-                                          OptionVerificationType ovt,
-                                          OptionTypeFlags flags,
-                                          const SerializeFunc& serialize_func,
-                                          const EqualsFunc& equals_func) {
-    OptionTypeInfo info(AsCustomSharedPtr<T>(offset, ovt, flags));
-    info.SetSerializeFunc(serialize_func);
-    info.SetEqualsFunc(equals_func);
-    return info;
+    };
+    return OptionTypeInfo(offset, OptionType::kCustomizable, ovt,
+                          flags | OptionTypeFlags::kShared, parse_func,
+                          serialize_func, equals_func);
   }
 
   // Create a new std::unique_ptr<Customizable> OptionTypeInfo
@@ -612,6 +631,9 @@ class OptionTypeInfo {
     return *this;
   }
 
+  OptionTypeFlags GetFlags() const { return flags_; }
+  void SetFlags(OptionTypeFlags flags) { flags_ = flags; }
+
   bool IsEnabled(OptionTypeFlags otf) const { return (flags_ & otf) == otf; }
 
   bool IsEditable(const ConfigOptions& opts) const {
@@ -714,6 +736,8 @@ class OptionTypeInfo {
 
   bool IsCustomizable() const { return (type_ == OptionType::kCustomizable); }
 
+  OptionType GetType() const { return type_; }
+
   inline const void* GetOffset(const void* base) const {
     return static_cast<const char*>(base) + offset_;
   }

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

@@ -0,0 +1,102 @@
+//  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 <optional>
+#include <string>
+#include <variant>
+
+#include "rocksdb/rocksdb_namespace.h"
+#include "rocksdb/slice.h"
+#include "rocksdb/status.h"
+
+namespace ROCKSDB_NAMESPACE {
+
+class ColumnFamilyHandle;
+
+//       / \     UNDER CONSTRUCTION
+//      / ! \    UNDER CONSTRUCTION
+//     /-----\   UNDER CONSTRUCTION
+
+// 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
+// per-column basis. The secondary index then maintains a mapping from (column)
+// value to the list of primary keys that have the corresponding value (in the
+// given column).
+//
+// The primary and secondary key-value pairs can be stored in either the same
+// column family or different ones. It is the application's responsibility to
+// avoid conflicts and ambiguities (for example, by using prefixes to create
+// separate key spaces or using a dedicated column family for each secondary
+// index). Also, note that applications are not expected to manipulate secondary
+// index entries directly.
+//
+// In the general case where there are concurrent writers, maintaining a
+// secondary index requires transactional semantics and concurrency control.
+// Because of this, secondary indices are only supported via the transaction
+// layer. With secondary indices, whenever a (primary) key-value is inserted,
+// updated, or deleted via a transaction (regardless of whether it is an
+// explicit or implicit one), RocksDB will invoke any applicable SecondaryIndex
+// objects based on primary column family and column name, and it will
+// automatically add or remove any secondary index entries as needed (using
+// the same transaction).
+//
+// 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;
+
+  virtual void SetPrimaryColumnFamily(ColumnFamilyHandle* column_family) = 0;
+  virtual void SetSecondaryColumnFamily(ColumnFamilyHandle* column_family) = 0;
+
+  virtual ColumnFamilyHandle* GetPrimaryColumnFamily() const = 0;
+  virtual ColumnFamilyHandle* GetSecondaryColumnFamily() const = 0;
+
+  // The name of the primary column to index. Plain key-values can be indexed by
+  // specifying kDefaultWideColumnName.
+  virtual Slice GetPrimaryColumnName() const = 0;
+
+  // Optionally update the primary column value during an insert or update of a
+  // primary key-value. Called by the transaction layer before the primary
+  // key-value write is added to the transaction. Returning a non-OK status
+  // rolls back all operations in the transaction related to this primary
+  // key-value.
+  virtual Status UpdatePrimaryColumnValue(
+      const Slice& primary_key, const Slice& primary_column_value,
+      std::optional<std::variant<Slice, std::string>>* updated_column_value)
+      const = 0;
+
+  // Get the secondary key prefix for a given primary key-value. 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 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.
+  virtual Status GetSecondaryKeyPrefix(
+      const Slice& primary_key, const Slice& primary_column_value,
+      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> ->
+  // <secondary_value>). previous_column_value contains the previous value of
+  // the primary column in case it was changed by UpdatePrimaryColumnValue.
+  // Returning a non-OK status rolls back all operations in the transaction
+  // related to this primary key-value.
+  virtual Status GetSecondaryValue(
+      const Slice& primary_key, const Slice& primary_column_value,
+      const Slice& previous_column_value,
+      std::optional<std::variant<Slice, std::string>>* secondary_value)
+      const = 0;
+};
+
+}  // namespace ROCKSDB_NAMESPACE

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

@@ -7,6 +7,8 @@
 #include <atomic>
 #include <memory>
 
+#include "rocksdb/status.h"
+#include "rocksdb/system_clock.h"
 #include "rocksdb/table_properties.h"
 
 namespace ROCKSDB_NAMESPACE {
@@ -31,7 +33,7 @@ class CompactOnDeletionCollectorFactory
                                     size_t deletion_trigger,
                                     double deletion_ratio);
 
-  ~CompactOnDeletionCollectorFactory() {}
+  ~CompactOnDeletionCollectorFactory() override {}
 
   TablePropertiesCollector* CreateTablePropertiesCollector(
       TablePropertiesCollectorFactory::Context context) override;
@@ -106,7 +108,7 @@ class CompactForTieringCollectorFactory
   // for what entry is eligible.
   CompactForTieringCollectorFactory(double compaction_trigger_ratio);
 
-  ~CompactForTieringCollectorFactory() {}
+  ~CompactForTieringCollectorFactory() override {}
 
   TablePropertiesCollector* CreateTablePropertiesCollector(
       TablePropertiesCollectorFactory::Context context) override;
@@ -130,4 +132,89 @@ class CompactForTieringCollectorFactory
 
 std::shared_ptr<CompactForTieringCollectorFactory>
 NewCompactForTieringCollectorFactory(double compaction_trigger_ratio);
+
+// Information for the unix write time of a collection of data. Combined with
+// the current unix time, these stats give an overview of how long the data
+// have been written to the DB.
+// Check `DataCollectionIsEmpty` and `TrackedDataRatio` before interpreting
+// the stats.
+struct DataCollectionUnixWriteTimeInfo {
+  // The minimum write time, a.k.a. the write time of the oldest key.
+  uint64_t min_write_time = 0;
+  // The maximum write time, a.k.a. the write time of the newest key.
+  uint64_t max_write_time = 0;
+  // The average write time.
+  uint64_t average_write_time = 0;
+
+  // The number of entries that can be considered infinitely old because their
+  // sequence number are zeroed out. We know they are old entries but do not
+  // know how old exactly. These entries are separately counted and not
+  // aggregated in above stats.
+  uint64_t num_entries_infinitely_old = 0;
+
+  // The number of entries used to create above min, max, average stats.
+  uint64_t num_entries_write_time_aggregated = 0;
+
+  // The number of entries for which write time is untracked.
+  uint64_t num_entries_write_time_untracked = 0;
+
+  DataCollectionUnixWriteTimeInfo() {}
+
+  DataCollectionUnixWriteTimeInfo(uint64_t _min_write_time,
+                                  uint64_t _max_write_time,
+                                  uint64_t _average_write_time,
+                                  uint64_t _num_entries_infinitely_old,
+                                  uint64_t _num_entries_write_time_aggregated,
+                                  uint64_t _num_entries_write_time_untracked)
+      : min_write_time(_min_write_time),
+        max_write_time(_max_write_time),
+        average_write_time(_average_write_time),
+        num_entries_infinitely_old(_num_entries_infinitely_old),
+        num_entries_write_time_aggregated(_num_entries_write_time_aggregated),
+        num_entries_write_time_untracked(_num_entries_write_time_untracked) {}
+
+  // Returns true if the data collection for which this
+  // `DataCollectionUnixWriteTimeInfo` is for is empty.
+  bool DataCollectionIsEmpty() const {
+    return num_entries_infinitely_old == 0 &&
+           num_entries_write_time_aggregated == 0 &&
+           num_entries_write_time_untracked == 0;
+  }
+
+  // The closer the ratio is to 1, the more accurate the stats reflect the
+  // actual write time of this collection of data. If this ratio is 0, there is
+  // no write time information available. It could be either the data collection
+  // is empty, or none of its data has write time info tracked.
+  //
+  // For a single file, its data either has write time info tracked or not
+  // tracked, this ratio would be either 0 or 1. For a level, this ratio
+  // reflects what portion of the data has its write time info tracked in this
+  // struct. 0 is returned if the level is empty.
+  double TrackedDataRatio() const {
+    if (DataCollectionIsEmpty()) {
+      return 0;
+    }
+    uint64_t num_entries_write_time_tracked =
+        num_entries_infinitely_old + num_entries_write_time_aggregated;
+    return num_entries_write_time_tracked /
+           static_cast<double>(num_entries_write_time_tracked +
+                               num_entries_write_time_untracked);
+  }
+
+  // Whether the file or the level has infinitely old data.
+  bool HasInfinitelyOldData() const { return num_entries_infinitely_old > 0; }
+};
+
+// Given the table properties of a file, return data's unix write time stats
+// if available.
+Status GetDataCollectionUnixWriteTimeInfoForFile(
+    const std::shared_ptr<const TableProperties>& table_properties,
+    std::unique_ptr<DataCollectionUnixWriteTimeInfo>* file_info);
+
+// Given the collection of table properties per level, return data unix write
+// time stats if available.
+Status GetDataCollectionUnixWriteTimeInfoForLevels(
+    const std::vector<std::unique_ptr<TablePropertiesCollection>>&
+        levels_table_properties,
+    std::vector<std::unique_ptr<DataCollectionUnixWriteTimeInfo>>* levels_info);
 }  // namespace ROCKSDB_NAMESPACE

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

@@ -477,6 +477,36 @@ class Transaction {
   virtual Iterator* GetIterator(const ReadOptions& read_options,
                                 ColumnFamilyHandle* column_family) = 0;
 
+  // Returns a multi-column-family coalescing iterator for the given column
+  // families that includes both keys in the DB and uncommitted keys in this
+  // transaction.
+  //
+  // Setting read_options.snapshot will affect what is read from the
+  // DB but will NOT change which keys are read from this transaction (the keys
+  // in this transaction do not yet belong to any snapshot and will be fetched
+  // regardless).
+  //
+  // The returned iterator is only valid until Commit(), Rollback(), or
+  // RollbackToSavePoint() is called.
+  virtual std::unique_ptr<Iterator> GetCoalescingIterator(
+      const ReadOptions& read_options,
+      const std::vector<ColumnFamilyHandle*>& column_families) = 0;
+
+  // Returns a multi-column-family attribute group iterator for the given column
+  // families that includes both keys in the DB and uncommitted keys in this
+  // transaction.
+  //
+  // Setting read_options.snapshot will affect what is read from the
+  // DB but will NOT change which keys are read from this transaction (the keys
+  // in this transaction do not yet belong to any snapshot and will be fetched
+  // regardless).
+  //
+  // The returned iterator is only valid until Commit(), Rollback(), or
+  // RollbackToSavePoint() is called.
+  virtual std::unique_ptr<AttributeGroupIterator> GetAttributeGroupIterator(
+      const ReadOptions& read_options,
+      const std::vector<ColumnFamilyHandle*>& column_families) = 0;
+
   // Put, PutEntity, Merge, Delete, and SingleDelete behave similarly to the
   // corresponding functions in WriteBatch, but will also do conflict checking
   // on the keys being written.
@@ -720,6 +750,8 @@ 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

@@ -20,6 +20,7 @@
 
 namespace ROCKSDB_NAMESPACE {
 
+class SecondaryIndex;
 class TransactionDBMutexFactory;
 
 enum TxnDBWritePolicy {
@@ -240,6 +241,14 @@ struct TransactionDBOptions {
   // user-defined timestamps so this option only applies in this case.
   bool enable_udt_validation = true;
 
+  //       / \     UNDER CONSTRUCTION
+  //      / ! \    UNDER CONSTRUCTION
+  //     /-----\   UNDER CONSTRUCTION
+  //
+  // The secondary indices to be maintained. See the SecondaryIndex interface
+  // for more details.
+  std::vector<std::shared_ptr<SecondaryIndex>> secondary_indices;
+
  private:
   // 128 entries
   // Should the default value change, please also update wp_snapshot_cache_bits
@@ -339,6 +348,23 @@ struct TransactionOptions {
   // size in APIs that MyRocks currently are using, including Put, Merge, Delete
   // DeleteRange, SingleDelete.
   bool write_batch_track_timestamp_size = false;
+
+  // EXPERIMENTAL
+  // 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.
+  // Transactions with Merge() or PutEntity() is not supported yet.
+  //
+  // Note that the transaction will be ingested as an immutable memtable for
+  // CFs it updates, and the current memtable will be switched to a new one.
+  // So ingesting many transactions in a short period of time may cause stall
+  // due to too many memtables.
+  // Note that the ingestion relies on the transaction's underlying index,
+  // (WriteBatchWithIndex), so updates that are added to the transaction
+  // 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.
+  bool commit_bypass_memtable = false;
 };
 
 // The per-write optimizations that do not involve transactions. TransactionDB
@@ -460,7 +486,10 @@ class TransactionDB : public StackableDB {
   //
   // If old_txn is not null, BeginTransaction will reuse this Transaction
   // handle instead of allocating a new one.  This is an optimization to avoid
-  // extra allocations when repeatedly creating transactions.
+  // extra allocations when repeatedly creating transactions. **Note that this
+  // may not free all the allocated memory by the previous transaction (see
+  // WriteBatch::Clear()). To ensure that all allocated memory is freed, users
+  // must destruct the transaction object.
   virtual Transaction* BeginTransaction(
       const WriteOptions& write_options,
       const TransactionOptions& txn_options = TransactionOptions(),

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

@@ -74,6 +74,10 @@ class WBWIIterator {
   // WriteBatchWithIndex
   virtual WriteEntry Entry() const = 0;
 
+  // For this user key, there is a single delete in this write batch,
+  // and it was overwritten by another update.
+  virtual bool HasOverWrittenSingleDel() const { return false; }
+
   virtual Status status() const = 0;
 };
 
@@ -188,8 +192,10 @@ class WriteBatchWithIndex : public WriteBatchBase {
   // Create an iterator of a column family. User can call iterator.Seek() to
   // search to the next entry of or after a key. Keys will be iterated in the
   // order given by index_comparator. For multiple updates on the same key,
-  // each update will be returned as a separate entry, in the order of update
-  // time.
+  // if overwrite_key=false, then each update will be returned as a separate
+  // entry, in the order of update time.
+  // if overwrite_key=true, then one entry per key will be returned. Merge
+  // updates on the same key will be returned as separate entries.
   //
   // The returned iterator should be deleted by the caller.
   WBWIIterator* NewIterator(ColumnFamilyHandle* column_family);
@@ -348,12 +354,27 @@ class WriteBatchWithIndex : public WriteBatchBase {
   void SetMaxBytes(size_t max_bytes) override;
   size_t GetDataSize() const;
 
+  struct CFStat {
+    uint32_t entry_count = 0;
+    uint32_t overwritten_sd_count = 0;
+  };
+  // Will track CF ID, per CF entry count and overwritten sd count.
+  // Should be enabled when WBWI is empty for correct tracking.
+  void SetTrackPerCFStat(bool track);
+  const std::unordered_map<uint32_t, CFStat>& GetCFStats() const;
+
+  bool GetOverwriteKey() const;
+
  private:
   friend class PessimisticTransactionDB;
   friend class WritePreparedTxn;
   friend class WriteUnpreparedTxn;
   friend class WriteBatchWithIndex_SubBatchCnt_Test;
   friend class WriteBatchWithIndexInternal;
+  friend class WBWIMemTable;
+
+  WBWIIterator* NewIterator(uint32_t cf_id) const;
+
   // Returns the number of sub-batches inside the write batch. A sub-batch
   // starts right before inserting a key that is a duplicate of a key in the
   // last sub-batch.

package/deps/rocksdb/rocksdb/include/rocksdb/version.h

@@ -12,8 +12,8 @@
 // NOTE: in 'main' development branch, this should be the *next*
 // minor or major version number planned for release.
 #define ROCKSDB_MAJOR 9
-#define ROCKSDB_MINOR 7
-#define ROCKSDB_PATCH 4
+#define ROCKSDB_MINOR 10
+#define ROCKSDB_PATCH 0
 
 // Do not use these. We made the mistake of declaring macros starting with
 // double underscore. Now we have to live with our choice. We'll deprecate these

package/deps/rocksdb/rocksdb/include/rocksdb/write_batch.h

@@ -209,6 +209,8 @@ class WriteBatch : public WriteBatchBase {
 
   using WriteBatchBase::Clear;
   // Clear all updates buffered in this batch.
+  // Internally, it calls resize() on the string buffer. So allocated memory
+  // capacity may not be freed.
   void Clear() override;
 
   // Records the state of the batch for future calls to RollbackToSavePoint().