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

#ifndef GOOGLE_PROTOBUF_INCLUDED_greptime_2fv1_2fwal_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_greptime_2fv1_2fwal_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/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include "greptime/v1/common.pb.h"
#include "greptime/v1/row.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_greptime_2fv1_2fwal_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_2fwal_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_greptime_2fv1_2fwal_2eproto;
namespace greptime {
namespace v1 {
class BulkWalEntry;
struct BulkWalEntryDefaultTypeInternal;
extern BulkWalEntryDefaultTypeInternal _BulkWalEntry_default_instance_;
class Mutation;
struct MutationDefaultTypeInternal;
extern MutationDefaultTypeInternal _Mutation_default_instance_;
class WalEntry;
struct WalEntryDefaultTypeInternal;
extern WalEntryDefaultTypeInternal _WalEntry_default_instance_;
class WriteHint;
struct WriteHintDefaultTypeInternal;
extern WriteHintDefaultTypeInternal _WriteHint_default_instance_;
}  // namespace v1
}  // namespace greptime
PROTOBUF_NAMESPACE_OPEN
template<> ::greptime::v1::BulkWalEntry* Arena::CreateMaybeMessage<::greptime::v1::BulkWalEntry>(Arena*);
template<> ::greptime::v1::Mutation* Arena::CreateMaybeMessage<::greptime::v1::Mutation>(Arena*);
template<> ::greptime::v1::WalEntry* Arena::CreateMaybeMessage<::greptime::v1::WalEntry>(Arena*);
template<> ::greptime::v1::WriteHint* Arena::CreateMaybeMessage<::greptime::v1::WriteHint>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace greptime {
namespace v1 {

enum OpType : int {
  DELETE = 0,
  PUT = 1,
  OpType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  OpType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool OpType_IsValid(int value);
constexpr OpType OpType_MIN = DELETE;
constexpr OpType OpType_MAX = PUT;
constexpr int OpType_ARRAYSIZE = OpType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* OpType_descriptor();
template<typename T>
inline const std::string& OpType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, OpType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function OpType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    OpType_descriptor(), enum_t_value);
}
inline bool OpType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, OpType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<OpType>(
    OpType_descriptor(), name, value);
}
enum PrimaryKeyEncoding : int {
  DENSE = 0,
  SPARSE = 1,
  PrimaryKeyEncoding_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  PrimaryKeyEncoding_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool PrimaryKeyEncoding_IsValid(int value);
constexpr PrimaryKeyEncoding PrimaryKeyEncoding_MIN = DENSE;
constexpr PrimaryKeyEncoding PrimaryKeyEncoding_MAX = SPARSE;
constexpr int PrimaryKeyEncoding_ARRAYSIZE = PrimaryKeyEncoding_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PrimaryKeyEncoding_descriptor();
template<typename T>
inline const std::string& PrimaryKeyEncoding_Name(T enum_t_value) {
  static_assert(::std::is_same<T, PrimaryKeyEncoding>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function PrimaryKeyEncoding_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    PrimaryKeyEncoding_descriptor(), enum_t_value);
}
inline bool PrimaryKeyEncoding_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PrimaryKeyEncoding* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PrimaryKeyEncoding>(
    PrimaryKeyEncoding_descriptor(), name, value);
}
// ===================================================================

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

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

  inline WriteHint& operator=(const WriteHint& from) {
    CopyFrom(from);
    return *this;
  }
  inline WriteHint& operator=(WriteHint&& 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 WriteHint& default_instance() {
    return *internal_default_instance();
  }
  static inline const WriteHint* internal_default_instance() {
    return reinterpret_cast<const WriteHint*>(
               &_WriteHint_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(WriteHint& a, WriteHint& b) {
    a.Swap(&b);
  }
  inline void Swap(WriteHint* 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(WriteHint* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  WriteHint* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<WriteHint>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const WriteHint& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const WriteHint& from) {
    WriteHint::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(WriteHint* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "greptime.v1.WriteHint";
  }
  protected:
  explicit WriteHint(::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 {
    kPrimaryKeyEncodingFieldNumber = 1,
  };
  // .greptime.v1.PrimaryKeyEncoding primary_key_encoding = 1;
  void clear_primary_key_encoding();
  ::greptime::v1::PrimaryKeyEncoding primary_key_encoding() const;
  void set_primary_key_encoding(::greptime::v1::PrimaryKeyEncoding value);
  private:
  ::greptime::v1::PrimaryKeyEncoding _internal_primary_key_encoding() const;
  void _internal_set_primary_key_encoding(::greptime::v1::PrimaryKeyEncoding value);
  public:

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

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

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

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

  inline Mutation& operator=(const Mutation& from) {
    CopyFrom(from);
    return *this;
  }
  inline Mutation& operator=(Mutation&& 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 Mutation& default_instance() {
    return *internal_default_instance();
  }
  static inline const Mutation* internal_default_instance() {
    return reinterpret_cast<const Mutation*>(
               &_Mutation_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(Mutation& a, Mutation& b) {
    a.Swap(&b);
  }
  inline void Swap(Mutation* 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(Mutation* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Mutation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Mutation>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Mutation& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Mutation& from) {
    Mutation::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(Mutation* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "greptime.v1.Mutation";
  }
  protected:
  explicit Mutation(::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 {
    kRowsFieldNumber = 3,
    kWriteHintFieldNumber = 4,
    kSequenceFieldNumber = 2,
    kOpTypeFieldNumber = 1,
  };
  // .greptime.v1.Rows rows = 3;
  bool has_rows() const;
  private:
  bool _internal_has_rows() const;
  public:
  void clear_rows();
  const ::greptime::v1::Rows& rows() const;
  PROTOBUF_NODISCARD ::greptime::v1::Rows* release_rows();
  ::greptime::v1::Rows* mutable_rows();
  void set_allocated_rows(::greptime::v1::Rows* rows);
  private:
  const ::greptime::v1::Rows& _internal_rows() const;
  ::greptime::v1::Rows* _internal_mutable_rows();
  public:
  void unsafe_arena_set_allocated_rows(
      ::greptime::v1::Rows* rows);
  ::greptime::v1::Rows* unsafe_arena_release_rows();

  // .greptime.v1.WriteHint write_hint = 4;
  bool has_write_hint() const;
  private:
  bool _internal_has_write_hint() const;
  public:
  void clear_write_hint();
  const ::greptime::v1::WriteHint& write_hint() const;
  PROTOBUF_NODISCARD ::greptime::v1::WriteHint* release_write_hint();
  ::greptime::v1::WriteHint* mutable_write_hint();
  void set_allocated_write_hint(::greptime::v1::WriteHint* write_hint);
  private:
  const ::greptime::v1::WriteHint& _internal_write_hint() const;
  ::greptime::v1::WriteHint* _internal_mutable_write_hint();
  public:
  void unsafe_arena_set_allocated_write_hint(
      ::greptime::v1::WriteHint* write_hint);
  ::greptime::v1::WriteHint* unsafe_arena_release_write_hint();

  // uint64 sequence = 2;
  void clear_sequence();
  uint64_t sequence() const;
  void set_sequence(uint64_t value);
  private:
  uint64_t _internal_sequence() const;
  void _internal_set_sequence(uint64_t value);
  public:

  // .greptime.v1.OpType op_type = 1;
  void clear_op_type();
  ::greptime::v1::OpType op_type() const;
  void set_op_type(::greptime::v1::OpType value);
  private:
  ::greptime::v1::OpType _internal_op_type() const;
  void _internal_set_op_type(::greptime::v1::OpType value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::greptime::v1::Rows* rows_;
    ::greptime::v1::WriteHint* write_hint_;
    uint64_t sequence_;
    int op_type_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_greptime_2fv1_2fwal_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline WalEntry& operator=(const WalEntry& from) {
    CopyFrom(from);
    return *this;
  }
  inline WalEntry& operator=(WalEntry&& 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 WalEntry& default_instance() {
    return *internal_default_instance();
  }
  static inline const WalEntry* internal_default_instance() {
    return reinterpret_cast<const WalEntry*>(
               &_WalEntry_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(WalEntry& a, WalEntry& b) {
    a.Swap(&b);
  }
  inline void Swap(WalEntry* 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(WalEntry* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  WalEntry* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<WalEntry>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const WalEntry& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const WalEntry& from) {
    WalEntry::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(WalEntry* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "greptime.v1.WalEntry";
  }
  protected:
  explicit WalEntry(::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 {
    kMutationsFieldNumber = 1,
    kBulkEntriesFieldNumber = 2,
  };
  // repeated .greptime.v1.Mutation mutations = 1;
  int mutations_size() const;
  private:
  int _internal_mutations_size() const;
  public:
  void clear_mutations();
  ::greptime::v1::Mutation* mutable_mutations(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Mutation >*
      mutable_mutations();
  private:
  const ::greptime::v1::Mutation& _internal_mutations(int index) const;
  ::greptime::v1::Mutation* _internal_add_mutations();
  public:
  const ::greptime::v1::Mutation& mutations(int index) const;
  ::greptime::v1::Mutation* add_mutations();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Mutation >&
      mutations() const;

  // repeated .greptime.v1.BulkWalEntry bulk_entries = 2;
  int bulk_entries_size() const;
  private:
  int _internal_bulk_entries_size() const;
  public:
  void clear_bulk_entries();
  ::greptime::v1::BulkWalEntry* mutable_bulk_entries(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::BulkWalEntry >*
      mutable_bulk_entries();
  private:
  const ::greptime::v1::BulkWalEntry& _internal_bulk_entries(int index) const;
  ::greptime::v1::BulkWalEntry* _internal_add_bulk_entries();
  public:
  const ::greptime::v1::BulkWalEntry& bulk_entries(int index) const;
  ::greptime::v1::BulkWalEntry* add_bulk_entries();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::BulkWalEntry >&
      bulk_entries() const;

  // @@protoc_insertion_point(class_scope:greptime.v1.WalEntry)
 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::Mutation > mutations_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::BulkWalEntry > bulk_entries_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_greptime_2fv1_2fwal_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline BulkWalEntry& operator=(const BulkWalEntry& from) {
    CopyFrom(from);
    return *this;
  }
  inline BulkWalEntry& operator=(BulkWalEntry&& 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 BulkWalEntry& default_instance() {
    return *internal_default_instance();
  }
  enum BodyCase {
    kArrowIpc = 5,
    BODY_NOT_SET = 0,
  };

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

  friend void swap(BulkWalEntry& a, BulkWalEntry& b) {
    a.Swap(&b);
  }
  inline void Swap(BulkWalEntry* 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(BulkWalEntry* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  BulkWalEntry* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<BulkWalEntry>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const BulkWalEntry& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const BulkWalEntry& from) {
    BulkWalEntry::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(BulkWalEntry* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "greptime.v1.BulkWalEntry";
  }
  protected:
  explicit BulkWalEntry(::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 {
    kSequenceFieldNumber = 1,
    kMaxTsFieldNumber = 2,
    kMinTsFieldNumber = 3,
    kTimestampIndexFieldNumber = 4,
    kArrowIpcFieldNumber = 5,
  };
  // uint64 sequence = 1;
  void clear_sequence();
  uint64_t sequence() const;
  void set_sequence(uint64_t value);
  private:
  uint64_t _internal_sequence() const;
  void _internal_set_sequence(uint64_t value);
  public:

  // int64 max_ts = 2;
  void clear_max_ts();
  int64_t max_ts() const;
  void set_max_ts(int64_t value);
  private:
  int64_t _internal_max_ts() const;
  void _internal_set_max_ts(int64_t value);
  public:

  // int64 min_ts = 3;
  void clear_min_ts();
  int64_t min_ts() const;
  void set_min_ts(int64_t value);
  private:
  int64_t _internal_min_ts() const;
  void _internal_set_min_ts(int64_t value);
  public:

  // uint32 timestamp_index = 4;
  void clear_timestamp_index();
  uint32_t timestamp_index() const;
  void set_timestamp_index(uint32_t value);
  private:
  uint32_t _internal_timestamp_index() const;
  void _internal_set_timestamp_index(uint32_t value);
  public:

  // .greptime.v1.ArrowIpc arrow_ipc = 5;
  bool has_arrow_ipc() const;
  private:
  bool _internal_has_arrow_ipc() const;
  public:
  void clear_arrow_ipc();
  const ::greptime::v1::ArrowIpc& arrow_ipc() const;
  PROTOBUF_NODISCARD ::greptime::v1::ArrowIpc* release_arrow_ipc();
  ::greptime::v1::ArrowIpc* mutable_arrow_ipc();
  void set_allocated_arrow_ipc(::greptime::v1::ArrowIpc* arrow_ipc);
  private:
  const ::greptime::v1::ArrowIpc& _internal_arrow_ipc() const;
  ::greptime::v1::ArrowIpc* _internal_mutable_arrow_ipc();
  public:
  void unsafe_arena_set_allocated_arrow_ipc(
      ::greptime::v1::ArrowIpc* arrow_ipc);
  ::greptime::v1::ArrowIpc* unsafe_arena_release_arrow_ipc();

  void clear_body();
  BodyCase body_case() const;
  // @@protoc_insertion_point(class_scope:greptime.v1.BulkWalEntry)
 private:
  class _Internal;
  void set_has_arrow_ipc();

  inline bool has_body() const;
  inline void clear_has_body();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    uint64_t sequence_;
    int64_t max_ts_;
    int64_t min_ts_;
    uint32_t timestamp_index_;
    union BodyUnion {
      constexpr BodyUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::greptime::v1::ArrowIpc* arrow_ipc_;
    } body_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t _oneof_case_[1];

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


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

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

// .greptime.v1.PrimaryKeyEncoding primary_key_encoding = 1;
inline void WriteHint::clear_primary_key_encoding() {
  _impl_.primary_key_encoding_ = 0;
}
inline ::greptime::v1::PrimaryKeyEncoding WriteHint::_internal_primary_key_encoding() const {
  return static_cast< ::greptime::v1::PrimaryKeyEncoding >(_impl_.primary_key_encoding_);
}
inline ::greptime::v1::PrimaryKeyEncoding WriteHint::primary_key_encoding() const {
  // @@protoc_insertion_point(field_get:greptime.v1.WriteHint.primary_key_encoding)
  return _internal_primary_key_encoding();
}
inline void WriteHint::_internal_set_primary_key_encoding(::greptime::v1::PrimaryKeyEncoding value) {
  
  _impl_.primary_key_encoding_ = value;
}
inline void WriteHint::set_primary_key_encoding(::greptime::v1::PrimaryKeyEncoding value) {
  _internal_set_primary_key_encoding(value);
  // @@protoc_insertion_point(field_set:greptime.v1.WriteHint.primary_key_encoding)
}

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

// Mutation

// .greptime.v1.OpType op_type = 1;
inline void Mutation::clear_op_type() {
  _impl_.op_type_ = 0;
}
inline ::greptime::v1::OpType Mutation::_internal_op_type() const {
  return static_cast< ::greptime::v1::OpType >(_impl_.op_type_);
}
inline ::greptime::v1::OpType Mutation::op_type() const {
  // @@protoc_insertion_point(field_get:greptime.v1.Mutation.op_type)
  return _internal_op_type();
}
inline void Mutation::_internal_set_op_type(::greptime::v1::OpType value) {
  
  _impl_.op_type_ = value;
}
inline void Mutation::set_op_type(::greptime::v1::OpType value) {
  _internal_set_op_type(value);
  // @@protoc_insertion_point(field_set:greptime.v1.Mutation.op_type)
}

// uint64 sequence = 2;
inline void Mutation::clear_sequence() {
  _impl_.sequence_ = uint64_t{0u};
}
inline uint64_t Mutation::_internal_sequence() const {
  return _impl_.sequence_;
}
inline uint64_t Mutation::sequence() const {
  // @@protoc_insertion_point(field_get:greptime.v1.Mutation.sequence)
  return _internal_sequence();
}
inline void Mutation::_internal_set_sequence(uint64_t value) {
  
  _impl_.sequence_ = value;
}
inline void Mutation::set_sequence(uint64_t value) {
  _internal_set_sequence(value);
  // @@protoc_insertion_point(field_set:greptime.v1.Mutation.sequence)
}

// .greptime.v1.Rows rows = 3;
inline bool Mutation::_internal_has_rows() const {
  return this != internal_default_instance() && _impl_.rows_ != nullptr;
}
inline bool Mutation::has_rows() const {
  return _internal_has_rows();
}
inline const ::greptime::v1::Rows& Mutation::_internal_rows() const {
  const ::greptime::v1::Rows* p = _impl_.rows_;
  return p != nullptr ? *p : reinterpret_cast<const ::greptime::v1::Rows&>(
      ::greptime::v1::_Rows_default_instance_);
}
inline const ::greptime::v1::Rows& Mutation::rows() const {
  // @@protoc_insertion_point(field_get:greptime.v1.Mutation.rows)
  return _internal_rows();
}
inline void Mutation::unsafe_arena_set_allocated_rows(
    ::greptime::v1::Rows* rows) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.rows_);
  }
  _impl_.rows_ = rows;
  if (rows) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.Mutation.rows)
}
inline ::greptime::v1::Rows* Mutation::release_rows() {
  
  ::greptime::v1::Rows* temp = _impl_.rows_;
  _impl_.rows_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::greptime::v1::Rows* Mutation::unsafe_arena_release_rows() {
  // @@protoc_insertion_point(field_release:greptime.v1.Mutation.rows)
  
  ::greptime::v1::Rows* temp = _impl_.rows_;
  _impl_.rows_ = nullptr;
  return temp;
}
inline ::greptime::v1::Rows* Mutation::_internal_mutable_rows() {
  
  if (_impl_.rows_ == nullptr) {
    auto* p = CreateMaybeMessage<::greptime::v1::Rows>(GetArenaForAllocation());
    _impl_.rows_ = p;
  }
  return _impl_.rows_;
}
inline ::greptime::v1::Rows* Mutation::mutable_rows() {
  ::greptime::v1::Rows* _msg = _internal_mutable_rows();
  // @@protoc_insertion_point(field_mutable:greptime.v1.Mutation.rows)
  return _msg;
}
inline void Mutation::set_allocated_rows(::greptime::v1::Rows* rows) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.rows_);
  }
  if (rows) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(rows));
    if (message_arena != submessage_arena) {
      rows = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, rows, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.rows_ = rows;
  // @@protoc_insertion_point(field_set_allocated:greptime.v1.Mutation.rows)
}

// .greptime.v1.WriteHint write_hint = 4;
inline bool Mutation::_internal_has_write_hint() const {
  return this != internal_default_instance() && _impl_.write_hint_ != nullptr;
}
inline bool Mutation::has_write_hint() const {
  return _internal_has_write_hint();
}
inline void Mutation::clear_write_hint() {
  if (GetArenaForAllocation() == nullptr && _impl_.write_hint_ != nullptr) {
    delete _impl_.write_hint_;
  }
  _impl_.write_hint_ = nullptr;
}
inline const ::greptime::v1::WriteHint& Mutation::_internal_write_hint() const {
  const ::greptime::v1::WriteHint* p = _impl_.write_hint_;
  return p != nullptr ? *p : reinterpret_cast<const ::greptime::v1::WriteHint&>(
      ::greptime::v1::_WriteHint_default_instance_);
}
inline const ::greptime::v1::WriteHint& Mutation::write_hint() const {
  // @@protoc_insertion_point(field_get:greptime.v1.Mutation.write_hint)
  return _internal_write_hint();
}
inline void Mutation::unsafe_arena_set_allocated_write_hint(
    ::greptime::v1::WriteHint* write_hint) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.write_hint_);
  }
  _impl_.write_hint_ = write_hint;
  if (write_hint) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.Mutation.write_hint)
}
inline ::greptime::v1::WriteHint* Mutation::release_write_hint() {
  
  ::greptime::v1::WriteHint* temp = _impl_.write_hint_;
  _impl_.write_hint_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::greptime::v1::WriteHint* Mutation::unsafe_arena_release_write_hint() {
  // @@protoc_insertion_point(field_release:greptime.v1.Mutation.write_hint)
  
  ::greptime::v1::WriteHint* temp = _impl_.write_hint_;
  _impl_.write_hint_ = nullptr;
  return temp;
}
inline ::greptime::v1::WriteHint* Mutation::_internal_mutable_write_hint() {
  
  if (_impl_.write_hint_ == nullptr) {
    auto* p = CreateMaybeMessage<::greptime::v1::WriteHint>(GetArenaForAllocation());
    _impl_.write_hint_ = p;
  }
  return _impl_.write_hint_;
}
inline ::greptime::v1::WriteHint* Mutation::mutable_write_hint() {
  ::greptime::v1::WriteHint* _msg = _internal_mutable_write_hint();
  // @@protoc_insertion_point(field_mutable:greptime.v1.Mutation.write_hint)
  return _msg;
}
inline void Mutation::set_allocated_write_hint(::greptime::v1::WriteHint* write_hint) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.write_hint_;
  }
  if (write_hint) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(write_hint);
    if (message_arena != submessage_arena) {
      write_hint = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, write_hint, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.write_hint_ = write_hint;
  // @@protoc_insertion_point(field_set_allocated:greptime.v1.Mutation.write_hint)
}

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

// WalEntry

// repeated .greptime.v1.Mutation mutations = 1;
inline int WalEntry::_internal_mutations_size() const {
  return _impl_.mutations_.size();
}
inline int WalEntry::mutations_size() const {
  return _internal_mutations_size();
}
inline void WalEntry::clear_mutations() {
  _impl_.mutations_.Clear();
}
inline ::greptime::v1::Mutation* WalEntry::mutable_mutations(int index) {
  // @@protoc_insertion_point(field_mutable:greptime.v1.WalEntry.mutations)
  return _impl_.mutations_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Mutation >*
WalEntry::mutable_mutations() {
  // @@protoc_insertion_point(field_mutable_list:greptime.v1.WalEntry.mutations)
  return &_impl_.mutations_;
}
inline const ::greptime::v1::Mutation& WalEntry::_internal_mutations(int index) const {
  return _impl_.mutations_.Get(index);
}
inline const ::greptime::v1::Mutation& WalEntry::mutations(int index) const {
  // @@protoc_insertion_point(field_get:greptime.v1.WalEntry.mutations)
  return _internal_mutations(index);
}
inline ::greptime::v1::Mutation* WalEntry::_internal_add_mutations() {
  return _impl_.mutations_.Add();
}
inline ::greptime::v1::Mutation* WalEntry::add_mutations() {
  ::greptime::v1::Mutation* _add = _internal_add_mutations();
  // @@protoc_insertion_point(field_add:greptime.v1.WalEntry.mutations)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Mutation >&
WalEntry::mutations() const {
  // @@protoc_insertion_point(field_list:greptime.v1.WalEntry.mutations)
  return _impl_.mutations_;
}

// repeated .greptime.v1.BulkWalEntry bulk_entries = 2;
inline int WalEntry::_internal_bulk_entries_size() const {
  return _impl_.bulk_entries_.size();
}
inline int WalEntry::bulk_entries_size() const {
  return _internal_bulk_entries_size();
}
inline void WalEntry::clear_bulk_entries() {
  _impl_.bulk_entries_.Clear();
}
inline ::greptime::v1::BulkWalEntry* WalEntry::mutable_bulk_entries(int index) {
  // @@protoc_insertion_point(field_mutable:greptime.v1.WalEntry.bulk_entries)
  return _impl_.bulk_entries_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::BulkWalEntry >*
WalEntry::mutable_bulk_entries() {
  // @@protoc_insertion_point(field_mutable_list:greptime.v1.WalEntry.bulk_entries)
  return &_impl_.bulk_entries_;
}
inline const ::greptime::v1::BulkWalEntry& WalEntry::_internal_bulk_entries(int index) const {
  return _impl_.bulk_entries_.Get(index);
}
inline const ::greptime::v1::BulkWalEntry& WalEntry::bulk_entries(int index) const {
  // @@protoc_insertion_point(field_get:greptime.v1.WalEntry.bulk_entries)
  return _internal_bulk_entries(index);
}
inline ::greptime::v1::BulkWalEntry* WalEntry::_internal_add_bulk_entries() {
  return _impl_.bulk_entries_.Add();
}
inline ::greptime::v1::BulkWalEntry* WalEntry::add_bulk_entries() {
  ::greptime::v1::BulkWalEntry* _add = _internal_add_bulk_entries();
  // @@protoc_insertion_point(field_add:greptime.v1.WalEntry.bulk_entries)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::BulkWalEntry >&
WalEntry::bulk_entries() const {
  // @@protoc_insertion_point(field_list:greptime.v1.WalEntry.bulk_entries)
  return _impl_.bulk_entries_;
}

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

// BulkWalEntry

// uint64 sequence = 1;
inline void BulkWalEntry::clear_sequence() {
  _impl_.sequence_ = uint64_t{0u};
}
inline uint64_t BulkWalEntry::_internal_sequence() const {
  return _impl_.sequence_;
}
inline uint64_t BulkWalEntry::sequence() const {
  // @@protoc_insertion_point(field_get:greptime.v1.BulkWalEntry.sequence)
  return _internal_sequence();
}
inline void BulkWalEntry::_internal_set_sequence(uint64_t value) {
  
  _impl_.sequence_ = value;
}
inline void BulkWalEntry::set_sequence(uint64_t value) {
  _internal_set_sequence(value);
  // @@protoc_insertion_point(field_set:greptime.v1.BulkWalEntry.sequence)
}

// int64 max_ts = 2;
inline void BulkWalEntry::clear_max_ts() {
  _impl_.max_ts_ = int64_t{0};
}
inline int64_t BulkWalEntry::_internal_max_ts() const {
  return _impl_.max_ts_;
}
inline int64_t BulkWalEntry::max_ts() const {
  // @@protoc_insertion_point(field_get:greptime.v1.BulkWalEntry.max_ts)
  return _internal_max_ts();
}
inline void BulkWalEntry::_internal_set_max_ts(int64_t value) {
  
  _impl_.max_ts_ = value;
}
inline void BulkWalEntry::set_max_ts(int64_t value) {
  _internal_set_max_ts(value);
  // @@protoc_insertion_point(field_set:greptime.v1.BulkWalEntry.max_ts)
}

// int64 min_ts = 3;
inline void BulkWalEntry::clear_min_ts() {
  _impl_.min_ts_ = int64_t{0};
}
inline int64_t BulkWalEntry::_internal_min_ts() const {
  return _impl_.min_ts_;
}
inline int64_t BulkWalEntry::min_ts() const {
  // @@protoc_insertion_point(field_get:greptime.v1.BulkWalEntry.min_ts)
  return _internal_min_ts();
}
inline void BulkWalEntry::_internal_set_min_ts(int64_t value) {
  
  _impl_.min_ts_ = value;
}
inline void BulkWalEntry::set_min_ts(int64_t value) {
  _internal_set_min_ts(value);
  // @@protoc_insertion_point(field_set:greptime.v1.BulkWalEntry.min_ts)
}

// uint32 timestamp_index = 4;
inline void BulkWalEntry::clear_timestamp_index() {
  _impl_.timestamp_index_ = 0u;
}
inline uint32_t BulkWalEntry::_internal_timestamp_index() const {
  return _impl_.timestamp_index_;
}
inline uint32_t BulkWalEntry::timestamp_index() const {
  // @@protoc_insertion_point(field_get:greptime.v1.BulkWalEntry.timestamp_index)
  return _internal_timestamp_index();
}
inline void BulkWalEntry::_internal_set_timestamp_index(uint32_t value) {
  
  _impl_.timestamp_index_ = value;
}
inline void BulkWalEntry::set_timestamp_index(uint32_t value) {
  _internal_set_timestamp_index(value);
  // @@protoc_insertion_point(field_set:greptime.v1.BulkWalEntry.timestamp_index)
}

// .greptime.v1.ArrowIpc arrow_ipc = 5;
inline bool BulkWalEntry::_internal_has_arrow_ipc() const {
  return body_case() == kArrowIpc;
}
inline bool BulkWalEntry::has_arrow_ipc() const {
  return _internal_has_arrow_ipc();
}
inline void BulkWalEntry::set_has_arrow_ipc() {
  _impl_._oneof_case_[0] = kArrowIpc;
}
inline ::greptime::v1::ArrowIpc* BulkWalEntry::release_arrow_ipc() {
  // @@protoc_insertion_point(field_release:greptime.v1.BulkWalEntry.arrow_ipc)
  if (_internal_has_arrow_ipc()) {
    clear_has_body();
    ::greptime::v1::ArrowIpc* temp = _impl_.body_.arrow_ipc_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.body_.arrow_ipc_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::greptime::v1::ArrowIpc& BulkWalEntry::_internal_arrow_ipc() const {
  return _internal_has_arrow_ipc()
      ? *_impl_.body_.arrow_ipc_
      : reinterpret_cast< ::greptime::v1::ArrowIpc&>(::greptime::v1::_ArrowIpc_default_instance_);
}
inline const ::greptime::v1::ArrowIpc& BulkWalEntry::arrow_ipc() const {
  // @@protoc_insertion_point(field_get:greptime.v1.BulkWalEntry.arrow_ipc)
  return _internal_arrow_ipc();
}
inline ::greptime::v1::ArrowIpc* BulkWalEntry::unsafe_arena_release_arrow_ipc() {
  // @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.BulkWalEntry.arrow_ipc)
  if (_internal_has_arrow_ipc()) {
    clear_has_body();
    ::greptime::v1::ArrowIpc* temp = _impl_.body_.arrow_ipc_;
    _impl_.body_.arrow_ipc_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void BulkWalEntry::unsafe_arena_set_allocated_arrow_ipc(::greptime::v1::ArrowIpc* arrow_ipc) {
  clear_body();
  if (arrow_ipc) {
    set_has_arrow_ipc();
    _impl_.body_.arrow_ipc_ = arrow_ipc;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.BulkWalEntry.arrow_ipc)
}
inline ::greptime::v1::ArrowIpc* BulkWalEntry::_internal_mutable_arrow_ipc() {
  if (!_internal_has_arrow_ipc()) {
    clear_body();
    set_has_arrow_ipc();
    _impl_.body_.arrow_ipc_ = CreateMaybeMessage< ::greptime::v1::ArrowIpc >(GetArenaForAllocation());
  }
  return _impl_.body_.arrow_ipc_;
}
inline ::greptime::v1::ArrowIpc* BulkWalEntry::mutable_arrow_ipc() {
  ::greptime::v1::ArrowIpc* _msg = _internal_mutable_arrow_ipc();
  // @@protoc_insertion_point(field_mutable:greptime.v1.BulkWalEntry.arrow_ipc)
  return _msg;
}

inline bool BulkWalEntry::has_body() const {
  return body_case() != BODY_NOT_SET;
}
inline void BulkWalEntry::clear_has_body() {
  _impl_._oneof_case_[0] = BODY_NOT_SET;
}
inline BulkWalEntry::BodyCase BulkWalEntry::body_case() const {
  return BulkWalEntry::BodyCase(_impl_._oneof_case_[0]);
}
#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace v1
}  // namespace greptime

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::greptime::v1::OpType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::greptime::v1::OpType>() {
  return ::greptime::v1::OpType_descriptor();
}
template <> struct is_proto_enum< ::greptime::v1::PrimaryKeyEncoding> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::greptime::v1::PrimaryKeyEncoding>() {
  return ::greptime::v1::PrimaryKeyEncoding_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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