/Users/deen/code/yugabyte-db/src/yb/docdb/primitive_value.h

Source (jump to first uncovered line)
// Copyright (c) YugaByte, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
// in compliance with the License.  You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software distributed under the License
// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
// or implied.  See the License for the specific language governing permissions and limitations
// under the License.
//

#ifndef YB_DOCDB_PRIMITIVE_VALUE_H_
#define YB_DOCDB_PRIMITIVE_VALUE_H_

#include <ostream>
#include <string>
#include <vector>

#include <glog/logging.h>

#include "yb/common/common_fwd.h"
#include "yb/common/column_id.h"
#include "yb/common/doc_hybrid_time.h"
#include "yb/common/hybrid_time.h"

#include "yb/docdb/docdb_fwd.h"

#include "yb/util/algorithm_util.h"
#include "yb/util/net/inetaddress.h"
#include "yb/util/slice.h"
#include "yb/util/strongly_typed_bool.h"
#include "yb/util/timestamp.h"
#include "yb/util/uuid.h"

namespace yb {
namespace docdb {

// Used for extending a list.
// PREPEND prepends the arguments one by one (PREPEND a b c) will prepend [c b a] to the list,
// while PREPEND_BLOCK prepends the arguments together, so it will prepend [a b c] to the list.
YB_DEFINE_ENUM(ListExtendOrder, (APPEND)(PREPEND_BLOCK)(PREPEND))

// A necessary use of a forward declaration to avoid circular inclusion.
class SubDocument;

enum class SystemColumnIds : ColumnIdRep {
  kLivenessColumn = 0  // Stores the TTL for QL rows inserted using an INSERT statement.
};

class PrimitiveValue {
 public:
  static const PrimitiveValue kInvalid;
  static const PrimitiveValue kTombstone;
  static const PrimitiveValue kObject;
  static const PrimitiveValue kLivenessColumn;

  // Flags for jsonb.
  // Indicates that the stored jsonb is the complete jsonb value and not a partial update to jsonb.
  static constexpr int64_t kCompleteJsonb = 1;

  PrimitiveValue();
  explicit PrimitiveValue(ValueType value_type);

  PrimitiveValue(const PrimitiveValue& other);

  PrimitiveValue(PrimitiveValue&& other) {
    MoveFrom(&other);
  }

  PrimitiveValue& operator =(const PrimitiveValue& other) {
    this->~PrimitiveValue();
    new(this) PrimitiveValue(other);
    return *this;
  }

  PrimitiveValue& operator =(PrimitiveValue&& other) {
    this->~PrimitiveValue();
    MoveFrom(&other);
    return *this;
  }

  explicit PrimitiveValue(const Slice& s,
                          SortOrder sort_order = SortOrder::kAscending,
                          bool is_collate = false);

  explicit PrimitiveValue(const std::string& s,
                          SortOrder sort_order = SortOrder::kAscending,
                          bool is_collate = false);

  explicit PrimitiveValue(const char* s,
                          SortOrder sort_order = SortOrder::kAscending,
                          bool is_collate = false);

  explicit PrimitiveValue(int64_t v, SortOrder sort_order = SortOrder::kAscending);

  explicit PrimitiveValue(const Timestamp& timestamp,
                          SortOrder sort_order = SortOrder::kAscending);

  explicit PrimitiveValue(const InetAddress& inetaddress,
                          SortOrder sort_order = SortOrder::kAscending);

  explicit PrimitiveValue(const Uuid& uuid,
                          SortOrder sort_order = SortOrder::kAscending);

  explicit PrimitiveValue(const HybridTime& hybrid_time);
  explicit PrimitiveValue(const DocHybridTime& hybrid_time);
  explicit PrimitiveValue(const ColumnId column_id);

  static PrimitiveValue NullValue(SortingType sorting);

  // Converts a SortingType to its SortOrder equivalent.
  // SortingType::kAscending and SortingType::kNotSpecified get
  // converted to SortOrder::kAscending.
  // SortingType::kDescending gets converted to SortOrder::kDescending.
  static SortOrder SortOrderFromColumnSchemaSortingType(SortingType sorting_type);

  // Construct a primitive value from a QLValuePB.
  static PrimitiveValue FromQLValuePB(const QLValuePB& value,
                                      SortingType sorting_type);

