// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: greptime/v1/row.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_greptime_2fv1_2frow_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_greptime_2fv1_2frow_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3021000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3021006 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/unknown_field_set.h>
#include "greptime/v1/common.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_greptime_2fv1_2frow_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_greptime_2fv1_2frow_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_greptime_2fv1_2frow_2eproto;
namespace greptime {
namespace v1 {
class ColumnSchema;
struct ColumnSchemaDefaultTypeInternal;
extern ColumnSchemaDefaultTypeInternal _ColumnSchema_default_instance_;
class Row;
struct RowDefaultTypeInternal;
extern RowDefaultTypeInternal _Row_default_instance_;
class Rows;
struct RowsDefaultTypeInternal;
extern RowsDefaultTypeInternal _Rows_default_instance_;
class Value;
struct ValueDefaultTypeInternal;
extern ValueDefaultTypeInternal _Value_default_instance_;
}  // namespace v1
}  // namespace greptime
PROTOBUF_NAMESPACE_OPEN
template<> ::greptime::v1::ColumnSchema* Arena::CreateMaybeMessage<::greptime::v1::ColumnSchema>(Arena*);
template<> ::greptime::v1::Row* Arena::CreateMaybeMessage<::greptime::v1::Row>(Arena*);
template<> ::greptime::v1::Rows* Arena::CreateMaybeMessage<::greptime::v1::Rows>(Arena*);
template<> ::greptime::v1::Value* Arena::CreateMaybeMessage<::greptime::v1::Value>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace greptime {
namespace v1 {

// ===================================================================

class Rows final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:greptime.v1.Rows) */ {
 public:
  inline Rows() : Rows(nullptr) {}
  ~Rows() override;
  explicit PROTOBUF_CONSTEXPR Rows(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Rows(const Rows& from);
  Rows(Rows&& from) noexcept
    : Rows() {
    *this = ::std::move(from);
  }

  inline Rows& operator=(const Rows& from) {
    CopyFrom(from);
    return *this;
  }
  inline Rows& operator=(Rows&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Rows& default_instance() {
    return *internal_default_instance();
  }
  static inline const Rows* internal_default_instance() {
    return reinterpret_cast<const Rows*>(
               &_Rows_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(Rows& a, Rows& b) {
    a.Swap(&b);
  }
  inline void Swap(Rows* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Rows* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Rows* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Rows>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Rows& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Rows& from) {
    Rows::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Rows* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "greptime.v1.Rows";
  }
  protected:
  explicit Rows(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kSchemaFieldNumber = 1,
    kRowsFieldNumber = 2,
  };
  // repeated .greptime.v1.ColumnSchema schema = 1;
  int schema_size() const;
  private:
  int _internal_schema_size() const;
  public:
  void clear_schema();
  ::greptime::v1::ColumnSchema* mutable_schema(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::ColumnSchema >*
      mutable_schema();
  private:
  const ::greptime::v1::ColumnSchema& _internal_schema(int index) const;
  ::greptime::v1::ColumnSchema* _internal_add_schema();
  public:
  const ::greptime::v1::ColumnSchema& schema(int index) const;
  ::greptime::v1::ColumnSchema* add_schema();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::ColumnSchema >&
      schema() const;

  // repeated .greptime.v1.Row rows = 2;
  int rows_size() const;
  private:
  int _internal_rows_size() const;
  public:
  void clear_rows();
  ::greptime::v1::Row* mutable_rows(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Row >*
      mutable_rows();
  private:
  const ::greptime::v1::Row& _internal_rows(int index) const;
  ::greptime::v1::Row* _internal_add_rows();
  public:
  const ::greptime::v1::Row& rows(int index) const;
  ::greptime::v1::Row* add_rows();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Row >&
      rows() const;

  // @@protoc_insertion_point(class_scope:greptime.v1.Rows)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::ColumnSchema > schema_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Row > rows_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_greptime_2fv1_2frow_2eproto;
};
// -------------------------------------------------------------------

class ColumnSchema final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:greptime.v1.ColumnSchema) */ {
 public:
  inline ColumnSchema() : ColumnSchema(nullptr) {}
  ~ColumnSchema() override;
  explicit PROTOBUF_CONSTEXPR ColumnSchema(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ColumnSchema(const ColumnSchema& from);
  ColumnSchema(ColumnSchema&& from) noexcept
    : ColumnSchema() {
    *this = ::std::move(from);
  }

  inline ColumnSchema& operator=(const ColumnSchema& from) {
    CopyFrom(from);
    return *this;
  }
  inline ColumnSchema& operator=(ColumnSchema&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ColumnSchema& default_instance() {
    return *internal_default_instance();
  }
  static inline const ColumnSchema* internal_default_instance() {
    return reinterpret_cast<const ColumnSchema*>(
               &_ColumnSchema_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(ColumnSchema& a, ColumnSchema& b) {
    a.Swap(&b);
  }
  inline void Swap(ColumnSchema* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ColumnSchema* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  ColumnSchema* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ColumnSchema>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ColumnSchema& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ColumnSchema& from) {
    ColumnSchema::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ColumnSchema* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "greptime.v1.ColumnSchema";
  }
  protected:
  explicit ColumnSchema(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kColumnNameFieldNumber = 1,
    kDatatypeFieldNumber = 2,
    kSemanticTypeFieldNumber = 3,
  };
  // string column_name = 1;
  void clear_column_name();
  const std::string& column_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_column_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_column_name();
  PROTOBUF_NODISCARD std::string* release_column_name();
  void set_allocated_column_name(std::string* column_name);
  private:
  const std::string& _internal_column_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_column_name(const std::string& value);
  std::string* _internal_mutable_column_name();
  public:

  // .greptime.v1.ColumnDataType datatype = 2;
  void clear_datatype();
  ::greptime::v1::ColumnDataType datatype() const;
  void set_datatype(::greptime::v1::ColumnDataType value);
  private:
  ::greptime::v1::ColumnDataType _internal_datatype() const;
  void _internal_set_datatype(::greptime::v1::ColumnDataType value);
  public:

  // .greptime.v1.SemanticType semantic_type = 3;
  void clear_semantic_type();
  ::greptime::v1::SemanticType semantic_type() const;
  void set_semantic_type(::greptime::v1::SemanticType value);
  private:
  ::greptime::v1::SemanticType _internal_semantic_type() const;
  void _internal_set_semantic_type(::greptime::v1::SemanticType value);
  public:

  // @@protoc_insertion_point(class_scope:greptime.v1.ColumnSchema)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr column_name_;
    int datatype_;
    int semantic_type_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_greptime_2fv1_2frow_2eproto;
};
// -------------------------------------------------------------------

class Row final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:greptime.v1.Row) */ {
 public:
  inline Row() : Row(nullptr) {}
  ~Row() override;
  explicit PROTOBUF_CONSTEXPR Row(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Row(const Row& from);
  Row(Row&& from) noexcept
    : Row() {
    *this = ::std::move(from);
  }

  inline Row& operator=(const Row& from) {
    CopyFrom(from);
    return *this;
  }
  inline Row& operator=(Row&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Row& default_instance() {
    return *internal_default_instance();
  }
  static inline const Row* internal_default_instance() {
    return reinterpret_cast<const Row*>(
               &_Row_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(Row& a, Row& b) {
    a.Swap(&b);
  }
  inline void Swap(Row* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Row* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Row* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Row>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Row& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Row& from) {
    Row::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Row* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "greptime.v1.Row";
  }
  protected:
  explicit Row(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kValuesFieldNumber = 1,
  };
  // repeated .greptime.v1.Value values = 1;
  int values_size() const;
  private:
  int _internal_values_size() const;
  public:
  void clear_values();
  ::greptime::v1::Value* mutable_values(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Value >*
      mutable_values();
  private:
  const ::greptime::v1::Value& _internal_values(int index) const;
  ::greptime::v1::Value* _internal_add_values();
  public:
  const ::greptime::v1::Value& values(int index) const;
  ::greptime::v1::Value* add_values();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Value >&
      values() const;

  // @@protoc_insertion_point(class_scope:greptime.v1.Row)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Value > values_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_greptime_2fv1_2frow_2eproto;
};
// -------------------------------------------------------------------

class Value final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:greptime.v1.Value) */ {
 public:
  inline Value() : Value(nullptr) {}
  ~Value() override;
  explicit PROTOBUF_CONSTEXPR Value(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Value(const Value& from);
  Value(Value&& from) noexcept
    : Value() {
    *this = ::std::move(from);
  }

  inline Value& operator=(const Value& from) {
    CopyFrom(from);
    return *this;
  }
  inline Value& operator=(Value&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Value& default_instance() {
    return *internal_default_instance();
  }
  enum ValueDataCase {
    kI8Value = 1,
    kI16Value = 2,
    kI32Value = 3,
    kI64Value = 4,
    kU8Value = 5,
    kU16Value = 6,
    kU32Value = 7,
    kU64Value = 8,
    kF32Value = 9,
    kF64Value = 10,
    kBoolValue = 11,
    kBinaryValue = 12,
    kStringValue = 13,
    kDateValue = 14,
    kDatetimeValue = 15,
    kTimestampSecondValue = 16,
    kTimestampMillisecondValue = 17,
    kTimestampMicrosecondValue = 18,
    kTimestampNanosecondValue = 19,
    kTimeSecondValue = 20,
    kTimeMillisecondValue = 21,
    kTimeMicrosecondValue = 22,
    kTimeNanosecondValue = 23,
    kIntervalYearMonthValues = 24,
    kIntervalDayTimeValues = 25,
    kIntervalMonthDayNanoValues = 26,
    kDurationSecondValue = 27,
    kDurationMillisecondValue = 28,
    kDurationMicrosecondValue = 29,
    kDurationNanosecondValue = 30,
    VALUE_DATA_NOT_SET = 0,
  };

  static inline const Value* internal_default_instance() {
    return reinterpret_cast<const Value*>(
               &_Value_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(Value& a, Value& b) {
    a.Swap(&b);
  }
  inline void Swap(Value* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Value* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Value* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Value>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Value& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Value& from) {
    Value::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Value* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "greptime.v1.Value";
  }
  protected:
  explicit Value(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kI8ValueFieldNumber = 1,
    kI16ValueFieldNumber = 2,
    kI32ValueFieldNumber = 3,
    kI64ValueFieldNumber = 4,
    kU8ValueFieldNumber = 5,
    kU16ValueFieldNumber = 6,
    kU32ValueFieldNumber = 7,
    kU64ValueFieldNumber = 8,
    kF32ValueFieldNumber = 9,
    kF64ValueFieldNumber = 10,
    kBoolValueFieldNumber = 11,
    kBinaryValueFieldNumber = 12,
    kStringValueFieldNumber = 13,
    kDateValueFieldNumber = 14,
    kDatetimeValueFieldNumber = 15,
    kTimestampSecondValueFieldNumber = 16,
    kTimestampMillisecondValueFieldNumber = 17,
    kTimestampMicrosecondValueFieldNumber = 18,
    kTimestampNanosecondValueFieldNumber = 19,
    kTimeSecondValueFieldNumber = 20,
    kTimeMillisecondValueFieldNumber = 21,
    kTimeMicrosecondValueFieldNumber = 22,
    kTimeNanosecondValueFieldNumber = 23,
    kIntervalYearMonthValuesFieldNumber = 24,
    kIntervalDayTimeValuesFieldNumber = 25,
    kIntervalMonthDayNanoValuesFieldNumber = 26,
    kDurationSecondValueFieldNumber = 27,
    kDurationMillisecondValueFieldNumber = 28,
    kDurationMicrosecondValueFieldNumber = 29,
    kDurationNanosecondValueFieldNumber = 30,
  };
  // int32 i8_value = 1;
  bool has_i8_value() const;
  private:
  bool _internal_has_i8_value() const;
  public:
  void clear_i8_value();
  int32_t i8_value() const;
  void set_i8_value(int32_t value);
  private:
  int32_t _internal_i8_value() const;
  void _internal_set_i8_value(int32_t value);
  public:

  // int32 i16_value = 2;
  bool has_i16_value() const;
  private:
  bool _internal_has_i16_value() const;
  public:
  void clear_i16_value();
  int32_t i16_value() const;
  void set_i16_value(int32_t value);
  private:
  int32_t _internal_i16_value() const;
  void _internal_set_i16_value(int32_t value);
  public:

  // int32 i32_value = 3;
  bool has_i32_value() const;
  private:
  bool _internal_has_i32_value() const;
  public:
  void clear_i32_value();
  int32_t i32_value() const;
  void set_i32_value(int32_t value);
  private:
  int32_t _internal_i32_value() const;
  void _internal_set_i32_value(int32_t value);
  public:

  // int64 i64_value = 4;
  bool has_i64_value() const;
  private:
  bool _internal_has_i64_value() const;
  public:
  void clear_i64_value();
  int64_t i64_value() const;
  void set_i64_value(int64_t value);
  private:
  int64_t _internal_i64_value() const;
  void _internal_set_i64_value(int64_t value);
  public:

  // uint32 u8_value = 5;
  bool has_u8_value() const;
  private:
  bool _internal_has_u8_value() const;
  public:
  void clear_u8_value();
  uint32_t u8_value() const;
  void set_u8_value(uint32_t value);
  private:
  uint32_t _internal_u8_value() const;
  void _internal_set_u8_value(uint32_t value);
  public:

  // uint32 u16_value = 6;
  bool has_u16_value() const;
  private:
  bool _internal_has_u16_value() const;
  public:
  void clear_u16_value();
  uint32_t u16_value() const;
  void set_u16_value(uint32_t value);
  private:
  uint32_t _internal_u16_value() const;
  void _internal_set_u16_value(uint32_t value);
  public:

  // uint32 u32_value = 7;
  bool has_u32_value() const;
  private:
  bool _internal_has_u32_value() const;
  public:
  void clear_u32_value();
  uint32_t u32_value() const;
  void set_u32_value(uint32_t value);
  private:
  uint32_t _internal_u32_value() const;
  void _internal_set_u32_value(uint32_t value);
  public:

  // uint64 u64_value = 8;
  bool has_u64_value() const;
  private:
  bool _internal_has_u64_value() const;
  public:
  void clear_u64_value();
  uint64_t u64_value() const;
  void set_u64_value(uint64_t value);
  private:
  uint64_t _internal_u64_value() const;
  void _internal_set_u64_value(uint64_t value);
  public:

  // float f32_value = 9;
  bool has_f32_value() const;
  private:
  bool _internal_has_f32_value() const;
  public:
  void clear_f32_value();
  float f32_value() const;
  void set_f32_value(float value);
  private:
  float _internal_f32_value() const;
  void _internal_set_f32_value(float value);
  public:

  // double f64_value = 10;
  bool has_f64_value() const;
  private:
  bool _internal_has_f64_value() const;
  public:
  void clear_f64_value();
  double f64_value() const;
  void set_f64_value(double value);
  private:
  double _internal_f64_value() const;
  void _internal_set_f64_value(double value);
  public:

  // bool bool_value = 11;
  bool has_bool_value() const;
  private:
  bool _internal_has_bool_value() const;
  public:
  void clear_bool_value();
  bool bool_value() const;
  void set_bool_value(bool value);
  private:
  bool _internal_bool_value() const;
  void _internal_set_bool_value(bool value);
  public:

  // bytes binary_value = 12;
  bool has_binary_value() const;
  private:
  bool _internal_has_binary_value() const;
  public:
  void clear_binary_value();
  const std::string& binary_value() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_binary_value(ArgT0&& arg0, ArgT... args);
  std::string* mutable_binary_value();
  PROTOBUF_NODISCARD std::string* release_binary_value();
  void set_allocated_binary_value(std::string* binary_value);
  private:
  const std::string& _internal_binary_value() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_binary_value(const std::string& value);
  std::string* _internal_mutable_binary_value();
  public:

  // string string_value = 13;
  bool has_string_value() const;
  private:
  bool _internal_has_string_value() const;
  public:
  void clear_string_value();
  const std::string& string_value() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_string_value(ArgT0&& arg0, ArgT... args);
  std::string* mutable_string_value();
  PROTOBUF_NODISCARD std::string* release_string_value();
  void set_allocated_string_value(std::string* string_value);
  private:
  const std::string& _internal_string_value() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_string_value(const std::string& value);
  std::string* _internal_mutable_string_value();
  public:

  // int32 date_value = 14;
  bool has_date_value() const;
  private:
  bool _internal_has_date_value() const;
  public:
  void clear_date_value();
  int32_t date_value() const;
  void set_date_value(int32_t value);
  private:
  int32_t _internal_date_value() const;
  void _internal_set_date_value(int32_t value);
  public:

  // int64 datetime_value = 15;
  bool has_datetime_value() const;
  private:
  bool _internal_has_datetime_value() const;
  public:
  void clear_datetime_value();
  int64_t datetime_value() const;
  void set_datetime_value(int64_t value);
  private:
  int64_t _internal_datetime_value() const;
  void _internal_set_datetime_value(int64_t value);
  public:

  // int64 timestamp_second_value = 16;
  bool has_timestamp_second_value() const;
  private:
  bool _internal_has_timestamp_second_value() const;
  public:
  void clear_timestamp_second_value();
  int64_t timestamp_second_value() const;
  void set_timestamp_second_value(int64_t value);
  private:
  int64_t _internal_timestamp_second_value() const;
  void _internal_set_timestamp_second_value(int64_t value);
  public:

  // int64 timestamp_millisecond_value = 17;
  bool has_timestamp_millisecond_value() const;
  private:
  bool _internal_has_timestamp_millisecond_value() const;
  public:
  void clear_timestamp_millisecond_value();
  int64_t timestamp_millisecond_value() const;
  void set_timestamp_millisecond_value(int64_t value);
  private:
  int64_t _internal_timestamp_millisecond_value() const;
  void _internal_set_timestamp_millisecond_value(int64_t value);
  public:

  // int64 timestamp_microsecond_value = 18;
  bool has_timestamp_microsecond_value() const;
  private:
  bool _internal_has_timestamp_microsecond_value() const;
  public:
  void clear_timestamp_microsecond_value();
  int64_t timestamp_microsecond_value() const;
  void set_timestamp_microsecond_value(int64_t value);
  private:
  int64_t _internal_timestamp_microsecond_value() const;
  void _internal_set_timestamp_microsecond_value(int64_t value);
  public:

  // int64 timestamp_nanosecond_value = 19;
  bool has_timestamp_nanosecond_value() const;
  private:
  bool _internal_has_timestamp_nanosecond_value() const;
  public:
  void clear_timestamp_nanosecond_value();
  int64_t timestamp_nanosecond_value() const;
  void set_timestamp_nanosecond_value(int64_t value);
  private:
  int64_t _internal_timestamp_nanosecond_value() const;
  void _internal_set_timestamp_nanosecond_value(int64_t value);
  public:

  // int64 time_second_value = 20;
  bool has_time_second_value() const;
  private:
  bool _internal_has_time_second_value() const;
  public:
  void clear_time_second_value();
  int64_t time_second_value() const;
  void set_time_second_value(int64_t value);
  private:
  int64_t _internal_time_second_value() const;
  void _internal_set_time_second_value(int64_t value);
  public:

  // int64 time_millisecond_value = 21;
  bool has_time_millisecond_value() const;
  private:
  bool _internal_has_time_millisecond_value() const;
  public:
  void clear_time_millisecond_value();
  int64_t time_millisecond_value() const;
  void set_time_millisecond_value(int64_t value);
  private:
  int64_t _internal_time_millisecond_value() const;
  void _internal_set_time_millisecond_value(int64_t value);
  public:

  // int64 time_microsecond_value = 22;
  bool has_time_microsecond_value() const;
  private:
  bool _internal_has_time_microsecond_value() const;
  public:
  void clear_time_microsecond_value();
  int64_t time_microsecond_value() const;
  void set_time_microsecond_value(int64_t value);
  private:
  int64_t _internal_time_microsecond_value() const;
  void _internal_set_time_microsecond_value(int64_t value);
  public:

  // int64 time_nanosecond_value = 23;
  bool has_time_nanosecond_value() const;
  private:
  bool _internal_has_time_nanosecond_value() const;
  public:
  void clear_time_nanosecond_value();
  int64_t time_nanosecond_value() const;
  void set_time_nanosecond_value(int64_t value);
  private:
  int64_t _internal_time_nanosecond_value() const;
  void _internal_set_time_nanosecond_value(int64_t value);
  public:

  // int32 interval_year_month_values = 24;
  bool has_interval_year_month_values() const;
  private:
  bool _internal_has_interval_year_month_values() const;
  public:
  void clear_interval_year_month_values();
  int32_t interval_year_month_values() const;
  void set_interval_year_month_values(int32_t value);
  private:
  int32_t _internal_interval_year_month_values() const;
  void _internal_set_interval_year_month_values(int32_t value);
  public:

  // int64 interval_day_time_values = 25;
  bool has_interval_day_time_values() const;
  private:
  bool _internal_has_interval_day_time_values() const;
  public:
  void clear_interval_day_time_values();
  int64_t interval_day_time_values() const;
  void set_interval_day_time_values(int64_t value);
  private:
  int64_t _internal_interval_day_time_values() const;
  void _internal_set_interval_day_time_values(int64_t value);
  public:

  // .greptime.v1.IntervalMonthDayNano interval_month_day_nano_values = 26;
  bool has_interval_month_day_nano_values() const;
  private:
  bool _internal_has_interval_month_day_nano_values() const;
  public:
  void clear_interval_month_day_nano_values();
  const ::greptime::v1::IntervalMonthDayNano& interval_month_day_nano_values() const;
  PROTOBUF_NODISCARD ::greptime::v1::IntervalMonthDayNano* release_interval_month_day_nano_values();
  ::greptime::v1::IntervalMonthDayNano* mutable_interval_month_day_nano_values();
  void set_allocated_interval_month_day_nano_values(::greptime::v1::IntervalMonthDayNano* interval_month_day_nano_values);
  private:
  const ::greptime::v1::IntervalMonthDayNano& _internal_interval_month_day_nano_values() const;
  ::greptime::v1::IntervalMonthDayNano* _internal_mutable_interval_month_day_nano_values();
  public:
  void unsafe_arena_set_allocated_interval_month_day_nano_values(
      ::greptime::v1::IntervalMonthDayNano* interval_month_day_nano_values);
  ::greptime::v1::IntervalMonthDayNano* unsafe_arena_release_interval_month_day_nano_values();

  // int64 duration_second_value = 27;
  bool has_duration_second_value() const;
  private:
  bool _internal_has_duration_second_value() const;
  public:
  void clear_duration_second_value();
  int64_t duration_second_value() const;
  void set_duration_second_value(int64_t value);
  private:
  int64_t _internal_duration_second_value() const;
  void _internal_set_duration_second_value(int64_t value);
  public:

  // int64 duration_millisecond_value = 28;
  bool has_duration_millisecond_value() const;
  private:
  bool _internal_has_duration_millisecond_value() const;
  public:
  void clear_duration_millisecond_value();
  int64_t duration_millisecond_value() const;
  void set_duration_millisecond_value(int64_t value);
  private:
  int64_t _internal_duration_millisecond_value() const;
  void _internal_set_duration_millisecond_value(int64_t value);
  public:

  // int64 duration_microsecond_value = 29;
  bool has_duration_microsecond_value() const;
  private:
  bool _internal_has_duration_microsecond_value() const;
  public:
  void clear_duration_microsecond_value();
  int64_t duration_microsecond_value() const;
  void set_duration_microsecond_value(int64_t value);
  private:
  int64_t _internal_duration_microsecond_value() const;
  void _internal_set_duration_microsecond_value(int64_t value);
  public:

  // int64 duration_nanosecond_value = 30;
  bool has_duration_nanosecond_value() const;
  private:
  bool _internal_has_duration_nanosecond_value() const;
  public:
  void clear_duration_nanosecond_value();
  int64_t duration_nanosecond_value() const;
  void set_duration_nanosecond_value(int64_t value);
  private:
  int64_t _internal_duration_nanosecond_value() const;
  void _internal_set_duration_nanosecond_value(int64_t value);
  public:

  void clear_value_data();
  ValueDataCase value_data_case() const;
  // @@protoc_insertion_point(class_scope:greptime.v1.Value)
 private:
  class _Internal;
  void set_has_i8_value();
  void set_has_i16_value();
  void set_has_i32_value();
  void set_has_i64_value();
  void set_has_u8_value();
  void set_has_u16_value();
  void set_has_u32_value();
  void set_has_u64_value();
  void set_has_f32_value();
  void set_has_f64_value();
  void set_has_bool_value();
  void set_has_binary_value();
  void set_has_string_value();
  void set_has_date_value();
  void set_has_datetime_value();
  void set_has_timestamp_second_value();
  void set_has_timestamp_millisecond_value();
  void set_has_timestamp_microsecond_value();
  void set_has_timestamp_nanosecond_value();
  void set_has_time_second_value();
  void set_has_time_millisecond_value();
  void set_has_time_microsecond_value();
  void set_has_time_nanosecond_value();
  void set_has_interval_year_month_values();
  void set_has_interval_day_time_values();
  void set_has_interval_month_day_nano_values();
  void set_has_duration_second_value();
  void set_has_duration_millisecond_value();
  void set_has_duration_microsecond_value();
  void set_has_duration_nanosecond_value();

  inline bool has_value_data() const;
  inline void clear_has_value_data();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    union ValueDataUnion {
      constexpr ValueDataUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      int32_t i8_value_;
      int32_t i16_value_;
      int32_t i32_value_;
      int64_t i64_value_;
      uint32_t u8_value_;
      uint32_t u16_value_;
      uint32_t u32_value_;
      uint64_t u64_value_;
      float f32_value_;
      double f64_value_;
      bool bool_value_;
      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr binary_value_;
      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_value_;
      int32_t date_value_;
      int64_t datetime_value_;
      int64_t timestamp_second_value_;
      int64_t timestamp_millisecond_value_;
      int64_t timestamp_microsecond_value_;
      int64_t timestamp_nanosecond_value_;
      int64_t time_second_value_;
      int64_t time_millisecond_value_;
      int64_t time_microsecond_value_;
      int64_t time_nanosecond_value_;
      int32_t interval_year_month_values_;
      int64_t interval_day_time_values_;
      ::greptime::v1::IntervalMonthDayNano* interval_month_day_nano_values_;
      int64_t duration_second_value_;
      int64_t duration_millisecond_value_;
      int64_t duration_microsecond_value_;
      int64_t duration_nanosecond_value_;
    } value_data_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_greptime_2fv1_2frow_2eproto;
};
// ===================================================================


// ===================================================================

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// Rows

// repeated .greptime.v1.ColumnSchema schema = 1;
inline int Rows::_internal_schema_size() const {
  return _impl_.schema_.size();
}
inline int Rows::schema_size() const {
  return _internal_schema_size();
}
inline void Rows::clear_schema() {
  _impl_.schema_.Clear();
}
inline ::greptime::v1::ColumnSchema* Rows::mutable_schema(int index) {
  // @@protoc_insertion_point(field_mutable:greptime.v1.Rows.schema)
  return _impl_.schema_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::ColumnSchema >*
Rows::mutable_schema() {
  // @@protoc_insertion_point(field_mutable_list:greptime.v1.Rows.schema)
  return &_impl_.schema_;
}
inline const ::greptime::v1::ColumnSchema& Rows::_internal_schema(int index) const {
  return _impl_.schema_.Get(index);
}
inline const ::greptime::v1::ColumnSchema& Rows::schema(int index) const {
  // @@protoc_insertion_point(field_get:greptime.v1.Rows.schema)
  return _internal_schema(index);
}
inline ::greptime::v1::ColumnSchema* Rows::_internal_add_schema() {
  return _impl_.schema_.Add();
}
inline ::greptime::v1::ColumnSchema* Rows::add_schema() {
  ::greptime::v1::ColumnSchema* _add = _internal_add_schema();
  // @@protoc_insertion_point(field_add:greptime.v1.Rows.schema)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::ColumnSchema >&
Rows::schema() const {
  // @@protoc_insertion_point(field_list:greptime.v1.Rows.schema)
  return _impl_.schema_;
}

// repeated .greptime.v1.Row rows = 2;
inline int Rows::_internal_rows_size() const {
  return _impl_.rows_.size();
}
inline int Rows::rows_size() const {
  return _internal_rows_size();
}
inline void Rows::clear_rows() {
  _impl_.rows_.Clear();
}
inline ::greptime::v1::Row* Rows::mutable_rows(int index) {
  // @@protoc_insertion_point(field_mutable:greptime.v1.Rows.rows)
  return _impl_.rows_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Row >*
Rows::mutable_rows() {
  // @@protoc_insertion_point(field_mutable_list:greptime.v1.Rows.rows)
  return &_impl_.rows_;
}
inline const ::greptime::v1::Row& Rows::_internal_rows(int index) const {
  return _impl_.rows_.Get(index);
}
inline const ::greptime::v1::Row& Rows::rows(int index) const {
  // @@protoc_insertion_point(field_get:greptime.v1.Rows.rows)
  return _internal_rows(index);
}
inline ::greptime::v1::Row* Rows::_internal_add_rows() {
  return _impl_.rows_.Add();
}
inline ::greptime::v1::Row* Rows::add_rows() {
  ::greptime::v1::Row* _add = _internal_add_rows();
  // @@protoc_insertion_point(field_add:greptime.v1.Rows.rows)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Row >&
Rows::rows() const {
  // @@protoc_insertion_point(field_list:greptime.v1.Rows.rows)
  return _impl_.rows_;
}

// -------------------------------------------------------------------

// ColumnSchema

// string column_name = 1;
inline void ColumnSchema::clear_column_name() {
  _impl_.column_name_.ClearToEmpty();
}
inline const std::string& ColumnSchema::column_name() const {
  // @@protoc_insertion_point(field_get:greptime.v1.ColumnSchema.column_name)
  return _internal_column_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ColumnSchema::set_column_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.column_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:greptime.v1.ColumnSchema.column_name)
}
inline std::string* ColumnSchema::mutable_column_name() {
  std::string* _s = _internal_mutable_column_name();
  // @@protoc_insertion_point(field_mutable:greptime.v1.ColumnSchema.column_name)
  return _s;
}
inline const std::string& ColumnSchema::_internal_column_name() const {
  return _impl_.column_name_.Get();
}
inline void ColumnSchema::_internal_set_column_name(const std::string& value) {
  
  _impl_.column_name_.Set(value, GetArenaForAllocation());
}
inline std::string* ColumnSchema::_internal_mutable_column_name() {
  
  return _impl_.column_name_.Mutable(GetArenaForAllocation());
}
inline std::string* ColumnSchema::release_column_name() {
  // @@protoc_insertion_point(field_release:greptime.v1.ColumnSchema.column_name)
  return _impl_.column_name_.Release();
}
inline void ColumnSchema::set_allocated_column_name(std::string* column_name) {
  if (column_name != nullptr) {
    
  } else {
    
  }
  _impl_.column_name_.SetAllocated(column_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.column_name_.IsDefault()) {
    _impl_.column_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:greptime.v1.ColumnSchema.column_name)
}

// .greptime.v1.ColumnDataType datatype = 2;
inline void ColumnSchema::clear_datatype() {
  _impl_.datatype_ = 0;
}
inline ::greptime::v1::ColumnDataType ColumnSchema::_internal_datatype() const {
  return static_cast< ::greptime::v1::ColumnDataType >(_impl_.datatype_);
}
inline ::greptime::v1::ColumnDataType ColumnSchema::datatype() const {
  // @@protoc_insertion_point(field_get:greptime.v1.ColumnSchema.datatype)
  return _internal_datatype();
}
inline void ColumnSchema::_internal_set_datatype(::greptime::v1::ColumnDataType value) {
  
  _impl_.datatype_ = value;
}
inline void ColumnSchema::set_datatype(::greptime::v1::ColumnDataType value) {
  _internal_set_datatype(value);
  // @@protoc_insertion_point(field_set:greptime.v1.ColumnSchema.datatype)
}

// .greptime.v1.SemanticType semantic_type = 3;
inline void ColumnSchema::clear_semantic_type() {
  _impl_.semantic_type_ = 0;
}
inline ::greptime::v1::SemanticType ColumnSchema::_internal_semantic_type() const {
  return static_cast< ::greptime::v1::SemanticType >(_impl_.semantic_type_);
}
inline ::greptime::v1::SemanticType ColumnSchema::semantic_type() const {
  // @@protoc_insertion_point(field_get:greptime.v1.ColumnSchema.semantic_type)
  return _internal_semantic_type();
}
inline void ColumnSchema::_internal_set_semantic_type(::greptime::v1::SemanticType value) {
  
  _impl_.semantic_type_ = value;
}
inline void ColumnSchema::set_semantic_type(::greptime::v1::SemanticType value) {
  _internal_set_semantic_type(value);
  // @@protoc_insertion_point(field_set:greptime.v1.ColumnSchema.semantic_type)
}

// -------------------------------------------------------------------

// Row

// repeated .greptime.v1.Value values = 1;
inline int Row::_internal_values_size() const {
  return _impl_.values_.size();
}
inline int Row::values_size() const {
  return _internal_values_size();
}
inline void Row::clear_values() {
  _impl_.values_.Clear();
}
inline ::greptime::v1::Value* Row::mutable_values(int index) {
  // @@protoc_insertion_point(field_mutable:greptime.v1.Row.values)
  return _impl_.values_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Value >*
Row::mutable_values() {
  // @@protoc_insertion_point(field_mutable_list:greptime.v1.Row.values)
  return &_impl_.values_;
}
inline const ::greptime::v1::Value& Row::_internal_values(int index) const {
  return _impl_.values_.Get(index);
}
inline const ::greptime::v1::Value& Row::values(int index) const {
  // @@protoc_insertion_point(field_get:greptime.v1.Row.values)
  return _internal_values(index);
}
inline ::greptime::v1::Value* Row::_internal_add_values() {
  return _impl_.values_.Add();
}
inline ::greptime::v1::Value* Row::add_values() {
  ::greptime::v1::Value* _add = _internal_add_values();
  // @@protoc_insertion_point(field_add:greptime.v1.Row.values)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Value >&
Row::values() const {
  // @@protoc_insertion_point(field_list:greptime.v1.Row.values)
  return _impl_.values_;
}

// -------------------------------------------------------------------

// Value

// int32 i8_value = 1;
inline bool Value::_internal_has_i8_value() const {
  return value_data_case() == kI8Value;
}
inline bool Value::has_i8_value() const {
  return _internal_has_i8_value();
}
inline void Value::set_has_i8_value() {
  _impl_._oneof_case_[0] = kI8Value;
}
inline void Value::clear_i8_value() {
  if (_internal_has_i8_value()) {
    _impl_.value_data_.i8_value_ = 0;
    clear_has_value_data();
  }
}
inline int32_t Value::_internal_i8_value() const {
  if (_internal_has_i8_value()) {
    return _impl_.value_data_.i8_value_;
  }
  return 0;
}
inline void Value::_internal_set_i8_value(int32_t value) {
  if (!_internal_has_i8_value()) {
    clear_value_data();
    set_has_i8_value();
  }
  _impl_.value_data_.i8_value_ = value;
}
inline int32_t Value::i8_value() const {
  // @@protoc_insertion_point(field_get:greptime.v1.Value.i8_value)
  return _internal_i8_value();
}
inline void Value::set_i8_value(int32_t value) {
  _internal_set_i8_value(value);
  // @@protoc_insertion_point(field_set:greptime.v1.Value.i8_value)
}

// int32 i16_value = 2;
inline bool Value::_internal_has_i16_value() const {
  return value_data_case() == kI16Value;
}
inline bool Value::has_i16_value() const {
  return _internal_has_i16_value();
}
inline void Value::set_has_i16_value() {
  _impl_._oneof_case_[0] = kI16Value;
}
inline void Value::clear_i16_value() {
  if (_internal_has_i16_value()) {
    _impl_.value_data_.i16_value_ = 0;
    clear_has_value_data();
  }
}
inline int32_t Value::_internal_i16_value() const {
  if (_internal_has_i16_value()) {
    return _impl_.value_data_.i16_value_;
  }
  return 0;
}
inline void Value::_internal_set_i16_value(int32_t value) {
  if (!_internal_has_i16_value()) {
    clear_value_data();
    set_has_i16_value();
  }
  _impl_.value_data_.i16_value_ = value;
}
inline int32_t Value::i16_value() const {
  // @@protoc_insertion_point(field_get:greptime.v1.Value.i16_value)
  return _internal_i16_value();
}
inline void Value::set_i16_value(int32_t value) {
  _internal_set_i16_value(value);
  // @@protoc_insertion_point(field_set:greptime.v1.Value.i16_value)
}

// int32 i32_value = 3;
inline bool Value::_internal_has_i32_value() const {
  return value_data_case() == kI32Value;
}
inline bool Value::has_i32_value() const {
  return _internal_has_i32_value();
}
inline void Value::set_has_i32_value() {
  _impl_._oneof_case_[0] = kI32Value;
}
inline void Value::clear_i32_value() {
  if (_internal_has_i32_value()) {
    _impl_.value_data_.i32_value_ = 0;
    clear_has_value_data();
  }
}
inline int32_t Value::_internal_i32_value() const {
  if (_internal_has_i32_value()) {
    return _impl_.value_data_.i32_value_;
  }
  return 0;
}
inline void Value::_internal_set_i32_value(int32_t value) {
  if (!_internal_has_i32_value()) {
    clear_value_data();
    set_has_i32_value();
  }
  _impl_.value_data_.i32_value_ = value;
}
inline int32_t Value::i32_value() const {
  // @@protoc_insertion_point(field_get:greptime.v1.Value.i32_value)
  return _internal_i32_value();
}
inline void Value::set_i32_value(int32_t value) {
  _internal_set_i32_value(value);
  // @@protoc_insertion_point(field_set:greptime.v1.Value.i32_value)
}

// int64 i64_value = 4;
inline bool Value::_internal_has_i64_value() const {
  return value_data_case() == kI64Value;
}
inline bool Value::has_i64_value() const {
  return _internal_has_i64_value();
}
inline void Value::set_has_i64_value() {
  _impl_._oneof_case_[0] = kI64Value;
}
inline void Value::clear_i64_value() {
  if (_internal_has_i64_value()) {
    _impl_.value_data_.i64_value_ = int64_t{0};
    clear_has_value_data();
  }
}
inline int64_t Value::_internal_i64_value() const {
  if (_internal_has_i64_value()) {
    return _impl_.value_data_.i64_value_;
  }
  return int64_t{0};
}
inline void Value::_internal_set_i64_value(int64_t value) {
  if (!_internal_has_i64_value()) {
    clear_value_data();
    set_has_i64_value();
  }
  _impl_.value_data_.i64_value_ = value;
}
inline int64_t Value::i64_value() const {
  // @@protoc_insertion_point(field_get:greptime.v1.Value.i64_value)
  return _internal_i64_value();
}
inline void Value::set_i64_value(int64_t value) {
  _internal_set_i64_value(value);
  // @@protoc_insertion_point(field_set:greptime.v1.Value.i64_value)
}

// uint32 u8_value = 5;
inline bool Value::_internal_has_u8_value() const {
  return value_data_case() == kU8Value;
}
inline bool Value::has_u8_value() const {
  return _internal_has_u8_value();
}
inline void Value::set_has_u8_value() {
  _impl_._oneof_case_[0] = kU8Value;
}
inline void Value::clear_u8_value() {
  if (_internal_has_u8_value()) {
    _impl_.value_data_.u8_value_ = 0u;
    clear_has_value_data();
  }
}
inline uint32_t Value::_internal_u8_value() const {
  if (_internal_has_u8_value()) {
    return _impl_.value_data_.u8_value_;
  }
  return 0u;
}
inline void Value::_internal_set_u8_value(uint32_t value) {
  if (!_internal_has_u8_value()) {
    clear_value_data();
    set_has_u8_value();
  }
  _impl_.value_data_.u8_value_ = value;
}
inline uint32_t Value::u8_value() const {
  // @@protoc_insertion_point(field_get:greptime.v1.Value.u8_value)
  return _internal_u8_value();
}
inline void Value::set_u8_value(uint32_t value) {
  _internal_set_u8_value(value);
  // @@protoc_insertion_point(field_set:greptime.v1.Value.u8_value)
}

// uint32 u16_value = 6;
inline bool Value::_internal_has_u16_value() const {
  return value_data_case() == kU16Value;
}
inline bool Value::has_u16_value() const {
  return _internal_has_u16_value();
}
inline void Value::set_has_u16_value() {
  _impl_._oneof_case_[0] = kU16Value;
}
inline void Value::clear_u16_value() {
  if (_internal_has_u16_value()) {
    _impl_.value_data_.u16_value_ = 0u;
    clear_has_value_data();
  }
}
inline uint32_t Value::_internal_u16_value() const {
  if (_internal_has_u16_value()) {
    return _impl_.value_data_.u16_value_;
  }
  return 0u;
}
inline void Value::_internal_set_u16_value(uint32_t value) {
  if (!_internal_has_u16_value()) {
    clear_value_data();
    set_has_u16_value();
  }
  _impl_.value_data_.u16_value_ = value;
}
inline uint32_t Value::u16_value() const {
  // @@protoc_insertion_point(field_get:greptime.v1.Value.u16_value)
  return _internal_u16_value();
}
inline void Value::set_u16_value(uint32_t value) {
  _internal_set_u16_value(value);
  // @@protoc_insertion_point(field_set:greptime.v1.Value.u16_value)
}

// uint32 u32_value = 7;
inline bool Value::_internal_has_u32_value() const {
  return value_data_case() == kU32Value;
}
inline bool Value::has_u32_value() const {
  return _internal_has_u32_value();
}
inline void Value::set_has_u32_value() {
  _impl_._oneof_case_[0] = kU32Value;
}
inline void Value::clear_u32_value() {
  if (_internal_has_u32_value()) {
    _impl_.value_data_.u32_value_ = 0u;
    clear_has_value_data();
  }
}
inline uint32_t Value::_internal_u32_value() const {
  if (_internal_has_u32_value()) {
    return _impl_.value_data_.u32_value_;
  }
  return 0u;
}
inline void Value::_internal_set_u32_value(uint32_t value) {
  if (!_internal_has_u32_value()) {
    clear_value_data();
    set_has_u32_value();
  }
  _impl_.value_data_.u32_value_ = value;
}
inline uint32_t Value::u32_value() const {
  // @@protoc_insertion_point(field_get:greptime.v1.Value.u32_value)
  return _internal_u32_value();
}
inline void Value::set_u32_value(uint32_t value) {
  _internal_set_u32_value(value);
  // @@protoc_insertion_point(field_set:greptime.v1.Value.u32_value)
}

// uint64 u64_value = 8;
inline bool Value::_internal_has_u64_value() const {
  return value_data_case() == kU64Value;
}
inline bool Value::has_u64_value() const {
  return _internal_has_u64_value();
}
inline void Value::set_has_u64_value() {
  _impl_._oneof_case_[0] = kU64Value;
}
inline void Value::clear_u64_value() {
  if (_internal_has_u64_value()) {
    _impl_.value_data_.u64_value_ = uint64_t{0u};
    clear_has_value_data();
  }
}
inline uint64_t Value::_internal_u64_value() const {
  if (_internal_has_u64_value()) {
    return _impl_.value_data_.u64_value_;
  }
  return uint64_t{0u};
}
inline void Value::_internal_set_u64_value(uint64_t value) {
  if (!_internal_has_u64_value()) {
    clear_value_data();
    set_has_u64_value();
  }
  _impl_.value_data_.u64_value_ = value;
}
inline uint64_t Value::u64_value() const {
  // @@protoc_insertion_point(field_get:greptime.v1.Value.u64_value)
  return _internal_u64_value();
}
inline void Value::set_u64_value(uint64_t value) {
  _internal_set_u64_value(value);
  // @@protoc_insertion_point(field_set:greptime.v1.Value.u64_value)
}

// float f32_value = 9;
inline bool Value::_internal_has_f32_value() const {
  return value_data_case() == kF32Value;
}
inline bool Value::has_f32_value() const {
  return _internal_has_f32_value();
}
inline void Value::set_has_f32_value() {
  _impl_._oneof_case_[0] = kF32Value;
}
inline void Value::clear_f32_value() {
  if (_internal_has_f32_value()) {
    _impl_.value_data_.f32_value_ = 0;
    clear_has_value_data();
  }
}
inline float Value::_internal_f32_value() const {
  if (_internal_has_f32_value()) {
    return _impl_.value_data_.f32_value_;
  }
  return 0;
}
inline void Value::_internal_set_f32_value(float value) {
  if (!_internal_has_f32_value()) {
    clear_value_data();
    set_has_f32_value();
  }
  _impl_.value_data_.f32_value_ = value;
}
inline float Value::f32_value() const {
  // @@protoc_insertion_point(field_get:greptime.v1.Value.f32_value)
  return _internal_f32_value();
}
inline void Value::set_f32_value(float value) {
  _internal_set_f32_value(value);
  // @@protoc_insertion_point(field_set:greptime.v1.Value.f32_value)
}

// double f64_value = 10;
inline bool Value::_internal_has_f64_value() const {
  return value_data_case() == kF64Value;
}
inline bool Value::has_f64_value() const {
  return _internal_has_f64_value();
}
inline void Value::set_has_f64_value() {
  _impl_._oneof_case_[0] = kF64Value;
}
inline void Value::clear_f64_value() {
  if (_internal_has_f64_value()) {
    _impl_.value_data_.f64_value_ = 0;
    clear_has_value_data();
  }
}
inline double Value::_internal_f64_value() const {
  if (_internal_has_f64_value()) {
    return _impl_.value_data_.f64_value_;
  }
  return 0;
}
inline void Value::_internal_set_f64_value(double value) {
  if (!_internal_has_f64_value()) {
    clear_value_data();
    set_has_f64_value();
  }
  _impl_.value_data_.f64_value_ = value;
}
inline double Value::f64_value() const {
  // @@protoc_insertion_point(field_get:greptime.v1.Value.f64_value)
  return _internal_f64_value();
}
inline void Value::set_f64_value(double value) {
  _internal_set_f64_value(value);
  // @@protoc_insertion_point(field_set:greptime.v1.Value.f64_value)
}

// bool bool_value = 11;
inline bool Value::_internal_has_bool_value() const {
  return value_data_case() == kBoolValue;
}
inline bool Value::has_bool_value() const {
  return _internal_has_bool_value();
}
inline void Value::set_has_bool_value() {
  _impl_._oneof_case_[0] = kBoolValue;
}
inline void Value::clear_bool_value() {
  if (_internal_has_bool_value()) {
    _impl_.value_data_.bool_value_ = false;
    clear_has_value_data();
  }
}
inline bool Value::_internal_bool_value() const {
  if (_internal_has_bool_value()) {
    return _impl_.value_data_.bool_value_;
  }
  return false;
}
inline void Value::_internal_set_bool_value(bool value) {
  if (!_internal_has_bool_value()) {
    clear_value_data();
    set_has_bool_value();
  }
  _impl_.value_data_.bool_value_ = value;
}
inline bool Value::bool_value() const {
  // @@protoc_insertion_point(field_get:greptime.v1.Value.bool_value)
  return _internal_bool_value();
}
inline void Value::set_bool_value(bool value) {
  _internal_set_bool_value(value);
  // @@protoc_insertion_point(field_set:greptime.v1.Value.bool_value)
}

// bytes binary_value = 12;
inline bool Value::_internal_has_binary_value() const {
  return value_data_case() == kBinaryValue;
}
inline bool Value::has_binary_value() const {
  return _internal_has_binary_value();
}
inline void Value::set_has_binary_value() {
  _impl_._oneof_case_[0] = kBinaryValue;
}
inline void Value::clear_binary_value() {
  if (_internal_has_binary_value()) {
    _impl_.value_data_.binary_value_.Destroy();
    clear_has_value_data();
  }
}
inline const std::string& Value::binary_value() const {
  // @@protoc_insertion_point(field_get:greptime.v1.Value.binary_value)
  return _internal_binary_value();
}
template <typename ArgT0, typename... ArgT>
inline void Value::set_binary_value(ArgT0&& arg0, ArgT... args) {
  if (!_internal_has_binary_value()) {
    clear_value_data();
    set_has_binary_value();
    _impl_.value_data_.binary_value_.InitDefault();
  }
  _impl_.value_data_.binary_value_.SetBytes( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:greptime.v1.Value.binary_value)
}
inline std::string* Value::mutable_binary_value() {
  std::string* _s = _internal_mutable_binary_value();
  // @@protoc_insertion_point(field_mutable:greptime.v1.Value.binary_value)
  return _s;
}
inline const std::string& Value::_internal_binary_value() const {
  if (_internal_has_binary_value()) {
    return _impl_.value_data_.binary_value_.Get();
  }
  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
}
inline void Value::_internal_set_binary_value(const std::string& value) {
  if (!_internal_has_binary_value()) {
    clear_value_data();
    set_has_binary_value();
    _impl_.value_data_.binary_value_.InitDefault();
  }
  _impl_.value_data_.binary_value_.Set(value, GetArenaForAllocation());
}
inline std::string* Value::_internal_mutable_binary_value() {
  if (!_internal_has_binary_value()) {
    clear_value_data();
    set_has_binary_value();
    _impl_.value_data_.binary_value_.InitDefault();
  }
  return _impl_.value_data_.binary_value_.Mutable(      GetArenaForAllocation());
}
inline std::string* Value::release_binary_value() {
  // @@protoc_insertion_point(field_release:greptime.v1.Value.binary_value)
  if (_internal_has_binary_value()) {
    clear_has_value_data();
    return _impl_.value_data_.binary_value_.Release();
  } else {
    return nullptr;
  }
}
inline void Value::set_allocated_binary_value(std::string* binary_value) {
  if (has_value_data()) {
    clear_value_data();
  }
  if (binary_value != nullptr) {
    set_has_binary_value();
    _impl_.value_data_.binary_value_.InitAllocated(binary_value, GetArenaForAllocation());
  }
  // @@protoc_insertion_point(field_set_allocated:greptime.v1.Value.binary_value)
}

// string string_value = 13;
inline bool Value::_internal_has_string_value() const {
  return value_data_case() == kStringValue;
}
inline bool Value::has_string_value() const {
  return _internal_has_string_value();
}
inline void Value::set_has_string_value() {
  _impl_._oneof_case_[0] = kStringValue;
}
inline void Value::clear_string_value() {
  if (_internal_has_string_value()) {
    _impl_.value_data_.string_value_.Destroy();
    clear_has_value_data();
  }
}
inline const std::string& Value::string_value() const {
  // @@protoc_insertion_point(field_get:greptime.v1.Value.string_value)
  return _internal_string_value();
}
template <typename ArgT0, typename... ArgT>
inline void Value::set_string_value(ArgT0&& arg0, ArgT... args) {
  if (!_internal_has_string_value()) {
    clear_value_data();
    set_has_string_value();
    _impl_.value_data_.string_value_.InitDefault();
  }
  _impl_.value_data_.string_value_.Set( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:greptime.v1.Value.string_value)
}
inline std::string* Value::mutable_string_value() {
  std::string* _s = _internal_mutable_string_value();
  // @@protoc_insertion_point(field_mutable:greptime.v1.Value.string_value)
  return _s;
}
inline const std::string& Value::_internal_string_value() const {
  if (_internal_has_string_value()) {
    return _impl_.value_data_.string_value_.Get();
  }
  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
}
inline void Value::_internal_set_string_value(const std::string& value) {
  if (!_internal_has_string_value()) {
    clear_value_data();
    set_has_string_value();
    _impl_.value_data_.string_value_.InitDefault();
  }
  _impl_.value_data_.string_value_.Set(value, GetArenaForAllocation());
}
inline std::string* Value::_internal_mutable_string_value() {
  if (!_internal_has_string_value()) {
    clear_value_data();
    set_has_string_value();
    _impl_.value_data_.string_value_.InitDefault();
  }
  return _impl_.value_data_.string_value_.Mutable(      GetArenaForAllocation());
}
inline std::string* Value::release_string_value() {
  // @@protoc_insertion_point(field_release:greptime.v1.Value.string_value)
  if (_internal_has_string_value()) {
    clear_has_value_data();
    return _impl_.value_data_.string_value_.Release();
  } else {
    return nullptr;
  }
}
inline void Value::set_allocated_string_value(std::string* string_value) {
  if (has_value_data()) {
    clear_value_data();
  }
  if (string_value != nullptr) {
    set_has_string_value();
    _impl_.value_data_.string_value_.InitAllocated(string_value, GetArenaForAllocation());
  }
  // @@protoc_insertion_point(field_set_allocated:greptime.v1.Value.string_value)
}

// int32 date_value = 14;
inline bool Value::_internal_has_date_value() const {
  return value_data_case() == kDateValue;
}
inline bool Value::has_date_value() const {
  return _internal_has_date_value();
}
inline void Value::set_has_date_value() {
  _impl_._oneof_case_[0] = kDateValue;
}
inline void Value::clear_date_value() {
  if (_internal_has_date_value()) {
    _impl_.value_data_.date_value_ = 0;
    clear_has_value_data();
  }
}
inline int32_t Value::_internal_date_value() const {
  if (_internal_has_date_value()) {
    return _impl_.value_data_.date_value_;
  }
  return 0;
}
inline void Value::_internal_set_date_value(int32_t value) {
  if (!_internal_has_date_value()) {
    clear_value_data();
    set_has_date_value();
  }
  _impl_.value_data_.date_value_ = value;
}
inline int32_t Value::date_value() const {
  // @@protoc_insertion_point(field_get:greptime.v1.Value.date_value)
  return _internal_date_value();
}
inline void Value::set_date_value(int32_t value) {
  _internal_set_date_value(value);
  // @@protoc_insertion_point(field_set:greptime.v1.Value.date_value)
}

// int64 datetime_value = 15;
inline bool Value::_internal_has_datetime_value() const {
  return value_data_case() == kDatetimeValue;
}
inline bool Value::has_datetime_value() const {
  return _internal_has_datetime_value();
}
inline void Value::set_has_datetime_value() {
  _impl_._oneof_case_[0] = kDatetimeValue;
}
inline void Value::clear_datetime_value() {
  if (_internal_has_datetime_value()) {
    _impl_.value_data_.datetime_value_ = int64_t{0};
    clear_has_value_data();
  }
}
inline int64_t Value::_internal_datetime_value() const {
  if (_internal_has_datetime_value()) {
    return _impl_.value_data_.datetime_value_;
  }
  return int64_t{0};
}
inline void Value::_internal_set_datetime_value(int64_t value) {
  if (!_internal_has_datetime_value()) {
    clear_value_data();
    set_has_datetime_value();
  }
  _impl_.value_data_.datetime_value_ = value;
}
inline int64_t Value::datetime_value() const {
  // @@protoc_insertion_point(field_get:greptime.v1.Value.datetime_value)
  return _internal_datetime_value();
}
inline void Value::set_datetime_value(int64_t value) {
  _internal_set_datetime_value(value);
  // @@protoc_insertion_point(field_set:greptime.v1.Value.datetime_value)
}

// int64 timestamp_second_value = 16;
inline bool Value::_internal_has_timestamp_second_value() const {
  return value_data_case() == kTimestampSecondValue;
}
inline bool Value::has_timestamp_second_value() const {
  return _internal_has_timestamp_second_value();
}
inline void Value::set_has_timestamp_second_value() {
  _impl_._oneof_case_[0] = kTimestampSecondValue;
}
inline void Value::clear_timestamp_second_value() {
  if (_internal_has_timestamp_second_value()) {
    _impl_.value_data_.timestamp_second_value_ = int64_t{0};
    clear_has_value_data();
  }
}
inline int64_t Value::_internal_timestamp_second_value() const {
  if (_internal_has_timestamp_second_value()) {
    return _impl_.value_data_.timestamp_second_value_;
  }
  return int64_t{0};
}
inline void Value::_internal_set_timestamp_second_value(int64_t value) {
  if (!_internal_has_timestamp_second_value()) {
    clear_value_data();
    set_has_timestamp_second_value();
  }
  _impl_.value_data_.timestamp_second_value_ = value;
}
inline int64_t Value::timestamp_second_value() const {
  // @@protoc_insertion_point(field_get:greptime.v1.Value.timestamp_second_value)
  return _internal_timestamp_second_value();
}
inline void Value::set_timestamp_second_value(int64_t value) {
  _internal_set_timestamp_second_value(value);
  // @@protoc_insertion_point(field_set:greptime.v1.Value.timestamp_second_value)
}

// int64 timestamp_millisecond_value = 17;
inline bool Value::_internal_has_timestamp_millisecond_value() const {
  return value_data_case() == kTimestampMillisecondValue;
}
inline bool Value::has_timestamp_millisecond_value() const {
  return _internal_has_timestamp_millisecond_value();
}
inline void Value::set_has_timestamp_millisecond_value() {
  _impl_._oneof_case_[0] = kTimestampMillisecondValue;
}
inline void Value::clear_timestamp_millisecond_value() {
  if (_internal_has_timestamp_millisecond_value()) {
    _impl_.value_data_.timestamp_millisecond_value_ = int64_t{0};
    clear_has_value_data();
  }
}
inline int64_t Value::_internal_timestamp_millisecond_value() const {
  if (_internal_has_timestamp_millisecond_value()) {
    return _impl_.value_data_.timestamp_millisecond_value_;
  }
  return int64_t{0};
}
inline void Value::_internal_set_timestamp_millisecond_value(int64_t value) {
  if (!_internal_has_timestamp_millisecond_value()) {
    clear_value_data();
    set_has_timestamp_millisecond_value();
  }
  _impl_.value_data_.timestamp_millisecond_value_ = value;
}
inline int64_t Value::timestamp_millisecond_value() const {
  // @@protoc_insertion_point(field_get:greptime.v1.Value.timestamp_millisecond_value)
  return _internal_timestamp_millisecond_value();
}
inline void Value::set_timestamp_millisecond_value(int64_t value) {
  _internal_set_timestamp_millisecond_value(value);
  // @@protoc_insertion_point(field_set:greptime.v1.Value.timestamp_millisecond_value)
}

// int64 timestamp_microsecond_value = 18;
inline bool Value::_internal_has_timestamp_microsecond_value() const {
  return value_data_case() == kTimestampMicrosecondValue;
}
inline bool Value::has_timestamp_microsecond_value() const {
  return _internal_has_timestamp_microsecond_value();
}
inline void Value::set_has_timestamp_microsecond_value() {
  _impl_._oneof_case_[0] = kTimestampMicrosecondValue;
}
inline void Value::clear_timestamp_microsecond_value() {
  if (_internal_has_timestamp_microsecond_value()) {
    _impl_.value_data_.timestamp_microsecond_value_ = int64_t{0};
    clear_has_value_data();
  }
}
inline int64_t Value::_internal_timestamp_microsecond_value() const {
  if (_internal_has_timestamp_microsecond_value()) {
    return _impl_.value_data_.timestamp_microsecond_value_;
  }
  return int64_t{0};
}
inline void Value::_internal_set_timestamp_microsecond_value(int64_t value) {
  if (!_internal_has_timestamp_microsecond_value()) {
    clear_value_data();
    set_has_timestamp_microsecond_value();
  }
  _impl_.value_data_.timestamp_microsecond_value_ = value;
}
inline int64_t Value::timestamp_microsecond_value() const {
  // @@protoc_insertion_point(field_get:greptime.v1.Value.timestamp_microsecond_value)
  return _internal_timestamp_microsecond_value();
}
inline void Value::set_timestamp_microsecond_value(int64_t value) {
  _internal_set_timestamp_microsecond_value(value);
  // @@protoc_insertion_point(field_set:greptime.v1.Value.timestamp_microsecond_value)
}

// int64 timestamp_nanosecond_value = 19;
inline bool Value::_internal_has_timestamp_nanosecond_value() const {
  return value_data_case() == kTimestampNanosecondValue;
}
inline bool Value::has_timestamp_nanosecond_value() const {
  return _internal_has_timestamp_nanosecond_value();
}
inline void Value::set_has_timestamp_nanosecond_value() {
  _impl_._oneof_case_[0] = kTimestampNanosecondValue;
}
inline void Value::clear_timestamp_nanosecond_value() {
  if (_internal_has_timestamp_nanosecond_value()) {
    _impl_.value_data_.timestamp_nanosecond_value_ = int64_t{0};
    clear_has_value_data();
  }
}
inline int64_t Value::_internal_timestamp_nanosecond_value() const {
  if (_internal_has_timestamp_nanosecond_value()) {
    return _impl_.value_data_.timestamp_nanosecond_value_;
  }
  return int64_t{0};
}
inline void Value::_internal_set_timestamp_nanosecond_value(int64_t value) {
  if (!_internal_has_timestamp_nanosecond_value()) {
    clear_value_data();
    set_has_timestamp_nanosecond_value();
  }
  _impl_.value_data_.timestamp_nanosecond_value_ = value;
}
inline int64_t Value::timestamp_nanosecond_value() const {
  // @@protoc_insertion_point(field_get:greptime.v1.Value.timestamp_nanosecond_value)
  return _internal_timestamp_nanosecond_value();
}
inline void Value::set_timestamp_nanosecond_value(int64_t value) {
  _internal_set_timestamp_nanosecond_value(value);
  // @@protoc_insertion_point(field_set:greptime.v1.Value.timestamp_nanosecond_value)
}

// int64 time_second_value = 20;
inline bool Value::_internal_has_time_second_value() const {
  return value_data_case() == kTimeSecondValue;
}
inline bool Value::has_time_second_value() const {
  return _internal_has_time_second_value();
}
inline void Value::set_has_time_second_value() {
  _impl_._oneof_case_[0] = kTimeSecondValue;
}
inline void Value::clear_time_second_value() {
  if (_internal_has_time_second_value()) {
    _impl_.value_data_.time_second_value_ = int64_t{0};
    clear_has_value_data();
  }
}
inline int64_t Value::_internal_time_second_value() const {
  if (_internal_has_time_second_value()) {
    return _impl_.value_data_.time_second_value_;
  }
  return int64_t{0};
}
inline void Value::_internal_set_time_second_value(int64_t value) {
  if (!_internal_has_time_second_value()) {
    clear_value_data();
    set_has_time_second_value();
  }
  _impl_.value_data_.time_second_value_ = value;
}
inline int64_t Value::time_second_value() const {
  // @@protoc_insertion_point(field_get:greptime.v1.Value.time_second_value)
  return _internal_time_second_value();
}
inline void Value::set_time_second_value(int64_t value) {
  _internal_set_time_second_value(value);
  // @@protoc_insertion_point(field_set:greptime.v1.Value.time_second_value)
}

// int64 time_millisecond_value = 21;
inline bool Value::_internal_has_time_millisecond_value() const {
  return value_data_case() == kTimeMillisecondValue;
}
inline bool Value::has_time_millisecond_value() const {
  return _internal_has_time_millisecond_value();
}
inline void Value::set_has_time_millisecond_value() {
  _impl_._oneof_case_[0] = kTimeMillisecondValue;
}
inline void Value::clear_time_millisecond_value() {
  if (_internal_has_time_millisecond_value()) {
    _impl_.value_data_.time_millisecond_value_ = int64_t{0};
    clear_has_value_data();
  }
}
inline int64_t Value::_internal_time_millisecond_value() const {
  if (_internal_has_time_millisecond_value()) {
    return _impl_.value_data_.time_millisecond_value_;
  }
  return int64_t{0};
}
inline void Value::_internal_set_time_millisecond_value(int64_t value) {
  if (!_internal_has_time_millisecond_value()) {
    clear_value_data();
    set_has_time_millisecond_value();
  }
  _impl_.value_data_.time_millisecond_value_ = value;
}
inline int64_t Value::time_millisecond_value() const {
  // @@protoc_insertion_point(field_get:greptime.v1.Value.time_millisecond_value)
  return _internal_time_millisecond_value();
}
inline void Value::set_time_millisecond_value(int64_t value) {
  _internal_set_time_millisecond_value(value);
  // @@protoc_insertion_point(field_set:greptime.v1.Value.time_millisecond_value)
}

// int64 time_microsecond_value = 22;
inline bool Value::_internal_has_time_microsecond_value() const {
  return value_data_case() == kTimeMicrosecondValue;
}
inline bool Value::has_time_microsecond_value() const {
  return _internal_has_time_microsecond_value();
}
inline void Value::set_has_time_microsecond_value() {
  _impl_._oneof_case_[0] = kTimeMicrosecondValue;
}
inline void Value::clear_time_microsecond_value() {
  if (_internal_has_time_microsecond_value()) {
    _impl_.value_data_.time_microsecond_value_ = int64_t{0};
    clear_has_value_data();
  }
}
inline int64_t Value::_internal_time_microsecond_value() const {
  if (_internal_has_time_microsecond_value()) {
    return _impl_.value_data_.time_microsecond_value_;
  }
  return int64_t{0};
}
inline void Value::_internal_set_time_microsecond_value(int64_t value) {
  if (!_internal_has_time_microsecond_value()) {
    clear_value_data();
    set_has_time_microsecond_value();
  }
  _impl_.value_data_.time_microsecond_value_ = value;
}
inline int64_t Value::time_microsecond_value() const {
  // @@protoc_insertion_point(field_get:greptime.v1.Value.time_microsecond_value)
  return _internal_time_microsecond_value();
}
inline void Value::set_time_microsecond_value(int64_t value) {
  _internal_set_time_microsecond_value(value);
  // @@protoc_insertion_point(field_set:greptime.v1.Value.time_microsecond_value)
}

// int64 time_nanosecond_value = 23;
inline bool Value::_internal_has_time_nanosecond_value() const {
  return value_data_case() == kTimeNanosecondValue;
}
inline bool Value::has_time_nanosecond_value() const {
  return _internal_has_time_nanosecond_value();
}
inline void Value::set_has_time_nanosecond_value() {
  _impl_._oneof_case_[0] = kTimeNanosecondValue;
}
inline void Value::clear_time_nanosecond_value() {
  if (_internal_has_time_nanosecond_value()) {
    _impl_.value_data_.time_nanosecond_value_ = int64_t{0};
    clear_has_value_data();
  }
}
inline int64_t Value::_internal_time_nanosecond_value() const {
  if (_internal_has_time_nanosecond_value()) {
    return _impl_.value_data_.time_nanosecond_value_;
  }
  return int64_t{0};
}
inline void Value::_internal_set_time_nanosecond_value(int64_t value) {
  if (!_internal_has_time_nanosecond_value()) {
    clear_value_data();
    set_has_time_nanosecond_value();
  }
  _impl_.value_data_.time_nanosecond_value_ = value;
}
inline int64_t Value::time_nanosecond_value() const {
  // @@protoc_insertion_point(field_get:greptime.v1.Value.time_nanosecond_value)
  return _internal_time_nanosecond_value();
}
inline void Value::set_time_nanosecond_value(int64_t value) {
  _internal_set_time_nanosecond_value(value);
  // @@protoc_insertion_point(field_set:greptime.v1.Value.time_nanosecond_value)
}

// int32 interval_year_month_values = 24;
inline bool Value::_internal_has_interval_year_month_values() const {
  return value_data_case() == kIntervalYearMonthValues;
}
inline bool Value::has_interval_year_month_values() const {
  return _internal_has_interval_year_month_values();
}
inline void Value::set_has_interval_year_month_values() {
  _impl_._oneof_case_[0] = kIntervalYearMonthValues;
}
inline void Value::clear_interval_year_month_values() {
  if (_internal_has_interval_year_month_values()) {
    _impl_.value_data_.interval_year_month_values_ = 0;
    clear_has_value_data();
  }
}
inline int32_t Value::_internal_interval_year_month_values() const {
  if (_internal_has_interval_year_month_values()) {
    return _impl_.value_data_.interval_year_month_values_;
  }
  return 0;
}
inline void Value::_internal_set_interval_year_month_values(int32_t value) {
  if (!_internal_has_interval_year_month_values()) {
    clear_value_data();
    set_has_interval_year_month_values();
  }
  _impl_.value_data_.interval_year_month_values_ = value;
}
inline int32_t Value::interval_year_month_values() const {
  // @@protoc_insertion_point(field_get:greptime.v1.Value.interval_year_month_values)
  return _internal_interval_year_month_values();
}
inline void Value::set_interval_year_month_values(int32_t value) {
  _internal_set_interval_year_month_values(value);
  // @@protoc_insertion_point(field_set:greptime.v1.Value.interval_year_month_values)
}

// int64 interval_day_time_values = 25;
inline bool Value::_internal_has_interval_day_time_values() const {
  return value_data_case() == kIntervalDayTimeValues;
}
inline bool Value::has_interval_day_time_values() const {
  return _internal_has_interval_day_time_values();
}
inline void Value::set_has_interval_day_time_values() {
  _impl_._oneof_case_[0] = kIntervalDayTimeValues;
}
inline void Value::clear_interval_day_time_values() {
  if (_internal_has_interval_day_time_values()) {
    _impl_.value_data_.interval_day_time_values_ = int64_t{0};
    clear_has_value_data();
  }
}
inline int64_t Value::_internal_interval_day_time_values() const {
  if (_internal_has_interval_day_time_values()) {
    return _impl_.value_data_.interval_day_time_values_;
  }
  return int64_t{0};
}
inline void Value::_internal_set_interval_day_time_values(int64_t value) {
  if (!_internal_has_interval_day_time_values()) {
    clear_value_data();
    set_has_interval_day_time_values();
  }
  _impl_.value_data_.interval_day_time_values_ = value;
}
inline int64_t Value::interval_day_time_values() const {
  // @@protoc_insertion_point(field_get:greptime.v1.Value.interval_day_time_values)
  return _internal_interval_day_time_values();
}
inline void Value::set_interval_day_time_values(int64_t value) {
  _internal_set_interval_day_time_values(value);
  // @@protoc_insertion_point(field_set:greptime.v1.Value.interval_day_time_values)
}

// .greptime.v1.IntervalMonthDayNano interval_month_day_nano_values = 26;
inline bool Value::_internal_has_interval_month_day_nano_values() const {
  return value_data_case() == kIntervalMonthDayNanoValues;
}
inline bool Value::has_interval_month_day_nano_values() const {
  return _internal_has_interval_month_day_nano_values();
}
inline void Value::set_has_interval_month_day_nano_values() {
  _impl_._oneof_case_[0] = kIntervalMonthDayNanoValues;
}
inline ::greptime::v1::IntervalMonthDayNano* Value::release_interval_month_day_nano_values() {
  // @@protoc_insertion_point(field_release:greptime.v1.Value.interval_month_day_nano_values)
  if (_internal_has_interval_month_day_nano_values()) {
    clear_has_value_data();
    ::greptime::v1::IntervalMonthDayNano* temp = _impl_.value_data_.interval_month_day_nano_values_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.value_data_.interval_month_day_nano_values_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::greptime::v1::IntervalMonthDayNano& Value::_internal_interval_month_day_nano_values() const {
  return _internal_has_interval_month_day_nano_values()
      ? *_impl_.value_data_.interval_month_day_nano_values_
      : reinterpret_cast< ::greptime::v1::IntervalMonthDayNano&>(::greptime::v1::_IntervalMonthDayNano_default_instance_);
}
inline const ::greptime::v1::IntervalMonthDayNano& Value::interval_month_day_nano_values() const {
  // @@protoc_insertion_point(field_get:greptime.v1.Value.interval_month_day_nano_values)
  return _internal_interval_month_day_nano_values();
}
inline ::greptime::v1::IntervalMonthDayNano* Value::unsafe_arena_release_interval_month_day_nano_values() {
  // @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.Value.interval_month_day_nano_values)
  if (_internal_has_interval_month_day_nano_values()) {
    clear_has_value_data();
    ::greptime::v1::IntervalMonthDayNano* temp = _impl_.value_data_.interval_month_day_nano_values_;
    _impl_.value_data_.interval_month_day_nano_values_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Value::unsafe_arena_set_allocated_interval_month_day_nano_values(::greptime::v1::IntervalMonthDayNano* interval_month_day_nano_values) {
  clear_value_data();
  if (interval_month_day_nano_values) {
    set_has_interval_month_day_nano_values();
    _impl_.value_data_.interval_month_day_nano_values_ = interval_month_day_nano_values;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.Value.interval_month_day_nano_values)
}
inline ::greptime::v1::IntervalMonthDayNano* Value::_internal_mutable_interval_month_day_nano_values() {
  if (!_internal_has_interval_month_day_nano_values()) {
    clear_value_data();
    set_has_interval_month_day_nano_values();
    _impl_.value_data_.interval_month_day_nano_values_ = CreateMaybeMessage< ::greptime::v1::IntervalMonthDayNano >(GetArenaForAllocation());
  }
  return _impl_.value_data_.interval_month_day_nano_values_;
}
inline ::greptime::v1::IntervalMonthDayNano* Value::mutable_interval_month_day_nano_values() {
  ::greptime::v1::IntervalMonthDayNano* _msg = _internal_mutable_interval_month_day_nano_values();
  // @@protoc_insertion_point(field_mutable:greptime.v1.Value.interval_month_day_nano_values)
  return _msg;
}

// int64 duration_second_value = 27;
inline bool Value::_internal_has_duration_second_value() const {
  return value_data_case() == kDurationSecondValue;
}
inline bool Value::has_duration_second_value() const {
  return _internal_has_duration_second_value();
}
inline void Value::set_has_duration_second_value() {
  _impl_._oneof_case_[0] = kDurationSecondValue;
}
inline void Value::clear_duration_second_value() {
  if (_internal_has_duration_second_value()) {
    _impl_.value_data_.duration_second_value_ = int64_t{0};
    clear_has_value_data();
  }
}
inline int64_t Value::_internal_duration_second_value() const {
  if (_internal_has_duration_second_value()) {
    return _impl_.value_data_.duration_second_value_;
  }
  return int64_t{0};
}
inline void Value::_internal_set_duration_second_value(int64_t value) {
  if (!_internal_has_duration_second_value()) {
    clear_value_data();
    set_has_duration_second_value();
  }
  _impl_.value_data_.duration_second_value_ = value;
}
inline int64_t Value::duration_second_value() const {
  // @@protoc_insertion_point(field_get:greptime.v1.Value.duration_second_value)
  return _internal_duration_second_value();
}
inline void Value::set_duration_second_value(int64_t value) {
  _internal_set_duration_second_value(value);
  // @@protoc_insertion_point(field_set:greptime.v1.Value.duration_second_value)
}

// int64 duration_millisecond_value = 28;
inline bool Value::_internal_has_duration_millisecond_value() const {
  return value_data_case() == kDurationMillisecondValue;
}
inline bool Value::has_duration_millisecond_value() const {
  return _internal_has_duration_millisecond_value();
}
inline void Value::set_has_duration_millisecond_value() {
  _impl_._oneof_case_[0] = kDurationMillisecondValue;
}
inline void Value::clear_duration_millisecond_value() {
  if (_internal_has_duration_millisecond_value()) {
    _impl_.value_data_.duration_millisecond_value_ = int64_t{0};
    clear_has_value_data();
  }
}
inline int64_t Value::_internal_duration_millisecond_value() const {
  if (_internal_has_duration_millisecond_value()) {
    return _impl_.value_data_.duration_millisecond_value_;
  }
  return int64_t{0};
}
inline void Value::_internal_set_duration_millisecond_value(int64_t value) {
  if (!_internal_has_duration_millisecond_value()) {
    clear_value_data();
    set_has_duration_millisecond_value();
  }
  _impl_.value_data_.duration_millisecond_value_ = value;
}
inline int64_t Value::duration_millisecond_value() const {
  // @@protoc_insertion_point(field_get:greptime.v1.Value.duration_millisecond_value)
  return _internal_duration_millisecond_value();
}
inline void Value::set_duration_millisecond_value(int64_t value) {
  _internal_set_duration_millisecond_value(value);
  // @@protoc_insertion_point(field_set:greptime.v1.Value.duration_millisecond_value)
}

// int64 duration_microsecond_value = 29;
inline bool Value::_internal_has_duration_microsecond_value() const {
  return value_data_case() == kDurationMicrosecondValue;
}
inline bool Value::has_duration_microsecond_value() const {
  return _internal_has_duration_microsecond_value();
}
inline void Value::set_has_duration_microsecond_value() {
  _impl_._oneof_case_[0] = kDurationMicrosecondValue;
}
inline void Value::clear_duration_microsecond_value() {
  if (_internal_has_duration_microsecond_value()) {
    _impl_.value_data_.duration_microsecond_value_ = int64_t{0};
    clear_has_value_data();
  }
}
inline int64_t Value::_internal_duration_microsecond_value() const {
  if (_internal_has_duration_microsecond_value()) {
    return _impl_.value_data_.duration_microsecond_value_;
  }
  return int64_t{0};
}
inline void Value::_internal_set_duration_microsecond_value(int64_t value) {
  if (!_internal_has_duration_microsecond_value()) {
    clear_value_data();
    set_has_duration_microsecond_value();
  }
  _impl_.value_data_.duration_microsecond_value_ = value;
}
inline int64_t Value::duration_microsecond_value() const {
  // @@protoc_insertion_point(field_get:greptime.v1.Value.duration_microsecond_value)
  return _internal_duration_microsecond_value();
}
inline void Value::set_duration_microsecond_value(int64_t value) {
  _internal_set_duration_microsecond_value(value);
  // @@protoc_insertion_point(field_set:greptime.v1.Value.duration_microsecond_value)
}

// int64 duration_nanosecond_value = 30;
inline bool Value::_internal_has_duration_nanosecond_value() const {
  return value_data_case() == kDurationNanosecondValue;
}
inline bool Value::has_duration_nanosecond_value() const {
  return _internal_has_duration_nanosecond_value();
}
inline void Value::set_has_duration_nanosecond_value() {
  _impl_._oneof_case_[0] = kDurationNanosecondValue;
}
inline void Value::clear_duration_nanosecond_value() {
  if (_internal_has_duration_nanosecond_value()) {
    _impl_.value_data_.duration_nanosecond_value_ = int64_t{0};
    clear_has_value_data();
  }
}
inline int64_t Value::_internal_duration_nanosecond_value() const {
  if (_internal_has_duration_nanosecond_value()) {
    return _impl_.value_data_.duration_nanosecond_value_;
  }
  return int64_t{0};
}
inline void Value::_internal_set_duration_nanosecond_value(int64_t value) {
  if (!_internal_has_duration_nanosecond_value()) {
    clear_value_data();
    set_has_duration_nanosecond_value();
  }
  _impl_.value_data_.duration_nanosecond_value_ = value;
}
inline int64_t Value::duration_nanosecond_value() const {
  // @@protoc_insertion_point(field_get:greptime.v1.Value.duration_nanosecond_value)
  return _internal_duration_nanosecond_value();
}
inline void Value::set_duration_nanosecond_value(int64_t value) {
  _internal_set_duration_nanosecond_value(value);
  // @@protoc_insertion_point(field_set:greptime.v1.Value.duration_nanosecond_value)
}

inline bool Value::has_value_data() const {
  return value_data_case() != VALUE_DATA_NOT_SET;
}
inline void Value::clear_has_value_data() {
  _impl_._oneof_case_[0] = VALUE_DATA_NOT_SET;
}
inline Value::ValueDataCase Value::value_data_case() const {
  return Value::ValueDataCase(_impl_._oneof_case_[0]);
}
#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)

}  // namespace v1
}  // namespace greptime

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_greptime_2fv1_2frow_2eproto