ceph/src/rocksdb/include/rocksdb/wide_columns.h

   1 //  Copyright (c) Meta Platforms, Inc. and affiliates.
   2 //  This source code is licensed under both the GPLv2 (found in the
   3 //  COPYING file in the root directory) and Apache 2.0 License
   4 //  (found in the LICENSE.Apache file in the root directory).
   5
   6 #pragma once
   7
   8 #include <ostream>
   9 #include <tuple>
  10 #include <utility>
  11 #include <vector>
  12
  13 #include "rocksdb/rocksdb_namespace.h"
  14 #include "rocksdb/slice.h"
  15 #include "rocksdb/status.h"
  16
  17 namespace ROCKSDB_NAMESPACE {
  18
  19 // Class representing a wide column, which is defined as a pair of column name
  20 // and column value.
  21 class WideColumn {
  22  public:
  23   WideColumn() = default;
  24
  25   // Initializes a WideColumn object by forwarding the name and value
  26   // arguments to the corresponding member Slices. This makes it possible to
  27   // construct a WideColumn using combinations of const char*, const
  28   // std::string&, const Slice& etc., for example:
  29   //
  30   // constexpr char foo[] = "foo";
  31   // const std::string bar("bar");
  32   // WideColumn column(foo, bar);
  33   template <typename N, typename V>
  34   WideColumn(N&& name, V&& value)
  35       : name_(std::forward<N>(name)), value_(std::forward<V>(value)) {}
  36
  37   // Initializes a WideColumn object by forwarding the elements of
  38   // name_tuple and value_tuple to the constructors of the corresponding member
  39   // Slices. This makes it possible to initialize the Slices using the Slice
  40   // constructors that take more than one argument, for example:
  41   //
  42   // constexpr char foo_name[] = "foo_name";
  43   // constexpr char bar_value[] = "bar_value";
  44   // WideColumn column(std::piecewise_construct,
  45   //                   std::forward_as_tuple(foo_name, 3),
  46   //                   std::forward_as_tuple(bar_value, 3));
  47   template <typename NTuple, typename VTuple>
  48   WideColumn(std::piecewise_construct_t, NTuple&& name_tuple,
  49              VTuple&& value_tuple)
  50       : name_(std::make_from_tuple<Slice>(std::forward<NTuple>(name_tuple))),
  51         value_(std::make_from_tuple<Slice>(std::forward<VTuple>(value_tuple))) {
  52   }
  53
  54   const Slice& name() const { return name_; }
  55   const Slice& value() const { return value_; }
  56
  57   Slice& name() { return name_; }
  58   Slice& value() { return value_; }
  59
  60  private:
  61   Slice name_;
  62   Slice value_;
  63 };
  64
  65 // Note: column names and values are compared bytewise.
  66 inline bool operator==(const WideColumn& lhs, const WideColumn& rhs) {
  67   return lhs.name() == rhs.name() && lhs.value() == rhs.value();
  68 }
  69
  70 inline bool operator!=(const WideColumn& lhs, const WideColumn& rhs) {
  71   return !(lhs == rhs);
  72 }
  73
  74 inline std::ostream& operator<<(std::ostream& os, const WideColumn& column) {
  75   const bool hex =
  76       (os.flags() & std::ios_base::basefield) == std::ios_base::hex;
  77   os << column.name().ToString(hex) << ':' << column.value().ToString(hex);
  78
  79   return os;
  80 }
  81
  82 // A collection of wide columns.
  83 using WideColumns = std::vector<WideColumn>;
  84
  85 // The anonymous default wide column (an empty Slice).
  86 extern const Slice kDefaultWideColumnName;
  87
  88 // An empty set of wide columns.
  89 extern const WideColumns kNoWideColumns;
  90
  91 // A self-contained collection of wide columns. Used for the results of
  92 // wide-column queries.
  93 class PinnableWideColumns {
  94  public:
  95   const WideColumns& columns() const { return columns_; }
  96   size_t serialized_size() const { return value_.size(); }
  97
  98   void SetPlainValue(const Slice& value);
  99   void SetPlainValue(const Slice& value, Cleanable* cleanable);
 100
 101   Status SetWideColumnValue(const Slice& value);
 102   Status SetWideColumnValue(const Slice& value, Cleanable* cleanable);
 103
 104   void Reset();
 105
 106  private:
 107   void CopyValue(const Slice& value);
 108   void PinOrCopyValue(const Slice& value, Cleanable* cleanable);
 109   void CreateIndexForPlainValue();
 110   Status CreateIndexForWideColumns();
 111
 112   PinnableSlice value_;
 113   WideColumns columns_;
 114 };
 115
 116 inline void PinnableWideColumns::CopyValue(const Slice& value) {
 117   value_.PinSelf(value);
 118 }
 119
 120 inline void PinnableWideColumns::PinOrCopyValue(const Slice& value,
 121                                                 Cleanable* cleanable) {
 122   if (!cleanable) {
 123     CopyValue(value);
 124     return;
 125   }
 126
 127   value_.PinSlice(value, cleanable);
 128 }
 129
 130 inline void PinnableWideColumns::CreateIndexForPlainValue() {
 131   columns_ = WideColumns{{kDefaultWideColumnName, value_}};
 132 }
 133
 134 inline void PinnableWideColumns::SetPlainValue(const Slice& value) {
 135   CopyValue(value);
 136   CreateIndexForPlainValue();
 137 }
 138
 139 inline void PinnableWideColumns::SetPlainValue(const Slice& value,
 140                                                Cleanable* cleanable) {
 141   PinOrCopyValue(value, cleanable);
 142   CreateIndexForPlainValue();
 143 }
 144
 145 inline Status PinnableWideColumns::SetWideColumnValue(const Slice& value) {
 146   CopyValue(value);
 147   return CreateIndexForWideColumns();
 148 }
 149
 150 inline Status PinnableWideColumns::SetWideColumnValue(const Slice& value,
 151                                                       Cleanable* cleanable) {
 152   PinOrCopyValue(value, cleanable);
 153   return CreateIndexForWideColumns();
 154 }
 155
 156 inline void PinnableWideColumns::Reset() {
 157   value_.Reset();
 158   columns_.clear();
 159 }
 160
 161 inline bool operator==(const PinnableWideColumns& lhs,
 162                        const PinnableWideColumns& rhs) {
 163   return lhs.columns() == rhs.columns();
 164 }
 165
 166 inline bool operator!=(const PinnableWideColumns& lhs,
 167                        const PinnableWideColumns& rhs) {
 168   return !(lhs == rhs);
 169 }
 170
 171 }  // namespace ROCKSDB_NAMESPACE