  // Set a primitive value in a QLValuePB.
  static void ToQLValuePB(const PrimitiveValue& pv,
                          const std::shared_ptr<QLType>& ql_type,
                          QLValuePB* ql_val);

  ValueType value_type() const { return type_; }

  void AppendToKey(KeyBytes* key_bytes) const;

  std::string ToValue() const;

  // Convert this value to a human-readable string for logging / debugging.
  std::string ToString(AutoDecodeKeys auto_decode_keys = AutoDecodeKeys::kFalse) const;

  ~PrimitiveValue();

  // Decodes a primitive value from the given slice representing a RocksDB key in our key encoding
  // format and consumes a prefix of the slice.
  static CHECKED_STATUS DecodeKey(rocksdb::Slice* slice, PrimitiveValue* out);
  CHECKED_STATUS DecodeFromKey(rocksdb::Slice* slice);

  // Decodes a primitive value from the given slice representing a RocksDB value in our value
  // encoding format. Expects the entire slice to be consumed and returns an error otherwise.
  CHECKED_STATUS DecodeFromValue(const rocksdb::Slice& rocksdb_slice);

  static PrimitiveValue Double(double d, SortOrder sort_order = SortOrder::kAscending);
  static PrimitiveValue Float(float f, SortOrder sort_order = SortOrder::kAscending);
  // decimal_str represents a human readable string representing the decimal number, e.g. "0.03".
  static PrimitiveValue Decimal(const std::string& decimal_str, SortOrder sort_order);
  static PrimitiveValue VarInt(const std::string& varint_str, SortOrder sort_order);
  static PrimitiveValue ArrayIndex(int64_t index);
  static PrimitiveValue UInt16Hash(uint16_t hash);
  static PrimitiveValue SystemColumnId(ColumnId column_id);
  static PrimitiveValue SystemColumnId(SystemColumnIds system_column_id);
  static PrimitiveValue Int32(int32_t v, SortOrder sort_order = SortOrder::kAscending);
  static PrimitiveValue UInt32(uint32_t v, SortOrder sort_order = SortOrder::kAscending);
  static PrimitiveValue UInt64(uint64_t v, SortOrder sort_order = SortOrder::kAscending);
  static PrimitiveValue TransactionId(Uuid transaction_id);
  static PrimitiveValue TableId(Uuid table_id);
  static PrimitiveValue PgTableOid(const PgTableOid pgtable_id);
  static PrimitiveValue Jsonb(const std::string& json);
  static PrimitiveValue GinNull(uint8_t v);

  KeyBytes ToKeyBytes() const;

  DocHybridTime hybrid_time() const;

  // As strange as it may sound, an instance of this class may sometimes contain a single byte that
  // indicates an empty data structure of a certain type (object, array), or a tombstone. This
  // method can tell whether what's stored here is an actual primitive value.
  bool IsPrimitive() const;

  bool IsTombstoneOrPrimitive() const;

  bool IsInfinity() const;

  int CompareTo(const PrimitiveValue& other) const;

  // Assuming this PrimitiveValue represents a string, return a Slice pointing to it.
  // This returns a YB slice, not a RocksDB slice, based on what was needed when this function was
  // implemented. This distinction should go away if we merge RocksDB and YB Slice classes.
  Slice GetStringAsSlice() const {
    DCHECK(IsString());
    return Slice(str_val_);
  }

  bool IsInt64() const;

  bool IsString() const;

  bool IsDouble() const;

  const std::string& GetString() const {
    DCHECK(IsString());
    return str_val_;
  }

  int32_t GetInt32() const;

  uint32_t GetUInt32() const;

  int64_t GetInt64() const;

  uint64_t GetUInt64() const;

  uint16_t GetUInt16() const;

  double GetDouble() const {
    DCHECK(IsDouble());
    return double_val_;
  }

  float GetFloat() const;

  const std::string& GetDecimal() const;

  const std::string& GetVarInt() const;

  Timestamp GetTimestamp() const;

  const InetAddress* GetInetaddress() const;

  const std::string& GetJson() const;

  const Uuid& GetUuid() const;

  ColumnId GetColumnId() const;

  uint8_t GetGinNull() const;

