@nxtedition/rocksdb 9.0.0 → 10.0.0

package/deps/rocksdb/rocksdb/include/rocksdb/merge_operator.h

@@ -8,10 +8,13 @@
 #include <deque>
 #include <memory>
 #include <string>
+#include <utility>
+#include <variant>
 #include <vector>
 
 #include "rocksdb/customizable.h"
 #include "rocksdb/slice.h"
+#include "rocksdb/wide_columns.h"
 
 namespace ROCKSDB_NAMESPACE {
 
@@ -33,7 +36,7 @@ class Logger;
 //    into rocksdb); numeric addition and string concatenation are examples;
 //
 //  b) MergeOperator - the generic class for all the more abstract / complex
-//    operations; one method (FullMergeV2) to merge a Put/Delete value with a
+//    operations; one method (FullMergeV3) to merge a Put/Delete value with a
 //    merge operand; and another method (PartialMerge) that merges multiple
 //    operands together. this is especially useful if your key values have
 //    complex structures but you would still like to support client-specific
@@ -158,6 +161,54 @@ class MergeOperator : public Customizable {
   virtual bool FullMergeV2(const MergeOperationInput& merge_in,
                            MergeOperationOutput* merge_out) const;
 
+  struct MergeOperationInputV3 {
+    using ExistingValue = std::variant<std::monostate, Slice, WideColumns>;
+    using OperandList = std::vector<Slice>;
+
+    explicit MergeOperationInputV3(const Slice& _key,
+                                   ExistingValue&& _existing_value,
+                                   const OperandList& _operand_list,
+                                   Logger* _logger)
+        : key(_key),
+          existing_value(std::move(_existing_value)),
+          operand_list(_operand_list),
+          logger(_logger) {}
+
+    // The user key, including the user-defined timestamp if applicable.
+    const Slice& key;
+    // The base value of the merge operation. Can be one of three things (see
+    // the ExistingValue variant above): no existing value, plain existing
+    // value, or wide-column existing value.
+    ExistingValue existing_value;
+    // The list of operands to apply.
+    const OperandList& operand_list;
+    // The logger to use in case a failure happens during the merge operation.
+    Logger* logger;
+  };
+
+  struct MergeOperationOutputV3 {
+    using NewColumns = std::vector<std::pair<std::string, std::string>>;
+    using NewValue = std::variant<std::string, NewColumns, Slice>;
+
+    // The result of the merge operation. Can be one of three things (see the
+    // NewValue variant above): a new plain value, a new wide-column value, or
+    // an existing merge operand.
+    NewValue new_value;
+    // The scope of the failure if applicable. See above for more details.
+    OpFailureScope op_failure_scope = OpFailureScope::kDefault;
+  };
+
+  // An extended version of FullMergeV2() that supports wide columns on both the
+  // input and the output side, enabling the application to perform general
+  // transformations during merges. For backward compatibility, the default
+  // implementation calls FullMergeV2(). Specifically, if there is no base value
+  // or the base value is a plain key-value, the default implementation falls
+  // back to FullMergeV2(). If the base value is a wide-column entity, the
+  // default implementation invokes FullMergeV2() to perform the merge on the
+  // default column, and leaves any other columns unchanged.
+  virtual bool FullMergeV3(const MergeOperationInputV3& merge_in,
+                           MergeOperationOutputV3* merge_out) const;
+
   // This function performs merge(left_op, right_op)
   // when both the operands are themselves merge operation types
   // that you would have passed to a DB::Merge() call in the same order
@@ -186,7 +237,7 @@ class MergeOperator : public Customizable {
   // TODO: Presently there is no way to differentiate between error/corruption
   // and simply "return false". For now, the client should simply return
   // false in any case it cannot perform partial-merge, regardless of reason.
-  // If there is corruption in the data, handle it in the FullMergeV2() function
+  // If there is corruption in the data, handle it in the FullMergeV3() function
   // and return false there.  The default implementation of PartialMerge will
   // always return false.
   virtual bool PartialMerge(const Slice& /*key*/, const Slice& /*left_operand*/,
@@ -243,8 +294,8 @@ class MergeOperator : public Customizable {
   // Doesn't help with iterators.
   //
   // Note: the merge operands are passed to this function in the reversed order
-  // relative to how they were merged (passed to FullMerge or FullMergeV2)
-  // for performance reasons, see also:
+  // relative to how they were merged (passed to
+  // FullMerge/FullMergeV2/FullMergeV3) for performance reasons, see also:
   // https://github.com/facebook/rocksdb/issues/3865
   virtual bool ShouldMerge(const std::vector<Slice>& /*operands*/) const {
     return false;

package/deps/rocksdb/rocksdb/include/rocksdb/options.h

@@ -13,6 +13,7 @@
 
 #include <limits>
 #include <memory>
+#include <optional>
 #include <string>
 #include <unordered_map>
 #include <vector>
@@ -206,6 +207,7 @@ struct ColumnFamilyOptions : public AdvancedColumnFamilyOptions {
   // - kZSTD: 3
   // - kZlibCompression: Z_DEFAULT_COMPRESSION (currently -1)
   // - kLZ4HCCompression: 0
+  // - kLZ4: -1 (i.e., `acceleration=1`; see `CompressionOptions::level` doc)
   // - For all others, we do not specify a compression level
   //
   // Dynamically changeable through SetOptions() API
@@ -483,7 +485,8 @@ struct DBOptions {
   // Default: false
   bool create_if_missing = false;
 
-  // If true, missing column families will be automatically created.
+  // If true, missing column families will be automatically created on
+  // DB::Open().
   // Default: false
   bool create_missing_column_families = false;
 
@@ -1198,11 +1201,11 @@ struct DBOptions {
   // currently.
   WalFilter* wal_filter = nullptr;
 
-  // If true, then DB::Open / CreateColumnFamily / DropColumnFamily
+  // If true, then DB::Open, CreateColumnFamily, DropColumnFamily, and
   // SetOptions will fail if options file is not properly persisted.
   //
-  // DEFAULT: false
-  bool fail_if_options_file_error = false;
+  // DEFAULT: true
+  bool fail_if_options_file_error = true;
 
   // If true, then print malloc stats together with rocksdb.stats
   // when printing to LOG.
@@ -1425,6 +1428,24 @@ struct DBOptions {
   // of the contract leads to undefined behaviors with high possibility of data
   // inconsistency, e.g. deleted old data become visible again, etc.
   bool enforce_single_del_contracts = true;
+
+  // EXPERIMENTAL
+  // Implementing off-peak duration awareness in RocksDB. In this context,
+  // "off-peak time" signifies periods characterized by significantly less read
+  // and write activity compared to other times. By leveraging this knowledge,
+  // we can prevent low-priority tasks, such as TTL-based compactions, from
+  // competing with read and write operations during peak hours. Essentially, we
+  // preprocess these tasks during the preceding off-peak period, just before
+  // the next peak cycle begins. For example, if the TTL is configured for 25
+  // days, we may compact the files during the off-peak hours of the 24th day.
+  //
+  // Time of the day in UTC, start_time-end_time inclusive.
+  // Format - HH:mm-HH:mm (00:00-23:59)
+  // If the start time > end time, it will be considered that the time period
+  // spans to the next day (e.g., 23:30-04:00). To make an entire day off-peak,
+  // use "0:00-23:59". To make an entire day have no offpeak period, leave
+  // this field blank. Default: Empty string (no offpeak).
+  std::string daily_offpeak_time_utc = "";
 };
 
 // Options to control the behavior of a database (passed to DB::Open)
@@ -1551,6 +1572,12 @@ struct ReadOptions {
   // soft limit then all the remaining keys are returned with status Aborted.
   uint64_t value_size_soft_limit = std::numeric_limits<uint64_t>::max();
 
+  // When the number of merge operands applied exceeds this threshold
+  // during a successful query, the operation will return a special OK
+  // Status with subcode kMergeOperandThresholdExceeded. Currently only applies
+  // to point lookups and is disabled by default.
+  std::optional<size_t> merge_operand_count_threshold;
+
   // If true, all data read from underlying storage will be
   // verified against corresponding checksums.
   bool verify_checksums = true;
@@ -1711,14 +1738,27 @@ struct ReadOptions {
   // during scans internally.
   // For this feature to enabled, iterate_upper_bound must also be specified.
   //
+  // NOTE: - Recommended for forward Scans only.
+  //       - In case of backward scans like Prev or SeekForPrev, the
+  //          cost of these backward operations might increase and affect the
+  //          performace. So this option should not be enabled if workload
+  //          contains backward scans.
+  //       - If there is a backward scans, this option will be
+  //          disabled internally and won't be reset if forward scan is done
+  //          again.
+  //
   // Default: false
   bool auto_readahead_size = false;
 
   // *** END options only relevant to iterators or scans ***
 
-  // ** For RocksDB internal use only **
+  // *** BEGIN options for RocksDB internal use only ***
+
+  // EXPERIMENTAL
   Env::IOActivity io_activity = Env::IOActivity::kUnknown;
 
+  // *** END options for RocksDB internal use only ***
+
   ReadOptions() {}
   ReadOptions(bool _verify_checksums, bool _fill_cache);
   explicit ReadOptions(Env::IOActivity _io_activity);

package/deps/rocksdb/rocksdb/include/rocksdb/port_defs.h

@@ -12,6 +12,10 @@
 
 namespace ROCKSDB_NAMESPACE {
 
+namespace port {
+class CondVar;
+}
+
 enum class CpuPriority {
   kIdle = 0,
   kLow = 1,

package/deps/rocksdb/rocksdb/include/rocksdb/rate_limiter.h

@@ -40,6 +40,15 @@ class RateLimiter {
   // REQUIRED: bytes_per_second > 0
   virtual void SetBytesPerSecond(int64_t bytes_per_second) = 0;
 
+  // This API allows user to dynamically change the max bytes can be granted in
+  // a single refill period (i.e, burst)
+  //
+  // REQUIRED: single_burst_bytes > 0. Otherwise `Status::InvalidArgument` will
+  // be returned.
+  virtual Status SetSingleBurstBytes(int64_t /* single_burst_bytes */) {
+    return Status::NotSupported();
+  }
+
   // Deprecated. New RateLimiter derived classes should override
   // Request(const int64_t, const Env::IOPriority, Statistics*) or
   // Request(const int64_t, const Env::IOPriority, Statistics*, OpType)

package/deps/rocksdb/rocksdb/include/rocksdb/secondary_cache.h

@@ -11,6 +11,7 @@
 
 #include "rocksdb/advanced_cache.h"
 #include "rocksdb/customizable.h"
+#include "rocksdb/options.h"
 #include "rocksdb/slice.h"
 #include "rocksdb/statistics.h"
 #include "rocksdb/status.h"
@@ -83,15 +84,19 @@ class SecondaryCache : public Customizable {
                         bool force_insert) = 0;
 
   // Insert a value from its saved/persistable data (typically uncompressed
-  // block), as if generated by SaveToCallback/SizeCallback. This can be used
-  // in "warming up" the cache from some auxiliary source, and like Insert()
-  // may or may not write it to cache depending on the admission control
-  // policy, even if the return status is success.
+  // block), as if generated by SaveToCallback/SizeCallback. The data can be
+  // compressed, in which case the type argument should specify the
+  // compression algorithm used. Additionally, the source argument should
+  // be set to the appropriate tier that will be responsible for
+  // uncompressing the data.
   //
-  // The default implementation only assumes the entry helper's create_cb is
-  // called at Lookup() time and not Insert() time, so should work for all
-  // foreseeable implementations.
-  virtual Status InsertSaved(const Slice& key, const Slice& saved);
+  // This method can be used in "warming up" the cache from some auxiliary
+  // source, and like Insert() may or may not write it to cache depending on
+  // the admission control policy, even if the return status is success.
+  virtual Status InsertSaved(
+      const Slice& key, const Slice& saved,
+      CompressionType type = CompressionType::kNoCompression,
+      CacheTier source = CacheTier::kVolatileTier) = 0;
 
   // Lookup the data for the given key in this cache. The create_cb
   // will be used to create the object. The handle returned may not be
@@ -148,4 +153,70 @@ class SecondaryCache : public Customizable {
   virtual Status Inflate(size_t /*increase*/) { return Status::NotSupported(); }
 };
 
+// A wrapper around a SecondaryCache object. A derived class may selectively
+// override methods to implement a different behavior.
+class SecondaryCacheWrapper : public SecondaryCache {
+ public:
+  explicit SecondaryCacheWrapper(std::shared_ptr<SecondaryCache> target)
+      : target_(std::move(target)) {}
+
+  virtual Status Insert(const Slice& key, Cache::ObjectPtr obj,
+                        const Cache::CacheItemHelper* helper,
+                        bool force_insert) override {
+    return target()->Insert(key, obj, helper, force_insert);
+  }
+
+  virtual Status InsertSaved(
+      const Slice& key, const Slice& saved,
+      CompressionType type = CompressionType::kNoCompression,
+      CacheTier source = CacheTier::kVolatileTier) override {
+    return target()->InsertSaved(key, saved, type, source);
+  }
+
+  virtual std::unique_ptr<SecondaryCacheResultHandle> Lookup(
+      const Slice& key, const Cache::CacheItemHelper* helper,
+      Cache::CreateContext* create_context, bool wait, bool advise_erase,
+      bool& kept_in_sec_cache) override {
+    return target()->Lookup(key, helper, create_context, wait, advise_erase,
+                            kept_in_sec_cache);
+  }
+
+  virtual bool SupportForceErase() const override {
+    return target()->SupportForceErase();
+  }
+
+  virtual void Erase(const Slice& key) override { target()->Erase(key); }
+
+  virtual void WaitAll(
+      std::vector<SecondaryCacheResultHandle*> handles) override {
+    target()->WaitAll(handles);
+  }
+
+  virtual Status SetCapacity(size_t capacity) override {
+    return target()->SetCapacity(capacity);
+  }
+
+  virtual Status GetCapacity(size_t& capacity) override {
+    return target()->GetCapacity(capacity);
+  }
+
+  virtual Status Deflate(size_t decrease) override {
+    return target()->Deflate(decrease);
+  }
+
+  virtual Status Inflate(size_t increase) override {
+    return target()->Inflate(increase);
+  }
+
+ protected:
+  SecondaryCache* target() const { return target_.get(); }
+
+ private:
+  std::shared_ptr<SecondaryCache> target_;
+};
+
+// Useful for cache entries that just need to be copied into a
+// secondary cache, such as compressed blocks
+extern const Cache::CacheItemHelper kSliceCacheItemHelper;
+
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/include/rocksdb/statistics.h

@@ -208,8 +208,11 @@ enum Tickers : uint32_t {
 
   // DEPRECATED / unused (see NUMBER_BLOCK_COMPRESSION_*)
   NUMBER_BLOCK_NOT_COMPRESSED,
+
+  // Tickers that record cumulative time.
   MERGE_OPERATION_TOTAL_TIME,
   FILTER_OPERATION_TOTAL_TIME,
+  COMPACTION_CPU_TOTAL_TIME,
 
   // Row cache.
   ROW_CACHE_HIT,
@@ -515,6 +518,19 @@ enum Tickers : uint32_t {
   // ReadOptions.auto_readahead_size is set.
   READAHEAD_TRIMMED,
 
+  // Number of FIFO compactions that drop files based on different reasons
+  FIFO_MAX_SIZE_COMPACTIONS,
+  FIFO_TTL_COMPACTIONS,
+
+  // Number of bytes prefetched during user initiated scan
+  PREFETCH_BYTES,
+
+  // Number of prefetched bytes that were actually useful
+  PREFETCH_BYTES_USEFUL,
+
+  // Number of FS reads avoided due to scan prefetching
+  PREFETCH_HITS,
+
   TICKER_ENUM_MAX
 };
 

package/deps/rocksdb/rocksdb/include/rocksdb/status.h

@@ -114,6 +114,7 @@ class Status {
     kTxnNotPrepared = 13,
     kIOFenced = 14,
     kMergeOperatorFailed = 15,
+    kMergeOperandThresholdExceeded = 16,
     kMaxSubCode
   };
 
@@ -150,6 +151,25 @@ class Status {
     return state_.get();
   }
 
+  // Override this status with another, unless this status is already non-ok.
+  // Returns *this. Thus, the result of `a.UpdateIfOk(b).UpdateIfOk(c)` is
+  // non-ok (and `a` modified as such) iff any input was non-ok, with
+  // left-most taking precedence as far as the details.
+  Status& UpdateIfOk(Status&& s) {
+    if (code() == kOk) {
+      *this = std::move(s);
+    } else {
+      // Alright to ignore that status as long as this one is checked
+      s.PermitUncheckedError();
+    }
+    MustCheck();
+    return *this;
+  }
+
+  Status& UpdateIfOk(const Status& s) {
+    return UpdateIfOk(std::forward<Status>(Status(s)));
+  }
+
   // Return a success status.
   static Status OK() { return Status(); }
 
@@ -159,6 +179,14 @@ class Status {
   // changing public APIs.
   static Status OkOverwritten() { return Status(kOk, kOverwritten); }
 
+  // Successful, though the number of operands merged during the query exceeded
+  // the threshold. Note: using variants of OK status for program logic is
+  // discouraged, but it can be useful for communicating statistical information
+  // without changing public APIs.
+  static Status OkMergeOperandThresholdExceeded() {
+    return Status(kOk, kMergeOperandThresholdExceeded);
+  }
+
   // Return error status of an appropriate type.
   static Status NotFound(const Slice& msg, const Slice& msg2 = Slice()) {
     return Status(kNotFound, msg, msg2);
@@ -301,6 +329,13 @@ class Status {
     return code() == kOk && subcode() == kOverwritten;
   }
 
+  // Returns true iff the status indicates success *with* the number of operands
+  // merged exceeding the threshold
+  bool IsOkMergeOperandThresholdExceeded() const {
+    MarkChecked();
+    return code() == kOk && subcode() == kMergeOperandThresholdExceeded;
+  }
+
   // Returns true iff the status indicates a NotFound error.
   bool IsNotFound() const {
     MarkChecked();

package/deps/rocksdb/rocksdb/include/rocksdb/system_clock.h

@@ -9,9 +9,11 @@
 #pragma once
 #include <stdint.h>
 
+#include <chrono>
 #include <memory>
 
 #include "rocksdb/customizable.h"
+#include "rocksdb/port_defs.h"
 #include "rocksdb/rocksdb_namespace.h"
 #include "rocksdb/status.h"
 
@@ -68,6 +70,14 @@ class SystemClock : public Customizable {
   // Sleep/delay the thread for the prescribed number of micro-seconds.
   virtual void SleepForMicroseconds(int micros) = 0;
 
+  // For internal use/extension only.
+  //
+  // Issues a wait on `cv` that times out at `deadline`. May wakeup and return
+  // spuriously.
+  //
+  // Returns true if wait timed out, false otherwise
+  virtual bool TimedWait(port::CondVar* cv, std::chrono::microseconds deadline);
+
   // Get the number of seconds since the Epoch, 1970-01-01 00:00:00 (UTC).
   // Only overwrites *unix_time on success.
   virtual Status GetCurrentTime(int64_t* unix_time) = 0;
@@ -94,6 +104,11 @@ class SystemClockWrapper : public SystemClock {
     return target_->SleepForMicroseconds(micros);
   }
 
+  virtual bool TimedWait(port::CondVar* cv,
+                         std::chrono::microseconds deadline) override {
+    return target_->TimedWait(cv, deadline);
+  }
+
   Status GetCurrentTime(int64_t* unix_time) override {
     return target_->GetCurrentTime(unix_time);
   }

package/deps/rocksdb/rocksdb/include/rocksdb/table_properties.h

@@ -219,9 +219,20 @@ struct TableProperties {
   // by column_family_name.
   uint64_t column_family_id = ROCKSDB_NAMESPACE::
       TablePropertiesCollectorFactory::Context::kUnknownColumnFamily;
-  // Timestamp of the latest key. 0 means unknown.
-  // TODO(sagar0): Should be changed to latest_key_time ... but don't know the
-  // full implications of backward compatibility. Hence retaining for now.
+
+  // Oldest ancester time. 0 means unknown.
+  //
+  // For flush output file, oldest ancestor time is the oldest key time in the
+  // file.  If the oldest key time is not available, flush time is used.
+  //
+  // For compaction output file, oldest ancestor time is the oldest
+  // among all the oldest key time of its input files, since the file could be
+  // the compaction output from other SST files, which could in turn be outputs
+  // for compact older SST files. If that's not available, creation time of this
+  // compaction output file is used.
+  //
+  // TODO(sagar0): Should be changed to oldest_ancester_time ... but don't know
+  // the full implications of backward compatibility. Hence retaining for now.
   uint64_t creation_time = 0;
 
   // Timestamp of the earliest key. 0 means unknown.

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

@@ -62,6 +62,8 @@ struct ThreadStatus {
     OP_DBITERATOR,
     OP_VERIFY_DB_CHECKSUM,
     OP_VERIFY_FILE_CHECKSUMS,
+    OP_GETENTITY,
+    OP_MULTIGETENTITY,
     NUM_OP_TYPES
   };
 

package/deps/rocksdb/rocksdb/include/rocksdb/types.h

@@ -7,6 +7,9 @@
 
 #include <stdint.h>
 
+#include <memory>
+#include <unordered_map>
+
 #include "rocksdb/slice.h"
 
 namespace ROCKSDB_NAMESPACE {
@@ -18,6 +21,10 @@ using ColumnFamilyId = uint32_t;
 // Represents a sequence number in a WAL file.
 using SequenceNumber = uint64_t;
 
+struct TableProperties;
+using TablePropertiesCollection =
+    std::unordered_map<std::string, std::shared_ptr<const TableProperties>>;
+
 const SequenceNumber kMinUnCommittedSeq = 1;  // 0 is always committed
 
 enum class TableFileCreationReason {

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

@@ -226,6 +226,12 @@ class LDBCommand {
   static std::string PrintKeyValue(const std::string& key,
                                    const std::string& value, bool is_hex);
 
+  static std::string PrintKeyValueOrWideColumns(const Slice& key,
+                                                const Slice& value,
+                                                const WideColumns& wide_columns,
+                                                bool is_key_hex,
+                                                bool is_value_hex);
+
   /**
    * Return true if the specified flag is present in the specified flags vector
    */
@@ -313,4 +319,3 @@ class LDBCommandRunner {
 };
 
 }  // namespace ROCKSDB_NAMESPACE
-

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

@@ -40,8 +40,9 @@ enum class OptionType {
   kUInt32T,
   kUInt64T,
   kSizeT,
-  kString,
   kDouble,
+  kAtomicInt,
+  kString,
   kCompactionStyle,
   kCompactionPri,
   kCompressionType,

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

@@ -527,6 +527,15 @@ class Transaction {
 
   virtual Status SingleDeleteUntracked(const Slice& key) = 0;
 
+  // Collpase the merge chain for the given key. This is can be used by the
+  // application to trigger an on-demand collpase to a key that has a long
+  // merge chain to reduce read amplification, without waiting for compaction
+  // to kick in.
+  virtual Status CollapseKey(const ReadOptions&, const Slice&,
+                             ColumnFamilyHandle* = nullptr) {
+    return Status::NotSupported("collpase not supported");
+  }
+
   // Similar to WriteBatch::PutLogData
   virtual void PutLogData(const Slice& blob) = 0;
 

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 8
-#define ROCKSDB_MINOR 6
-#define ROCKSDB_PATCH 7
+#define ROCKSDB_MINOR 8
+#define ROCKSDB_PATCH 1
 
 // 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/wide_columns.h

@@ -16,6 +16,8 @@
 
 namespace ROCKSDB_NAMESPACE {
 
+class ColumnFamilyHandle;
+
 // Class representing a wide column, which is defined as a pair of column name
 // and column value.
 class WideColumn {
@@ -74,8 +76,19 @@ inline bool operator!=(const WideColumn& lhs, const WideColumn& rhs) {
 inline std::ostream& operator<<(std::ostream& os, const WideColumn& column) {
   const bool hex =
       (os.flags() & std::ios_base::basefield) == std::ios_base::hex;
-  os << column.name().ToString(hex) << ':' << column.value().ToString(hex);
-
+  if (!column.name().empty()) {
+    if (hex) {
+      os << "0x";
+    }
+    os << column.name().ToString(hex);
+  }
+  os << ':';
+  if (!column.value().empty()) {
+    if (hex) {
+      os << "0x";
+    }
+    os << column.value().ToString(hex);
+  }
   return os;
 }
 
@@ -207,4 +220,42 @@ inline bool operator!=(const PinnableWideColumns& lhs,
   return !(lhs == rhs);
 }
 
+// Class representing attribute group. Attribute group is a logical grouping of
+// wide-column entities by leveraging Column Families. Wide-columns returned
+// from the query are pinnable.
+class PinnableAttributeGroup {
+ public:
+  ColumnFamilyHandle* column_family() const { return column_family_; }
+  const Status& status() const { return status_; }
+  const WideColumns& columns() const { return columns_.columns(); }
+
+  explicit PinnableAttributeGroup(ColumnFamilyHandle* column_family)
+      : column_family_(column_family), status_(Status::OK()) {}
+
+  void SetStatus(const Status& status);
+  void SetColumns(PinnableWideColumns&& columns);
+
+  void Reset();
+
+ private:
+  ColumnFamilyHandle* column_family_;
+  Status status_;
+  PinnableWideColumns columns_;
+};
+
+inline void PinnableAttributeGroup::SetStatus(const Status& status) {
+  status_ = status;
+}
+inline void PinnableAttributeGroup::SetColumns(PinnableWideColumns&& columns) {
+  columns_ = std::move(columns);
+}
+
+inline void PinnableAttributeGroup::Reset() {
+  SetStatus(Status::OK());
+  columns_.Reset();
+}
+
+// A collection of Attribute Groups.
+using PinnableAttributeGroups = std::vector<PinnableAttributeGroup>;
+
 }  // namespace ROCKSDB_NAMESPACE

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

@@ -395,8 +395,6 @@ class WriteBatch : public WriteBatchBase {
   // Returns true if MarkRollback will be called during Iterate
   bool HasRollback() const;
 
-  // Experimental.
-  //
   // Update timestamps of existing entries in the write batch if
   // applicable. If a key is intended for a column family that disables
   // timestamp, then this API won't set the timestamp for this key.