  bool operator <(const PrimitiveValue& other) const {
    return CompareTo(other) < 0;
  }

  bool operator <=(const PrimitiveValue& other) const {
    return CompareTo(other) <= 0;
  }

  bool operator >(const PrimitiveValue& other) const {
    return CompareTo(other) > 0;
  }

  bool operator >=(const PrimitiveValue& other) const {
    return CompareTo(other) >= 0;
  }

  bool operator==(const PrimitiveValue& other) const;

  bool operator!=(const PrimitiveValue& other) const { return !(*this == other); }

  ListExtendOrder GetExtendOrder() const {
    return extend_order_;
  }

  int64_t GetTtl() const {
    return ttl_seconds_;
  }

  bool IsWriteTimeSet() const {
    return write_time_ != kUninitializedWriteTime;
  }

  int64_t GetWriteTime() const {
    DCHECK_NE(kUninitializedWriteTime, write_time_);
    return write_time_;
  }

  void SetTtl(const int64_t ttl_seconds) {
    ttl_seconds_ = ttl_seconds;
  }

  void SetExtendOrder(const ListExtendOrder extend_order) const {
    extend_order_ = extend_order;
  }

  void SetWriteTime(const int64_t write_time) {
    write_time_ = write_time;
  }
  typedef std::vector<PrimitiveValue> FrozenContainer;

 protected:

  static constexpr int64_t kUninitializedWriteTime = std::numeric_limits<int64_t>::min();

  // Column attributes.
  int64_t ttl_seconds_ = -1;
  int64_t write_time_ = kUninitializedWriteTime;

  // TODO: make PrimitiveValue extend SubDocument and put this field
  // in SubDocument.
  // This field gives the extension order of elements of a list and
  // is applicable only to SubDocuments of type kArray.
  mutable ListExtendOrder extend_order_ = ListExtendOrder::APPEND;

  ValueType type_;

  // TODO: do we have to worry about alignment here?
  union {
    int32_t int32_val_;
    uint32_t uint32_val_;
    int64_t int64_val_;
    uint64_t uint64_val_;
    uint16_t uint16_val_;
    DocHybridTime hybrid_time_val_;
    std::string str_val_;
    float float_val_;
    double double_val_;
    Timestamp timestamp_val_;
    InetAddress* inetaddress_val_;
    Uuid uuid_val_;
    FrozenContainer* frozen_val_;
    // This is used in SubDocument to hold a pointer to a map or a vector.
    void* complex_data_structure_;
    ColumnId column_id_val_;
    std::string decimal_val_;
    std::string varint_val_;
    std::string json_val_;
    uint8_t gin_null_val_;
  };

 private:

  // This is used in both the move constructor and the move assignment operator. Assumes this object
  // has not been constructed, or that the destructor has just been called.
  void MoveFrom(PrimitiveValue* other);
};

inline std::ostream& operator<<(std::ostream& out, const PrimitiveValue& primitive_value) {
  out << primitive_value.ToString();
  return out;
}

inline std::ostream& operator<<(std::ostream& out, const SortOrder sort_order) {
  string sort_order_name = sort_order == SortOrder::kAscending ? "kAscending" : "kDescending";
  out << sort_order_name;
  return out;
}

// A variadic template utility for creating vectors with PrimitiveValue elements out of arbitrary
// sequences of arguments of supported types.
inline void AppendPrimitiveValues(std::vector<PrimitiveValue>* dest) {}

template <class T, class ...U>
inline void AppendPrimitiveValues(std::vector<PrimitiveValue>* dest,
                                  T first_arg,
                                  U... more_args) {
  dest->emplace_back(first_arg);
  AppendPrimitiveValues(dest, more_args...);
}

template <class ...T>
inline std::vector<PrimitiveValue> PrimitiveValues(T... args) {
  std::vector<PrimitiveValue> v;
  AppendPrimitiveValues(&v, args...);
  return v;
}

}  // namespace docdb
}  // namespace yb

#endif  // YB_DOCDB_PRIMITIVE_VALUE_H_

YugabyteDB (2.13.0.0-b42, bfc6a6643e7399ac8a0e81d06a3ee6d6571b33ab)

Coverage Report

Created: 2022-03-09 17:30