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

#ifndef GOOGLE_PROTOBUF_INCLUDED_greptime_2fv1_2fdatabase_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_greptime_2fv1_2fdatabase_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/ddl.pb.h"
#include "greptime/v1/column.pb.h"
#include "greptime/v1/row.pb.h"
#include "greptime/v1/prom.pb.h"
#include "greptime/v1/common.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_greptime_2fv1_2fdatabase_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_2fdatabase_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_greptime_2fv1_2fdatabase_2eproto;
namespace greptime {
namespace v1 {
class DeleteRequest;
struct DeleteRequestDefaultTypeInternal;
extern DeleteRequestDefaultTypeInternal _DeleteRequest_default_instance_;
class DeleteRequests;
struct DeleteRequestsDefaultTypeInternal;
extern DeleteRequestsDefaultTypeInternal _DeleteRequests_default_instance_;
class GreptimeRequest;
struct GreptimeRequestDefaultTypeInternal;
extern GreptimeRequestDefaultTypeInternal _GreptimeRequest_default_instance_;
class GreptimeResponse;
struct GreptimeResponseDefaultTypeInternal;
extern GreptimeResponseDefaultTypeInternal _GreptimeResponse_default_instance_;
class InsertIntoPlan;
struct InsertIntoPlanDefaultTypeInternal;
extern InsertIntoPlanDefaultTypeInternal _InsertIntoPlan_default_instance_;
class InsertRequest;
struct InsertRequestDefaultTypeInternal;
extern InsertRequestDefaultTypeInternal _InsertRequest_default_instance_;
class InsertRequests;
struct InsertRequestsDefaultTypeInternal;
extern InsertRequestsDefaultTypeInternal _InsertRequests_default_instance_;
class QueryRequest;
struct QueryRequestDefaultTypeInternal;
extern QueryRequestDefaultTypeInternal _QueryRequest_default_instance_;
class RowDeleteRequest;
struct RowDeleteRequestDefaultTypeInternal;
extern RowDeleteRequestDefaultTypeInternal _RowDeleteRequest_default_instance_;
class RowDeleteRequests;
struct RowDeleteRequestsDefaultTypeInternal;
extern RowDeleteRequestsDefaultTypeInternal _RowDeleteRequests_default_instance_;
class RowInsertRequest;
struct RowInsertRequestDefaultTypeInternal;
extern RowInsertRequestDefaultTypeInternal _RowInsertRequest_default_instance_;
class RowInsertRequests;
struct RowInsertRequestsDefaultTypeInternal;
extern RowInsertRequestsDefaultTypeInternal _RowInsertRequests_default_instance_;
}  // namespace v1
}  // namespace greptime
PROTOBUF_NAMESPACE_OPEN
template<> ::greptime::v1::DeleteRequest* Arena::CreateMaybeMessage<::greptime::v1::DeleteRequest>(Arena*);
template<> ::greptime::v1::DeleteRequests* Arena::CreateMaybeMessage<::greptime::v1::DeleteRequests>(Arena*);
template<> ::greptime::v1::GreptimeRequest* Arena::CreateMaybeMessage<::greptime::v1::GreptimeRequest>(Arena*);
template<> ::greptime::v1::GreptimeResponse* Arena::CreateMaybeMessage<::greptime::v1::GreptimeResponse>(Arena*);
template<> ::greptime::v1::InsertIntoPlan* Arena::CreateMaybeMessage<::greptime::v1::InsertIntoPlan>(Arena*);
template<> ::greptime::v1::InsertRequest* Arena::CreateMaybeMessage<::greptime::v1::InsertRequest>(Arena*);
template<> ::greptime::v1::InsertRequests* Arena::CreateMaybeMessage<::greptime::v1::InsertRequests>(Arena*);
template<> ::greptime::v1::QueryRequest* Arena::CreateMaybeMessage<::greptime::v1::QueryRequest>(Arena*);
template<> ::greptime::v1::RowDeleteRequest* Arena::CreateMaybeMessage<::greptime::v1::RowDeleteRequest>(Arena*);
template<> ::greptime::v1::RowDeleteRequests* Arena::CreateMaybeMessage<::greptime::v1::RowDeleteRequests>(Arena*);
template<> ::greptime::v1::RowInsertRequest* Arena::CreateMaybeMessage<::greptime::v1::RowInsertRequest>(Arena*);
template<> ::greptime::v1::RowInsertRequests* Arena::CreateMaybeMessage<::greptime::v1::RowInsertRequests>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace greptime {
namespace v1 {

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

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

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

  inline GreptimeRequest& operator=(const GreptimeRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline GreptimeRequest& operator=(GreptimeRequest&& 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 GreptimeRequest& default_instance() {
    return *internal_default_instance();
  }
  enum RequestCase {
    kInserts = 2,
    kQuery = 3,
    kDdl = 4,
    kDeletes = 5,
    kRowInserts = 6,
    kRowDeletes = 7,
    REQUEST_NOT_SET = 0,
  };

  static inline const GreptimeRequest* internal_default_instance() {
    return reinterpret_cast<const GreptimeRequest*>(
               &_GreptimeRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "greptime.v1.GreptimeRequest";
  }
  protected:
  explicit GreptimeRequest(::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 {
    kHeaderFieldNumber = 1,
    kInsertsFieldNumber = 2,
    kQueryFieldNumber = 3,
    kDdlFieldNumber = 4,
    kDeletesFieldNumber = 5,
    kRowInsertsFieldNumber = 6,
    kRowDeletesFieldNumber = 7,
  };
  // .greptime.v1.RequestHeader header = 1;
  bool has_header() const;
  private:
  bool _internal_has_header() const;
  public:
  void clear_header();
  const ::greptime::v1::RequestHeader& header() const;
  PROTOBUF_NODISCARD ::greptime::v1::RequestHeader* release_header();
  ::greptime::v1::RequestHeader* mutable_header();
  void set_allocated_header(::greptime::v1::RequestHeader* header);
  private:
  const ::greptime::v1::RequestHeader& _internal_header() const;
  ::greptime::v1::RequestHeader* _internal_mutable_header();
  public:
  void unsafe_arena_set_allocated_header(
      ::greptime::v1::RequestHeader* header);
  ::greptime::v1::RequestHeader* unsafe_arena_release_header();

  // .greptime.v1.InsertRequests inserts = 2;
  bool has_inserts() const;
  private:
  bool _internal_has_inserts() const;
  public:
  void clear_inserts();
  const ::greptime::v1::InsertRequests& inserts() const;
  PROTOBUF_NODISCARD ::greptime::v1::InsertRequests* release_inserts();
  ::greptime::v1::InsertRequests* mutable_inserts();
  void set_allocated_inserts(::greptime::v1::InsertRequests* inserts);
  private:
  const ::greptime::v1::InsertRequests& _internal_inserts() const;
  ::greptime::v1::InsertRequests* _internal_mutable_inserts();
  public:
  void unsafe_arena_set_allocated_inserts(
      ::greptime::v1::InsertRequests* inserts);
  ::greptime::v1::InsertRequests* unsafe_arena_release_inserts();

  // .greptime.v1.QueryRequest query = 3;
  bool has_query() const;
  private:
  bool _internal_has_query() const;
  public:
  void clear_query();
  const ::greptime::v1::QueryRequest& query() const;
  PROTOBUF_NODISCARD ::greptime::v1::QueryRequest* release_query();
  ::greptime::v1::QueryRequest* mutable_query();
  void set_allocated_query(::greptime::v1::QueryRequest* query);
  private:
  const ::greptime::v1::QueryRequest& _internal_query() const;
  ::greptime::v1::QueryRequest* _internal_mutable_query();
  public:
  void unsafe_arena_set_allocated_query(
      ::greptime::v1::QueryRequest* query);
  ::greptime::v1::QueryRequest* unsafe_arena_release_query();

  // .greptime.v1.DdlRequest ddl = 4;
  bool has_ddl() const;
  private:
  bool _internal_has_ddl() const;
  public:
  void clear_ddl();
  const ::greptime::v1::DdlRequest& ddl() const;
  PROTOBUF_NODISCARD ::greptime::v1::DdlRequest* release_ddl();
  ::greptime::v1::DdlRequest* mutable_ddl();
  void set_allocated_ddl(::greptime::v1::DdlRequest* ddl);
  private:
  const ::greptime::v1::DdlRequest& _internal_ddl() const;
  ::greptime::v1::DdlRequest* _internal_mutable_ddl();
  public:
  void unsafe_arena_set_allocated_ddl(
      ::greptime::v1::DdlRequest* ddl);
  ::greptime::v1::DdlRequest* unsafe_arena_release_ddl();

  // .greptime.v1.DeleteRequests deletes = 5;
  bool has_deletes() const;
  private:
  bool _internal_has_deletes() const;
  public:
  void clear_deletes();
  const ::greptime::v1::DeleteRequests& deletes() const;
  PROTOBUF_NODISCARD ::greptime::v1::DeleteRequests* release_deletes();
  ::greptime::v1::DeleteRequests* mutable_deletes();
  void set_allocated_deletes(::greptime::v1::DeleteRequests* deletes);
  private:
  const ::greptime::v1::DeleteRequests& _internal_deletes() const;
  ::greptime::v1::DeleteRequests* _internal_mutable_deletes();
  public:
  void unsafe_arena_set_allocated_deletes(
      ::greptime::v1::DeleteRequests* deletes);
  ::greptime::v1::DeleteRequests* unsafe_arena_release_deletes();

  // .greptime.v1.RowInsertRequests row_inserts = 6;
  bool has_row_inserts() const;
  private:
  bool _internal_has_row_inserts() const;
  public:
  void clear_row_inserts();
  const ::greptime::v1::RowInsertRequests& row_inserts() const;
  PROTOBUF_NODISCARD ::greptime::v1::RowInsertRequests* release_row_inserts();
  ::greptime::v1::RowInsertRequests* mutable_row_inserts();
  void set_allocated_row_inserts(::greptime::v1::RowInsertRequests* row_inserts);
  private:
  const ::greptime::v1::RowInsertRequests& _internal_row_inserts() const;
  ::greptime::v1::RowInsertRequests* _internal_mutable_row_inserts();
  public:
  void unsafe_arena_set_allocated_row_inserts(
      ::greptime::v1::RowInsertRequests* row_inserts);
  ::greptime::v1::RowInsertRequests* unsafe_arena_release_row_inserts();

  // .greptime.v1.RowDeleteRequests row_deletes = 7;
  bool has_row_deletes() const;
  private:
  bool _internal_has_row_deletes() const;
  public:
  void clear_row_deletes();
  const ::greptime::v1::RowDeleteRequests& row_deletes() const;
  PROTOBUF_NODISCARD ::greptime::v1::RowDeleteRequests* release_row_deletes();
  ::greptime::v1::RowDeleteRequests* mutable_row_deletes();
  void set_allocated_row_deletes(::greptime::v1::RowDeleteRequests* row_deletes);
  private:
  const ::greptime::v1::RowDeleteRequests& _internal_row_deletes() const;
  ::greptime::v1::RowDeleteRequests* _internal_mutable_row_deletes();
  public:
  void unsafe_arena_set_allocated_row_deletes(
      ::greptime::v1::RowDeleteRequests* row_deletes);
  ::greptime::v1::RowDeleteRequests* unsafe_arena_release_row_deletes();

  void clear_request();
  RequestCase request_case() const;
  // @@protoc_insertion_point(class_scope:greptime.v1.GreptimeRequest)
 private:
  class _Internal;
  void set_has_inserts();
  void set_has_query();
  void set_has_ddl();
  void set_has_deletes();
  void set_has_row_inserts();
  void set_has_row_deletes();

  inline bool has_request() const;
  inline void clear_has_request();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::greptime::v1::RequestHeader* header_;
    union RequestUnion {
      constexpr RequestUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::greptime::v1::InsertRequests* inserts_;
      ::greptime::v1::QueryRequest* query_;
      ::greptime::v1::DdlRequest* ddl_;
      ::greptime::v1::DeleteRequests* deletes_;
      ::greptime::v1::RowInsertRequests* row_inserts_;
      ::greptime::v1::RowDeleteRequests* row_deletes_;
    } request_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_greptime_2fv1_2fdatabase_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline GreptimeResponse& operator=(const GreptimeResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline GreptimeResponse& operator=(GreptimeResponse&& 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 GreptimeResponse& default_instance() {
    return *internal_default_instance();
  }
  enum ResponseCase {
    kAffectedRows = 2,
    RESPONSE_NOT_SET = 0,
  };

  static inline const GreptimeResponse* internal_default_instance() {
    return reinterpret_cast<const GreptimeResponse*>(
               &_GreptimeResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "greptime.v1.GreptimeResponse";
  }
  protected:
  explicit GreptimeResponse(::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 {
    kHeaderFieldNumber = 1,
    kAffectedRowsFieldNumber = 2,
  };
  // .greptime.v1.ResponseHeader header = 1;
  bool has_header() const;
  private:
  bool _internal_has_header() const;
  public:
  void clear_header();
  const ::greptime::v1::ResponseHeader& header() const;
  PROTOBUF_NODISCARD ::greptime::v1::ResponseHeader* release_header();
  ::greptime::v1::ResponseHeader* mutable_header();
  void set_allocated_header(::greptime::v1::ResponseHeader* header);
  private:
  const ::greptime::v1::ResponseHeader& _internal_header() const;
  ::greptime::v1::ResponseHeader* _internal_mutable_header();
  public:
  void unsafe_arena_set_allocated_header(
      ::greptime::v1::ResponseHeader* header);
  ::greptime::v1::ResponseHeader* unsafe_arena_release_header();

  // .greptime.v1.AffectedRows affected_rows = 2;
  bool has_affected_rows() const;
  private:
  bool _internal_has_affected_rows() const;
  public:
  void clear_affected_rows();
  const ::greptime::v1::AffectedRows& affected_rows() const;
  PROTOBUF_NODISCARD ::greptime::v1::AffectedRows* release_affected_rows();
  ::greptime::v1::AffectedRows* mutable_affected_rows();
  void set_allocated_affected_rows(::greptime::v1::AffectedRows* affected_rows);
  private:
  const ::greptime::v1::AffectedRows& _internal_affected_rows() const;
  ::greptime::v1::AffectedRows* _internal_mutable_affected_rows();
  public:
  void unsafe_arena_set_allocated_affected_rows(
      ::greptime::v1::AffectedRows* affected_rows);
  ::greptime::v1::AffectedRows* unsafe_arena_release_affected_rows();

  void clear_response();
  ResponseCase response_case() const;
  // @@protoc_insertion_point(class_scope:greptime.v1.GreptimeResponse)
 private:
  class _Internal;
  void set_has_affected_rows();

  inline bool has_response() const;
  inline void clear_has_response();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::greptime::v1::ResponseHeader* header_;
    union ResponseUnion {
      constexpr ResponseUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::greptime::v1::AffectedRows* affected_rows_;
    } response_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_greptime_2fv1_2fdatabase_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline QueryRequest& operator=(const QueryRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline QueryRequest& operator=(QueryRequest&& 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 QueryRequest& default_instance() {
    return *internal_default_instance();
  }
  enum QueryCase {
    kSql = 1,
    kLogicalPlan = 2,
    kPromRangeQuery = 3,
    kInsertIntoPlan = 4,
    QUERY_NOT_SET = 0,
  };

  static inline const QueryRequest* internal_default_instance() {
    return reinterpret_cast<const QueryRequest*>(
               &_QueryRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "greptime.v1.QueryRequest";
  }
  protected:
  explicit QueryRequest(::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 {
    kSqlFieldNumber = 1,
    kLogicalPlanFieldNumber = 2,
    kPromRangeQueryFieldNumber = 3,
    kInsertIntoPlanFieldNumber = 4,
  };
  // string sql = 1;
  bool has_sql() const;
  private:
  bool _internal_has_sql() const;
  public:
  void clear_sql();
  const std::string& sql() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_sql(ArgT0&& arg0, ArgT... args);
  std::string* mutable_sql();
  PROTOBUF_NODISCARD std::string* release_sql();
  void set_allocated_sql(std::string* sql);
  private:
  const std::string& _internal_sql() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sql(const std::string& value);
  std::string* _internal_mutable_sql();
  public:

  // bytes logical_plan = 2;
  bool has_logical_plan() const;
  private:
  bool _internal_has_logical_plan() const;
  public:
  void clear_logical_plan();
  const std::string& logical_plan() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_logical_plan(ArgT0&& arg0, ArgT... args);
  std::string* mutable_logical_plan();
  PROTOBUF_NODISCARD std::string* release_logical_plan();
  void set_allocated_logical_plan(std::string* logical_plan);
  private:
  const std::string& _internal_logical_plan() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_logical_plan(const std::string& value);
  std::string* _internal_mutable_logical_plan();
  public:

  // .greptime.v1.PromRangeQuery prom_range_query = 3;
  bool has_prom_range_query() const;
  private:
  bool _internal_has_prom_range_query() const;
  public:
  void clear_prom_range_query();
  const ::greptime::v1::PromRangeQuery& prom_range_query() const;
  PROTOBUF_NODISCARD ::greptime::v1::PromRangeQuery* release_prom_range_query();
  ::greptime::v1::PromRangeQuery* mutable_prom_range_query();
  void set_allocated_prom_range_query(::greptime::v1::PromRangeQuery* prom_range_query);
  private:
  const ::greptime::v1::PromRangeQuery& _internal_prom_range_query() const;
  ::greptime::v1::PromRangeQuery* _internal_mutable_prom_range_query();
  public:
  void unsafe_arena_set_allocated_prom_range_query(
      ::greptime::v1::PromRangeQuery* prom_range_query);
  ::greptime::v1::PromRangeQuery* unsafe_arena_release_prom_range_query();

  // .greptime.v1.InsertIntoPlan insert_into_plan = 4;
  bool has_insert_into_plan() const;
  private:
  bool _internal_has_insert_into_plan() const;
  public:
  void clear_insert_into_plan();
  const ::greptime::v1::InsertIntoPlan& insert_into_plan() const;
  PROTOBUF_NODISCARD ::greptime::v1::InsertIntoPlan* release_insert_into_plan();
  ::greptime::v1::InsertIntoPlan* mutable_insert_into_plan();
  void set_allocated_insert_into_plan(::greptime::v1::InsertIntoPlan* insert_into_plan);
  private:
  const ::greptime::v1::InsertIntoPlan& _internal_insert_into_plan() const;
  ::greptime::v1::InsertIntoPlan* _internal_mutable_insert_into_plan();
  public:
  void unsafe_arena_set_allocated_insert_into_plan(
      ::greptime::v1::InsertIntoPlan* insert_into_plan);
  ::greptime::v1::InsertIntoPlan* unsafe_arena_release_insert_into_plan();

  void clear_query();
  QueryCase query_case() const;
  // @@protoc_insertion_point(class_scope:greptime.v1.QueryRequest)
 private:
  class _Internal;
  void set_has_sql();
  void set_has_logical_plan();
  void set_has_prom_range_query();
  void set_has_insert_into_plan();

  inline bool has_query() const;
  inline void clear_has_query();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    union QueryUnion {
      constexpr QueryUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sql_;
      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr logical_plan_;
      ::greptime::v1::PromRangeQuery* prom_range_query_;
      ::greptime::v1::InsertIntoPlan* insert_into_plan_;
    } query_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_greptime_2fv1_2fdatabase_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "greptime.v1.InsertIntoPlan";
  }
  protected:
  explicit InsertIntoPlan(::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 {
    kLogicalPlanFieldNumber = 2,
    kTableNameFieldNumber = 1,
  };
  // bytes logical_plan = 2;
  void clear_logical_plan();
  const std::string& logical_plan() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_logical_plan(ArgT0&& arg0, ArgT... args);
  std::string* mutable_logical_plan();
  PROTOBUF_NODISCARD std::string* release_logical_plan();
  void set_allocated_logical_plan(std::string* logical_plan);
  private:
  const std::string& _internal_logical_plan() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_logical_plan(const std::string& value);
  std::string* _internal_mutable_logical_plan();
  public:

  // .greptime.v1.TableName table_name = 1;
  bool has_table_name() const;
  private:
  bool _internal_has_table_name() const;
  public:
  void clear_table_name();
  const ::greptime::v1::TableName& table_name() const;
  PROTOBUF_NODISCARD ::greptime::v1::TableName* release_table_name();
  ::greptime::v1::TableName* mutable_table_name();
  void set_allocated_table_name(::greptime::v1::TableName* table_name);
  private:
  const ::greptime::v1::TableName& _internal_table_name() const;
  ::greptime::v1::TableName* _internal_mutable_table_name();
  public:
  void unsafe_arena_set_allocated_table_name(
      ::greptime::v1::TableName* table_name);
  ::greptime::v1::TableName* unsafe_arena_release_table_name();

  // @@protoc_insertion_point(class_scope:greptime.v1.InsertIntoPlan)
 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 logical_plan_;
    ::greptime::v1::TableName* table_name_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_greptime_2fv1_2fdatabase_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "greptime.v1.InsertRequests";
  }
  protected:
  explicit InsertRequests(::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 {
    kInsertsFieldNumber = 1,
  };
  // repeated .greptime.v1.InsertRequest inserts = 1;
  int inserts_size() const;
  private:
  int _internal_inserts_size() const;
  public:
  void clear_inserts();
  ::greptime::v1::InsertRequest* mutable_inserts(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::InsertRequest >*
      mutable_inserts();
  private:
  const ::greptime::v1::InsertRequest& _internal_inserts(int index) const;
  ::greptime::v1::InsertRequest* _internal_add_inserts();
  public:
  const ::greptime::v1::InsertRequest& inserts(int index) const;
  ::greptime::v1::InsertRequest* add_inserts();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::InsertRequest >&
      inserts() const;

  // @@protoc_insertion_point(class_scope:greptime.v1.InsertRequests)
 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::InsertRequest > inserts_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_greptime_2fv1_2fdatabase_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "greptime.v1.InsertRequest";
  }
  protected:
  explicit InsertRequest(::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 {
    kColumnsFieldNumber = 3,
    kTableNameFieldNumber = 1,
    kRowCountFieldNumber = 4,
  };
  // repeated .greptime.v1.Column columns = 3;
  int columns_size() const;
  private:
  int _internal_columns_size() const;
  public:
  void clear_columns();
  ::greptime::v1::Column* mutable_columns(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Column >*
      mutable_columns();
  private:
  const ::greptime::v1::Column& _internal_columns(int index) const;
  ::greptime::v1::Column* _internal_add_columns();
  public:
  const ::greptime::v1::Column& columns(int index) const;
  ::greptime::v1::Column* add_columns();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Column >&
      columns() const;

  // string table_name = 1;
  void clear_table_name();
  const std::string& table_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_table_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_table_name();
  PROTOBUF_NODISCARD std::string* release_table_name();
  void set_allocated_table_name(std::string* table_name);
  private:
  const std::string& _internal_table_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_table_name(const std::string& value);
  std::string* _internal_mutable_table_name();
  public:

  // uint32 row_count = 4;
  void clear_row_count();
  uint32_t row_count() const;
  void set_row_count(uint32_t value);
  private:
  uint32_t _internal_row_count() const;
  void _internal_set_row_count(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:greptime.v1.InsertRequest)
 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::Column > columns_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_name_;
    uint32_t row_count_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_greptime_2fv1_2fdatabase_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "greptime.v1.DeleteRequests";
  }
  protected:
  explicit DeleteRequests(::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 {
    kDeletesFieldNumber = 1,
  };
  // repeated .greptime.v1.DeleteRequest deletes = 1;
  int deletes_size() const;
  private:
  int _internal_deletes_size() const;
  public:
  void clear_deletes();
  ::greptime::v1::DeleteRequest* mutable_deletes(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::DeleteRequest >*
      mutable_deletes();
  private:
  const ::greptime::v1::DeleteRequest& _internal_deletes(int index) const;
  ::greptime::v1::DeleteRequest* _internal_add_deletes();
  public:
  const ::greptime::v1::DeleteRequest& deletes(int index) const;
  ::greptime::v1::DeleteRequest* add_deletes();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::DeleteRequest >&
      deletes() const;

  // @@protoc_insertion_point(class_scope:greptime.v1.DeleteRequests)
 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::DeleteRequest > deletes_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_greptime_2fv1_2fdatabase_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "greptime.v1.DeleteRequest";
  }
  protected:
  explicit DeleteRequest(::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 {
    kKeyColumnsFieldNumber = 3,
    kTableNameFieldNumber = 1,
    kRowCountFieldNumber = 4,
  };
  // repeated .greptime.v1.Column key_columns = 3;
  int key_columns_size() const;
  private:
  int _internal_key_columns_size() const;
  public:
  void clear_key_columns();
  ::greptime::v1::Column* mutable_key_columns(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Column >*
      mutable_key_columns();
  private:
  const ::greptime::v1::Column& _internal_key_columns(int index) const;
  ::greptime::v1::Column* _internal_add_key_columns();
  public:
  const ::greptime::v1::Column& key_columns(int index) const;
  ::greptime::v1::Column* add_key_columns();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Column >&
      key_columns() const;

  // string table_name = 1;
  void clear_table_name();
  const std::string& table_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_table_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_table_name();
  PROTOBUF_NODISCARD std::string* release_table_name();
  void set_allocated_table_name(std::string* table_name);
  private:
  const std::string& _internal_table_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_table_name(const std::string& value);
  std::string* _internal_mutable_table_name();
  public:

  // uint32 row_count = 4;
  void clear_row_count();
  uint32_t row_count() const;
  void set_row_count(uint32_t value);
  private:
  uint32_t _internal_row_count() const;
  void _internal_set_row_count(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:greptime.v1.DeleteRequest)
 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::Column > key_columns_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_name_;
    uint32_t row_count_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_greptime_2fv1_2fdatabase_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "greptime.v1.RowInsertRequests";
  }
  protected:
  explicit RowInsertRequests(::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 {
    kInsertsFieldNumber = 1,
  };
  // repeated .greptime.v1.RowInsertRequest inserts = 1;
  int inserts_size() const;
  private:
  int _internal_inserts_size() const;
  public:
  void clear_inserts();
  ::greptime::v1::RowInsertRequest* mutable_inserts(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::RowInsertRequest >*
      mutable_inserts();
  private:
  const ::greptime::v1::RowInsertRequest& _internal_inserts(int index) const;
  ::greptime::v1::RowInsertRequest* _internal_add_inserts();
  public:
  const ::greptime::v1::RowInsertRequest& inserts(int index) const;
  ::greptime::v1::RowInsertRequest* add_inserts();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::RowInsertRequest >&
      inserts() const;

  // @@protoc_insertion_point(class_scope:greptime.v1.RowInsertRequests)
 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::RowInsertRequest > inserts_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_greptime_2fv1_2fdatabase_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "greptime.v1.RowInsertRequest";
  }
  protected:
  explicit RowInsertRequest(::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 {
    kTableNameFieldNumber = 1,
    kRowsFieldNumber = 2,
  };
  // string table_name = 1;
  void clear_table_name();
  const std::string& table_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_table_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_table_name();
  PROTOBUF_NODISCARD std::string* release_table_name();
  void set_allocated_table_name(std::string* table_name);
  private:
  const std::string& _internal_table_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_table_name(const std::string& value);
  std::string* _internal_mutable_table_name();
  public:

  // .greptime.v1.Rows rows = 2;
  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();

  // @@protoc_insertion_point(class_scope:greptime.v1.RowInsertRequest)
 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 table_name_;
    ::greptime::v1::Rows* rows_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_greptime_2fv1_2fdatabase_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "greptime.v1.RowDeleteRequests";
  }
  protected:
  explicit RowDeleteRequests(::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 {
    kDeletesFieldNumber = 1,
  };
  // repeated .greptime.v1.RowDeleteRequest deletes = 1;
  int deletes_size() const;
  private:
  int _internal_deletes_size() const;
  public:
  void clear_deletes();
  ::greptime::v1::RowDeleteRequest* mutable_deletes(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::RowDeleteRequest >*
      mutable_deletes();
  private:
  const ::greptime::v1::RowDeleteRequest& _internal_deletes(int index) const;
  ::greptime::v1::RowDeleteRequest* _internal_add_deletes();
  public:
  const ::greptime::v1::RowDeleteRequest& deletes(int index) const;
  ::greptime::v1::RowDeleteRequest* add_deletes();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::RowDeleteRequest >&
      deletes() const;

  // @@protoc_insertion_point(class_scope:greptime.v1.RowDeleteRequests)
 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::RowDeleteRequest > deletes_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_greptime_2fv1_2fdatabase_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "greptime.v1.RowDeleteRequest";
  }
  protected:
  explicit RowDeleteRequest(::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 {
    kTableNameFieldNumber = 1,
    kRowsFieldNumber = 2,
  };
  // string table_name = 1;
  void clear_table_name();
  const std::string& table_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_table_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_table_name();
  PROTOBUF_NODISCARD std::string* release_table_name();
  void set_allocated_table_name(std::string* table_name);
  private:
  const std::string& _internal_table_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_table_name(const std::string& value);
  std::string* _internal_mutable_table_name();
  public:

  // .greptime.v1.Rows rows = 2;
  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();

  // @@protoc_insertion_point(class_scope:greptime.v1.RowDeleteRequest)
 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 table_name_;
    ::greptime::v1::Rows* rows_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_greptime_2fv1_2fdatabase_2eproto;
};
// ===================================================================


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

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

// .greptime.v1.RequestHeader header = 1;
inline bool GreptimeRequest::_internal_has_header() const {
  return this != internal_default_instance() && _impl_.header_ != nullptr;
}
inline bool GreptimeRequest::has_header() const {
  return _internal_has_header();
}
inline const ::greptime::v1::RequestHeader& GreptimeRequest::_internal_header() const {
  const ::greptime::v1::RequestHeader* p = _impl_.header_;
  return p != nullptr ? *p : reinterpret_cast<const ::greptime::v1::RequestHeader&>(
      ::greptime::v1::_RequestHeader_default_instance_);
}
inline const ::greptime::v1::RequestHeader& GreptimeRequest::header() const {
  // @@protoc_insertion_point(field_get:greptime.v1.GreptimeRequest.header)
  return _internal_header();
}
inline void GreptimeRequest::unsafe_arena_set_allocated_header(
    ::greptime::v1::RequestHeader* header) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.header_);
  }
  _impl_.header_ = header;
  if (header) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.GreptimeRequest.header)
}
inline ::greptime::v1::RequestHeader* GreptimeRequest::release_header() {
  
  ::greptime::v1::RequestHeader* temp = _impl_.header_;
  _impl_.header_ = 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::RequestHeader* GreptimeRequest::unsafe_arena_release_header() {
  // @@protoc_insertion_point(field_release:greptime.v1.GreptimeRequest.header)
  
  ::greptime::v1::RequestHeader* temp = _impl_.header_;
  _impl_.header_ = nullptr;
  return temp;
}
inline ::greptime::v1::RequestHeader* GreptimeRequest::_internal_mutable_header() {
  
  if (_impl_.header_ == nullptr) {
    auto* p = CreateMaybeMessage<::greptime::v1::RequestHeader>(GetArenaForAllocation());
    _impl_.header_ = p;
  }
  return _impl_.header_;
}
inline ::greptime::v1::RequestHeader* GreptimeRequest::mutable_header() {
  ::greptime::v1::RequestHeader* _msg = _internal_mutable_header();
  // @@protoc_insertion_point(field_mutable:greptime.v1.GreptimeRequest.header)
  return _msg;
}
inline void GreptimeRequest::set_allocated_header(::greptime::v1::RequestHeader* header) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.header_);
  }
  if (header) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(header));
    if (message_arena != submessage_arena) {
      header = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, header, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.header_ = header;
  // @@protoc_insertion_point(field_set_allocated:greptime.v1.GreptimeRequest.header)
}

// .greptime.v1.InsertRequests inserts = 2;
inline bool GreptimeRequest::_internal_has_inserts() const {
  return request_case() == kInserts;
}
inline bool GreptimeRequest::has_inserts() const {
  return _internal_has_inserts();
}
inline void GreptimeRequest::set_has_inserts() {
  _impl_._oneof_case_[0] = kInserts;
}
inline void GreptimeRequest::clear_inserts() {
  if (_internal_has_inserts()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.request_.inserts_;
    }
    clear_has_request();
  }
}
inline ::greptime::v1::InsertRequests* GreptimeRequest::release_inserts() {
  // @@protoc_insertion_point(field_release:greptime.v1.GreptimeRequest.inserts)
  if (_internal_has_inserts()) {
    clear_has_request();
    ::greptime::v1::InsertRequests* temp = _impl_.request_.inserts_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.request_.inserts_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::greptime::v1::InsertRequests& GreptimeRequest::_internal_inserts() const {
  return _internal_has_inserts()
      ? *_impl_.request_.inserts_
      : reinterpret_cast< ::greptime::v1::InsertRequests&>(::greptime::v1::_InsertRequests_default_instance_);
}
inline const ::greptime::v1::InsertRequests& GreptimeRequest::inserts() const {
  // @@protoc_insertion_point(field_get:greptime.v1.GreptimeRequest.inserts)
  return _internal_inserts();
}
inline ::greptime::v1::InsertRequests* GreptimeRequest::unsafe_arena_release_inserts() {
  // @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.GreptimeRequest.inserts)
  if (_internal_has_inserts()) {
    clear_has_request();
    ::greptime::v1::InsertRequests* temp = _impl_.request_.inserts_;
    _impl_.request_.inserts_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void GreptimeRequest::unsafe_arena_set_allocated_inserts(::greptime::v1::InsertRequests* inserts) {
  clear_request();
  if (inserts) {
    set_has_inserts();
    _impl_.request_.inserts_ = inserts;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.GreptimeRequest.inserts)
}
inline ::greptime::v1::InsertRequests* GreptimeRequest::_internal_mutable_inserts() {
  if (!_internal_has_inserts()) {
    clear_request();
    set_has_inserts();
    _impl_.request_.inserts_ = CreateMaybeMessage< ::greptime::v1::InsertRequests >(GetArenaForAllocation());
  }
  return _impl_.request_.inserts_;
}
inline ::greptime::v1::InsertRequests* GreptimeRequest::mutable_inserts() {
  ::greptime::v1::InsertRequests* _msg = _internal_mutable_inserts();
  // @@protoc_insertion_point(field_mutable:greptime.v1.GreptimeRequest.inserts)
  return _msg;
}

// .greptime.v1.QueryRequest query = 3;
inline bool GreptimeRequest::_internal_has_query() const {
  return request_case() == kQuery;
}
inline bool GreptimeRequest::has_query() const {
  return _internal_has_query();
}
inline void GreptimeRequest::set_has_query() {
  _impl_._oneof_case_[0] = kQuery;
}
inline void GreptimeRequest::clear_query() {
  if (_internal_has_query()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.request_.query_;
    }
    clear_has_request();
  }
}
inline ::greptime::v1::QueryRequest* GreptimeRequest::release_query() {
  // @@protoc_insertion_point(field_release:greptime.v1.GreptimeRequest.query)
  if (_internal_has_query()) {
    clear_has_request();
    ::greptime::v1::QueryRequest* temp = _impl_.request_.query_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.request_.query_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::greptime::v1::QueryRequest& GreptimeRequest::_internal_query() const {
  return _internal_has_query()
      ? *_impl_.request_.query_
      : reinterpret_cast< ::greptime::v1::QueryRequest&>(::greptime::v1::_QueryRequest_default_instance_);
}
inline const ::greptime::v1::QueryRequest& GreptimeRequest::query() const {
  // @@protoc_insertion_point(field_get:greptime.v1.GreptimeRequest.query)
  return _internal_query();
}
inline ::greptime::v1::QueryRequest* GreptimeRequest::unsafe_arena_release_query() {
  // @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.GreptimeRequest.query)
  if (_internal_has_query()) {
    clear_has_request();
    ::greptime::v1::QueryRequest* temp = _impl_.request_.query_;
    _impl_.request_.query_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void GreptimeRequest::unsafe_arena_set_allocated_query(::greptime::v1::QueryRequest* query) {
  clear_request();
  if (query) {
    set_has_query();
    _impl_.request_.query_ = query;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.GreptimeRequest.query)
}
inline ::greptime::v1::QueryRequest* GreptimeRequest::_internal_mutable_query() {
  if (!_internal_has_query()) {
    clear_request();
    set_has_query();
    _impl_.request_.query_ = CreateMaybeMessage< ::greptime::v1::QueryRequest >(GetArenaForAllocation());
  }
  return _impl_.request_.query_;
}
inline ::greptime::v1::QueryRequest* GreptimeRequest::mutable_query() {
  ::greptime::v1::QueryRequest* _msg = _internal_mutable_query();
  // @@protoc_insertion_point(field_mutable:greptime.v1.GreptimeRequest.query)
  return _msg;
}

// .greptime.v1.DdlRequest ddl = 4;
inline bool GreptimeRequest::_internal_has_ddl() const {
  return request_case() == kDdl;
}
inline bool GreptimeRequest::has_ddl() const {
  return _internal_has_ddl();
}
inline void GreptimeRequest::set_has_ddl() {
  _impl_._oneof_case_[0] = kDdl;
}
inline ::greptime::v1::DdlRequest* GreptimeRequest::release_ddl() {
  // @@protoc_insertion_point(field_release:greptime.v1.GreptimeRequest.ddl)
  if (_internal_has_ddl()) {
    clear_has_request();
    ::greptime::v1::DdlRequest* temp = _impl_.request_.ddl_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.request_.ddl_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::greptime::v1::DdlRequest& GreptimeRequest::_internal_ddl() const {
  return _internal_has_ddl()
      ? *_impl_.request_.ddl_
      : reinterpret_cast< ::greptime::v1::DdlRequest&>(::greptime::v1::_DdlRequest_default_instance_);
}
inline const ::greptime::v1::DdlRequest& GreptimeRequest::ddl() const {
  // @@protoc_insertion_point(field_get:greptime.v1.GreptimeRequest.ddl)
  return _internal_ddl();
}
inline ::greptime::v1::DdlRequest* GreptimeRequest::unsafe_arena_release_ddl() {
  // @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.GreptimeRequest.ddl)
  if (_internal_has_ddl()) {
    clear_has_request();
    ::greptime::v1::DdlRequest* temp = _impl_.request_.ddl_;
    _impl_.request_.ddl_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void GreptimeRequest::unsafe_arena_set_allocated_ddl(::greptime::v1::DdlRequest* ddl) {
  clear_request();
  if (ddl) {
    set_has_ddl();
    _impl_.request_.ddl_ = ddl;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.GreptimeRequest.ddl)
}
inline ::greptime::v1::DdlRequest* GreptimeRequest::_internal_mutable_ddl() {
  if (!_internal_has_ddl()) {
    clear_request();
    set_has_ddl();
    _impl_.request_.ddl_ = CreateMaybeMessage< ::greptime::v1::DdlRequest >(GetArenaForAllocation());
  }
  return _impl_.request_.ddl_;
}
inline ::greptime::v1::DdlRequest* GreptimeRequest::mutable_ddl() {
  ::greptime::v1::DdlRequest* _msg = _internal_mutable_ddl();
  // @@protoc_insertion_point(field_mutable:greptime.v1.GreptimeRequest.ddl)
  return _msg;
}

// .greptime.v1.DeleteRequests deletes = 5;
inline bool GreptimeRequest::_internal_has_deletes() const {
  return request_case() == kDeletes;
}
inline bool GreptimeRequest::has_deletes() const {
  return _internal_has_deletes();
}
inline void GreptimeRequest::set_has_deletes() {
  _impl_._oneof_case_[0] = kDeletes;
}
inline void GreptimeRequest::clear_deletes() {
  if (_internal_has_deletes()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.request_.deletes_;
    }
    clear_has_request();
  }
}
inline ::greptime::v1::DeleteRequests* GreptimeRequest::release_deletes() {
  // @@protoc_insertion_point(field_release:greptime.v1.GreptimeRequest.deletes)
  if (_internal_has_deletes()) {
    clear_has_request();
    ::greptime::v1::DeleteRequests* temp = _impl_.request_.deletes_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.request_.deletes_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::greptime::v1::DeleteRequests& GreptimeRequest::_internal_deletes() const {
  return _internal_has_deletes()
      ? *_impl_.request_.deletes_
      : reinterpret_cast< ::greptime::v1::DeleteRequests&>(::greptime::v1::_DeleteRequests_default_instance_);
}
inline const ::greptime::v1::DeleteRequests& GreptimeRequest::deletes() const {
  // @@protoc_insertion_point(field_get:greptime.v1.GreptimeRequest.deletes)
  return _internal_deletes();
}
inline ::greptime::v1::DeleteRequests* GreptimeRequest::unsafe_arena_release_deletes() {
  // @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.GreptimeRequest.deletes)
  if (_internal_has_deletes()) {
    clear_has_request();
    ::greptime::v1::DeleteRequests* temp = _impl_.request_.deletes_;
    _impl_.request_.deletes_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void GreptimeRequest::unsafe_arena_set_allocated_deletes(::greptime::v1::DeleteRequests* deletes) {
  clear_request();
  if (deletes) {
    set_has_deletes();
    _impl_.request_.deletes_ = deletes;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.GreptimeRequest.deletes)
}
inline ::greptime::v1::DeleteRequests* GreptimeRequest::_internal_mutable_deletes() {
  if (!_internal_has_deletes()) {
    clear_request();
    set_has_deletes();
    _impl_.request_.deletes_ = CreateMaybeMessage< ::greptime::v1::DeleteRequests >(GetArenaForAllocation());
  }
  return _impl_.request_.deletes_;
}
inline ::greptime::v1::DeleteRequests* GreptimeRequest::mutable_deletes() {
  ::greptime::v1::DeleteRequests* _msg = _internal_mutable_deletes();
  // @@protoc_insertion_point(field_mutable:greptime.v1.GreptimeRequest.deletes)
  return _msg;
}

// .greptime.v1.RowInsertRequests row_inserts = 6;
inline bool GreptimeRequest::_internal_has_row_inserts() const {
  return request_case() == kRowInserts;
}
inline bool GreptimeRequest::has_row_inserts() const {
  return _internal_has_row_inserts();
}
inline void GreptimeRequest::set_has_row_inserts() {
  _impl_._oneof_case_[0] = kRowInserts;
}
inline void GreptimeRequest::clear_row_inserts() {
  if (_internal_has_row_inserts()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.request_.row_inserts_;
    }
    clear_has_request();
  }
}
inline ::greptime::v1::RowInsertRequests* GreptimeRequest::release_row_inserts() {
  // @@protoc_insertion_point(field_release:greptime.v1.GreptimeRequest.row_inserts)
  if (_internal_has_row_inserts()) {
    clear_has_request();
    ::greptime::v1::RowInsertRequests* temp = _impl_.request_.row_inserts_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.request_.row_inserts_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::greptime::v1::RowInsertRequests& GreptimeRequest::_internal_row_inserts() const {
  return _internal_has_row_inserts()
      ? *_impl_.request_.row_inserts_
      : reinterpret_cast< ::greptime::v1::RowInsertRequests&>(::greptime::v1::_RowInsertRequests_default_instance_);
}
inline const ::greptime::v1::RowInsertRequests& GreptimeRequest::row_inserts() const {
  // @@protoc_insertion_point(field_get:greptime.v1.GreptimeRequest.row_inserts)
  return _internal_row_inserts();
}
inline ::greptime::v1::RowInsertRequests* GreptimeRequest::unsafe_arena_release_row_inserts() {
  // @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.GreptimeRequest.row_inserts)
  if (_internal_has_row_inserts()) {
    clear_has_request();
    ::greptime::v1::RowInsertRequests* temp = _impl_.request_.row_inserts_;
    _impl_.request_.row_inserts_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void GreptimeRequest::unsafe_arena_set_allocated_row_inserts(::greptime::v1::RowInsertRequests* row_inserts) {
  clear_request();
  if (row_inserts) {
    set_has_row_inserts();
    _impl_.request_.row_inserts_ = row_inserts;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.GreptimeRequest.row_inserts)
}
inline ::greptime::v1::RowInsertRequests* GreptimeRequest::_internal_mutable_row_inserts() {
  if (!_internal_has_row_inserts()) {
    clear_request();
    set_has_row_inserts();
    _impl_.request_.row_inserts_ = CreateMaybeMessage< ::greptime::v1::RowInsertRequests >(GetArenaForAllocation());
  }
  return _impl_.request_.row_inserts_;
}
inline ::greptime::v1::RowInsertRequests* GreptimeRequest::mutable_row_inserts() {
  ::greptime::v1::RowInsertRequests* _msg = _internal_mutable_row_inserts();
  // @@protoc_insertion_point(field_mutable:greptime.v1.GreptimeRequest.row_inserts)
  return _msg;
}

// .greptime.v1.RowDeleteRequests row_deletes = 7;
inline bool GreptimeRequest::_internal_has_row_deletes() const {
  return request_case() == kRowDeletes;
}
inline bool GreptimeRequest::has_row_deletes() const {
  return _internal_has_row_deletes();
}
inline void GreptimeRequest::set_has_row_deletes() {
  _impl_._oneof_case_[0] = kRowDeletes;
}
inline void GreptimeRequest::clear_row_deletes() {
  if (_internal_has_row_deletes()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.request_.row_deletes_;
    }
    clear_has_request();
  }
}
inline ::greptime::v1::RowDeleteRequests* GreptimeRequest::release_row_deletes() {
  // @@protoc_insertion_point(field_release:greptime.v1.GreptimeRequest.row_deletes)
  if (_internal_has_row_deletes()) {
    clear_has_request();
    ::greptime::v1::RowDeleteRequests* temp = _impl_.request_.row_deletes_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.request_.row_deletes_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::greptime::v1::RowDeleteRequests& GreptimeRequest::_internal_row_deletes() const {
  return _internal_has_row_deletes()
      ? *_impl_.request_.row_deletes_
      : reinterpret_cast< ::greptime::v1::RowDeleteRequests&>(::greptime::v1::_RowDeleteRequests_default_instance_);
}
inline const ::greptime::v1::RowDeleteRequests& GreptimeRequest::row_deletes() const {
  // @@protoc_insertion_point(field_get:greptime.v1.GreptimeRequest.row_deletes)
  return _internal_row_deletes();
}
inline ::greptime::v1::RowDeleteRequests* GreptimeRequest::unsafe_arena_release_row_deletes() {
  // @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.GreptimeRequest.row_deletes)
  if (_internal_has_row_deletes()) {
    clear_has_request();
    ::greptime::v1::RowDeleteRequests* temp = _impl_.request_.row_deletes_;
    _impl_.request_.row_deletes_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void GreptimeRequest::unsafe_arena_set_allocated_row_deletes(::greptime::v1::RowDeleteRequests* row_deletes) {
  clear_request();
  if (row_deletes) {
    set_has_row_deletes();
    _impl_.request_.row_deletes_ = row_deletes;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.GreptimeRequest.row_deletes)
}
inline ::greptime::v1::RowDeleteRequests* GreptimeRequest::_internal_mutable_row_deletes() {
  if (!_internal_has_row_deletes()) {
    clear_request();
    set_has_row_deletes();
    _impl_.request_.row_deletes_ = CreateMaybeMessage< ::greptime::v1::RowDeleteRequests >(GetArenaForAllocation());
  }
  return _impl_.request_.row_deletes_;
}
inline ::greptime::v1::RowDeleteRequests* GreptimeRequest::mutable_row_deletes() {
  ::greptime::v1::RowDeleteRequests* _msg = _internal_mutable_row_deletes();
  // @@protoc_insertion_point(field_mutable:greptime.v1.GreptimeRequest.row_deletes)
  return _msg;
}

inline bool GreptimeRequest::has_request() const {
  return request_case() != REQUEST_NOT_SET;
}
inline void GreptimeRequest::clear_has_request() {
  _impl_._oneof_case_[0] = REQUEST_NOT_SET;
}
inline GreptimeRequest::RequestCase GreptimeRequest::request_case() const {
  return GreptimeRequest::RequestCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// GreptimeResponse

// .greptime.v1.ResponseHeader header = 1;
inline bool GreptimeResponse::_internal_has_header() const {
  return this != internal_default_instance() && _impl_.header_ != nullptr;
}
inline bool GreptimeResponse::has_header() const {
  return _internal_has_header();
}
inline const ::greptime::v1::ResponseHeader& GreptimeResponse::_internal_header() const {
  const ::greptime::v1::ResponseHeader* p = _impl_.header_;
  return p != nullptr ? *p : reinterpret_cast<const ::greptime::v1::ResponseHeader&>(
      ::greptime::v1::_ResponseHeader_default_instance_);
}
inline const ::greptime::v1::ResponseHeader& GreptimeResponse::header() const {
  // @@protoc_insertion_point(field_get:greptime.v1.GreptimeResponse.header)
  return _internal_header();
}
inline void GreptimeResponse::unsafe_arena_set_allocated_header(
    ::greptime::v1::ResponseHeader* header) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.header_);
  }
  _impl_.header_ = header;
  if (header) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.GreptimeResponse.header)
}
inline ::greptime::v1::ResponseHeader* GreptimeResponse::release_header() {
  
  ::greptime::v1::ResponseHeader* temp = _impl_.header_;
  _impl_.header_ = 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::ResponseHeader* GreptimeResponse::unsafe_arena_release_header() {
  // @@protoc_insertion_point(field_release:greptime.v1.GreptimeResponse.header)
  
  ::greptime::v1::ResponseHeader* temp = _impl_.header_;
  _impl_.header_ = nullptr;
  return temp;
}
inline ::greptime::v1::ResponseHeader* GreptimeResponse::_internal_mutable_header() {
  
  if (_impl_.header_ == nullptr) {
    auto* p = CreateMaybeMessage<::greptime::v1::ResponseHeader>(GetArenaForAllocation());
    _impl_.header_ = p;
  }
  return _impl_.header_;
}
inline ::greptime::v1::ResponseHeader* GreptimeResponse::mutable_header() {
  ::greptime::v1::ResponseHeader* _msg = _internal_mutable_header();
  // @@protoc_insertion_point(field_mutable:greptime.v1.GreptimeResponse.header)
  return _msg;
}
inline void GreptimeResponse::set_allocated_header(::greptime::v1::ResponseHeader* header) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.header_);
  }
  if (header) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(header));
    if (message_arena != submessage_arena) {
      header = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, header, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.header_ = header;
  // @@protoc_insertion_point(field_set_allocated:greptime.v1.GreptimeResponse.header)
}

// .greptime.v1.AffectedRows affected_rows = 2;
inline bool GreptimeResponse::_internal_has_affected_rows() const {
  return response_case() == kAffectedRows;
}
inline bool GreptimeResponse::has_affected_rows() const {
  return _internal_has_affected_rows();
}
inline void GreptimeResponse::set_has_affected_rows() {
  _impl_._oneof_case_[0] = kAffectedRows;
}
inline ::greptime::v1::AffectedRows* GreptimeResponse::release_affected_rows() {
  // @@protoc_insertion_point(field_release:greptime.v1.GreptimeResponse.affected_rows)
  if (_internal_has_affected_rows()) {
    clear_has_response();
    ::greptime::v1::AffectedRows* temp = _impl_.response_.affected_rows_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.response_.affected_rows_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::greptime::v1::AffectedRows& GreptimeResponse::_internal_affected_rows() const {
  return _internal_has_affected_rows()
      ? *_impl_.response_.affected_rows_
      : reinterpret_cast< ::greptime::v1::AffectedRows&>(::greptime::v1::_AffectedRows_default_instance_);
}
inline const ::greptime::v1::AffectedRows& GreptimeResponse::affected_rows() const {
  // @@protoc_insertion_point(field_get:greptime.v1.GreptimeResponse.affected_rows)
  return _internal_affected_rows();
}
inline ::greptime::v1::AffectedRows* GreptimeResponse::unsafe_arena_release_affected_rows() {
  // @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.GreptimeResponse.affected_rows)
  if (_internal_has_affected_rows()) {
    clear_has_response();
    ::greptime::v1::AffectedRows* temp = _impl_.response_.affected_rows_;
    _impl_.response_.affected_rows_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void GreptimeResponse::unsafe_arena_set_allocated_affected_rows(::greptime::v1::AffectedRows* affected_rows) {
  clear_response();
  if (affected_rows) {
    set_has_affected_rows();
    _impl_.response_.affected_rows_ = affected_rows;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.GreptimeResponse.affected_rows)
}
inline ::greptime::v1::AffectedRows* GreptimeResponse::_internal_mutable_affected_rows() {
  if (!_internal_has_affected_rows()) {
    clear_response();
    set_has_affected_rows();
    _impl_.response_.affected_rows_ = CreateMaybeMessage< ::greptime::v1::AffectedRows >(GetArenaForAllocation());
  }
  return _impl_.response_.affected_rows_;
}
inline ::greptime::v1::AffectedRows* GreptimeResponse::mutable_affected_rows() {
  ::greptime::v1::AffectedRows* _msg = _internal_mutable_affected_rows();
  // @@protoc_insertion_point(field_mutable:greptime.v1.GreptimeResponse.affected_rows)
  return _msg;
}

inline bool GreptimeResponse::has_response() const {
  return response_case() != RESPONSE_NOT_SET;
}
inline void GreptimeResponse::clear_has_response() {
  _impl_._oneof_case_[0] = RESPONSE_NOT_SET;
}
inline GreptimeResponse::ResponseCase GreptimeResponse::response_case() const {
  return GreptimeResponse::ResponseCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// QueryRequest

// string sql = 1;
inline bool QueryRequest::_internal_has_sql() const {
  return query_case() == kSql;
}
inline bool QueryRequest::has_sql() const {
  return _internal_has_sql();
}
inline void QueryRequest::set_has_sql() {
  _impl_._oneof_case_[0] = kSql;
}
inline void QueryRequest::clear_sql() {
  if (_internal_has_sql()) {
    _impl_.query_.sql_.Destroy();
    clear_has_query();
  }
}
inline const std::string& QueryRequest::sql() const {
  // @@protoc_insertion_point(field_get:greptime.v1.QueryRequest.sql)
  return _internal_sql();
}
template <typename ArgT0, typename... ArgT>
inline void QueryRequest::set_sql(ArgT0&& arg0, ArgT... args) {
  if (!_internal_has_sql()) {
    clear_query();
    set_has_sql();
    _impl_.query_.sql_.InitDefault();
  }
  _impl_.query_.sql_.Set( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:greptime.v1.QueryRequest.sql)
}
inline std::string* QueryRequest::mutable_sql() {
  std::string* _s = _internal_mutable_sql();
  // @@protoc_insertion_point(field_mutable:greptime.v1.QueryRequest.sql)
  return _s;
}
inline const std::string& QueryRequest::_internal_sql() const {
  if (_internal_has_sql()) {
    return _impl_.query_.sql_.Get();
  }
  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
}
inline void QueryRequest::_internal_set_sql(const std::string& value) {
  if (!_internal_has_sql()) {
    clear_query();
    set_has_sql();
    _impl_.query_.sql_.InitDefault();
  }
  _impl_.query_.sql_.Set(value, GetArenaForAllocation());
}
inline std::string* QueryRequest::_internal_mutable_sql() {
  if (!_internal_has_sql()) {
    clear_query();
    set_has_sql();
    _impl_.query_.sql_.InitDefault();
  }
  return _impl_.query_.sql_.Mutable(      GetArenaForAllocation());
}
inline std::string* QueryRequest::release_sql() {
  // @@protoc_insertion_point(field_release:greptime.v1.QueryRequest.sql)
  if (_internal_has_sql()) {
    clear_has_query();
    return _impl_.query_.sql_.Release();
  } else {
    return nullptr;
  }
}
inline void QueryRequest::set_allocated_sql(std::string* sql) {
  if (has_query()) {
    clear_query();
  }
  if (sql != nullptr) {
    set_has_sql();
    _impl_.query_.sql_.InitAllocated(sql, GetArenaForAllocation());
  }
  // @@protoc_insertion_point(field_set_allocated:greptime.v1.QueryRequest.sql)
}

// bytes logical_plan = 2;
inline bool QueryRequest::_internal_has_logical_plan() const {
  return query_case() == kLogicalPlan;
}
inline bool QueryRequest::has_logical_plan() const {
  return _internal_has_logical_plan();
}
inline void QueryRequest::set_has_logical_plan() {
  _impl_._oneof_case_[0] = kLogicalPlan;
}
inline void QueryRequest::clear_logical_plan() {
  if (_internal_has_logical_plan()) {
    _impl_.query_.logical_plan_.Destroy();
    clear_has_query();
  }
}
inline const std::string& QueryRequest::logical_plan() const {
  // @@protoc_insertion_point(field_get:greptime.v1.QueryRequest.logical_plan)
  return _internal_logical_plan();
}
template <typename ArgT0, typename... ArgT>
inline void QueryRequest::set_logical_plan(ArgT0&& arg0, ArgT... args) {
  if (!_internal_has_logical_plan()) {
    clear_query();
    set_has_logical_plan();
    _impl_.query_.logical_plan_.InitDefault();
  }
  _impl_.query_.logical_plan_.SetBytes( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:greptime.v1.QueryRequest.logical_plan)
}
inline std::string* QueryRequest::mutable_logical_plan() {
  std::string* _s = _internal_mutable_logical_plan();
  // @@protoc_insertion_point(field_mutable:greptime.v1.QueryRequest.logical_plan)
  return _s;
}
inline const std::string& QueryRequest::_internal_logical_plan() const {
  if (_internal_has_logical_plan()) {
    return _impl_.query_.logical_plan_.Get();
  }
  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
}
inline void QueryRequest::_internal_set_logical_plan(const std::string& value) {
  if (!_internal_has_logical_plan()) {
    clear_query();
    set_has_logical_plan();
    _impl_.query_.logical_plan_.InitDefault();
  }
  _impl_.query_.logical_plan_.Set(value, GetArenaForAllocation());
}
inline std::string* QueryRequest::_internal_mutable_logical_plan() {
  if (!_internal_has_logical_plan()) {
    clear_query();
    set_has_logical_plan();
    _impl_.query_.logical_plan_.InitDefault();
  }
  return _impl_.query_.logical_plan_.Mutable(      GetArenaForAllocation());
}
inline std::string* QueryRequest::release_logical_plan() {
  // @@protoc_insertion_point(field_release:greptime.v1.QueryRequest.logical_plan)
  if (_internal_has_logical_plan()) {
    clear_has_query();
    return _impl_.query_.logical_plan_.Release();
  } else {
    return nullptr;
  }
}
inline void QueryRequest::set_allocated_logical_plan(std::string* logical_plan) {
  if (has_query()) {
    clear_query();
  }
  if (logical_plan != nullptr) {
    set_has_logical_plan();
    _impl_.query_.logical_plan_.InitAllocated(logical_plan, GetArenaForAllocation());
  }
  // @@protoc_insertion_point(field_set_allocated:greptime.v1.QueryRequest.logical_plan)
}

// .greptime.v1.PromRangeQuery prom_range_query = 3;
inline bool QueryRequest::_internal_has_prom_range_query() const {
  return query_case() == kPromRangeQuery;
}
inline bool QueryRequest::has_prom_range_query() const {
  return _internal_has_prom_range_query();
}
inline void QueryRequest::set_has_prom_range_query() {
  _impl_._oneof_case_[0] = kPromRangeQuery;
}
inline ::greptime::v1::PromRangeQuery* QueryRequest::release_prom_range_query() {
  // @@protoc_insertion_point(field_release:greptime.v1.QueryRequest.prom_range_query)
  if (_internal_has_prom_range_query()) {
    clear_has_query();
    ::greptime::v1::PromRangeQuery* temp = _impl_.query_.prom_range_query_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.query_.prom_range_query_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::greptime::v1::PromRangeQuery& QueryRequest::_internal_prom_range_query() const {
  return _internal_has_prom_range_query()
      ? *_impl_.query_.prom_range_query_
      : reinterpret_cast< ::greptime::v1::PromRangeQuery&>(::greptime::v1::_PromRangeQuery_default_instance_);
}
inline const ::greptime::v1::PromRangeQuery& QueryRequest::prom_range_query() const {
  // @@protoc_insertion_point(field_get:greptime.v1.QueryRequest.prom_range_query)
  return _internal_prom_range_query();
}
inline ::greptime::v1::PromRangeQuery* QueryRequest::unsafe_arena_release_prom_range_query() {
  // @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.QueryRequest.prom_range_query)
  if (_internal_has_prom_range_query()) {
    clear_has_query();
    ::greptime::v1::PromRangeQuery* temp = _impl_.query_.prom_range_query_;
    _impl_.query_.prom_range_query_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void QueryRequest::unsafe_arena_set_allocated_prom_range_query(::greptime::v1::PromRangeQuery* prom_range_query) {
  clear_query();
  if (prom_range_query) {
    set_has_prom_range_query();
    _impl_.query_.prom_range_query_ = prom_range_query;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.QueryRequest.prom_range_query)
}
inline ::greptime::v1::PromRangeQuery* QueryRequest::_internal_mutable_prom_range_query() {
  if (!_internal_has_prom_range_query()) {
    clear_query();
    set_has_prom_range_query();
    _impl_.query_.prom_range_query_ = CreateMaybeMessage< ::greptime::v1::PromRangeQuery >(GetArenaForAllocation());
  }
  return _impl_.query_.prom_range_query_;
}
inline ::greptime::v1::PromRangeQuery* QueryRequest::mutable_prom_range_query() {
  ::greptime::v1::PromRangeQuery* _msg = _internal_mutable_prom_range_query();
  // @@protoc_insertion_point(field_mutable:greptime.v1.QueryRequest.prom_range_query)
  return _msg;
}

// .greptime.v1.InsertIntoPlan insert_into_plan = 4;
inline bool QueryRequest::_internal_has_insert_into_plan() const {
  return query_case() == kInsertIntoPlan;
}
inline bool QueryRequest::has_insert_into_plan() const {
  return _internal_has_insert_into_plan();
}
inline void QueryRequest::set_has_insert_into_plan() {
  _impl_._oneof_case_[0] = kInsertIntoPlan;
}
inline void QueryRequest::clear_insert_into_plan() {
  if (_internal_has_insert_into_plan()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.query_.insert_into_plan_;
    }
    clear_has_query();
  }
}
inline ::greptime::v1::InsertIntoPlan* QueryRequest::release_insert_into_plan() {
  // @@protoc_insertion_point(field_release:greptime.v1.QueryRequest.insert_into_plan)
  if (_internal_has_insert_into_plan()) {
    clear_has_query();
    ::greptime::v1::InsertIntoPlan* temp = _impl_.query_.insert_into_plan_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.query_.insert_into_plan_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::greptime::v1::InsertIntoPlan& QueryRequest::_internal_insert_into_plan() const {
  return _internal_has_insert_into_plan()
      ? *_impl_.query_.insert_into_plan_
      : reinterpret_cast< ::greptime::v1::InsertIntoPlan&>(::greptime::v1::_InsertIntoPlan_default_instance_);
}
inline const ::greptime::v1::InsertIntoPlan& QueryRequest::insert_into_plan() const {
  // @@protoc_insertion_point(field_get:greptime.v1.QueryRequest.insert_into_plan)
  return _internal_insert_into_plan();
}
inline ::greptime::v1::InsertIntoPlan* QueryRequest::unsafe_arena_release_insert_into_plan() {
  // @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.QueryRequest.insert_into_plan)
  if (_internal_has_insert_into_plan()) {
    clear_has_query();
    ::greptime::v1::InsertIntoPlan* temp = _impl_.query_.insert_into_plan_;
    _impl_.query_.insert_into_plan_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void QueryRequest::unsafe_arena_set_allocated_insert_into_plan(::greptime::v1::InsertIntoPlan* insert_into_plan) {
  clear_query();
  if (insert_into_plan) {
    set_has_insert_into_plan();
    _impl_.query_.insert_into_plan_ = insert_into_plan;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.QueryRequest.insert_into_plan)
}
inline ::greptime::v1::InsertIntoPlan* QueryRequest::_internal_mutable_insert_into_plan() {
  if (!_internal_has_insert_into_plan()) {
    clear_query();
    set_has_insert_into_plan();
    _impl_.query_.insert_into_plan_ = CreateMaybeMessage< ::greptime::v1::InsertIntoPlan >(GetArenaForAllocation());
  }
  return _impl_.query_.insert_into_plan_;
}
inline ::greptime::v1::InsertIntoPlan* QueryRequest::mutable_insert_into_plan() {
  ::greptime::v1::InsertIntoPlan* _msg = _internal_mutable_insert_into_plan();
  // @@protoc_insertion_point(field_mutable:greptime.v1.QueryRequest.insert_into_plan)
  return _msg;
}

inline bool QueryRequest::has_query() const {
  return query_case() != QUERY_NOT_SET;
}
inline void QueryRequest::clear_has_query() {
  _impl_._oneof_case_[0] = QUERY_NOT_SET;
}
inline QueryRequest::QueryCase QueryRequest::query_case() const {
  return QueryRequest::QueryCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// InsertIntoPlan

// .greptime.v1.TableName table_name = 1;
inline bool InsertIntoPlan::_internal_has_table_name() const {
  return this != internal_default_instance() && _impl_.table_name_ != nullptr;
}
inline bool InsertIntoPlan::has_table_name() const {
  return _internal_has_table_name();
}
inline const ::greptime::v1::TableName& InsertIntoPlan::_internal_table_name() const {
  const ::greptime::v1::TableName* p = _impl_.table_name_;
  return p != nullptr ? *p : reinterpret_cast<const ::greptime::v1::TableName&>(
      ::greptime::v1::_TableName_default_instance_);
}
inline const ::greptime::v1::TableName& InsertIntoPlan::table_name() const {
  // @@protoc_insertion_point(field_get:greptime.v1.InsertIntoPlan.table_name)
  return _internal_table_name();
}
inline void InsertIntoPlan::unsafe_arena_set_allocated_table_name(
    ::greptime::v1::TableName* table_name) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.table_name_);
  }
  _impl_.table_name_ = table_name;
  if (table_name) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.InsertIntoPlan.table_name)
}
inline ::greptime::v1::TableName* InsertIntoPlan::release_table_name() {
  
  ::greptime::v1::TableName* temp = _impl_.table_name_;
  _impl_.table_name_ = 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::TableName* InsertIntoPlan::unsafe_arena_release_table_name() {
  // @@protoc_insertion_point(field_release:greptime.v1.InsertIntoPlan.table_name)
  
  ::greptime::v1::TableName* temp = _impl_.table_name_;
  _impl_.table_name_ = nullptr;
  return temp;
}
inline ::greptime::v1::TableName* InsertIntoPlan::_internal_mutable_table_name() {
  
  if (_impl_.table_name_ == nullptr) {
    auto* p = CreateMaybeMessage<::greptime::v1::TableName>(GetArenaForAllocation());
    _impl_.table_name_ = p;
  }
  return _impl_.table_name_;
}
inline ::greptime::v1::TableName* InsertIntoPlan::mutable_table_name() {
  ::greptime::v1::TableName* _msg = _internal_mutable_table_name();
  // @@protoc_insertion_point(field_mutable:greptime.v1.InsertIntoPlan.table_name)
  return _msg;
}
inline void InsertIntoPlan::set_allocated_table_name(::greptime::v1::TableName* table_name) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.table_name_);
  }
  if (table_name) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(table_name));
    if (message_arena != submessage_arena) {
      table_name = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, table_name, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.table_name_ = table_name;
  // @@protoc_insertion_point(field_set_allocated:greptime.v1.InsertIntoPlan.table_name)
}

// bytes logical_plan = 2;
inline void InsertIntoPlan::clear_logical_plan() {
  _impl_.logical_plan_.ClearToEmpty();
}
inline const std::string& InsertIntoPlan::logical_plan() const {
  // @@protoc_insertion_point(field_get:greptime.v1.InsertIntoPlan.logical_plan)
  return _internal_logical_plan();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void InsertIntoPlan::set_logical_plan(ArgT0&& arg0, ArgT... args) {
 
 _impl_.logical_plan_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:greptime.v1.InsertIntoPlan.logical_plan)
}
inline std::string* InsertIntoPlan::mutable_logical_plan() {
  std::string* _s = _internal_mutable_logical_plan();
  // @@protoc_insertion_point(field_mutable:greptime.v1.InsertIntoPlan.logical_plan)
  return _s;
}
inline const std::string& InsertIntoPlan::_internal_logical_plan() const {
  return _impl_.logical_plan_.Get();
}
inline void InsertIntoPlan::_internal_set_logical_plan(const std::string& value) {
  
  _impl_.logical_plan_.Set(value, GetArenaForAllocation());
}
inline std::string* InsertIntoPlan::_internal_mutable_logical_plan() {
  
  return _impl_.logical_plan_.Mutable(GetArenaForAllocation());
}
inline std::string* InsertIntoPlan::release_logical_plan() {
  // @@protoc_insertion_point(field_release:greptime.v1.InsertIntoPlan.logical_plan)
  return _impl_.logical_plan_.Release();
}
inline void InsertIntoPlan::set_allocated_logical_plan(std::string* logical_plan) {
  if (logical_plan != nullptr) {
    
  } else {
    
  }
  _impl_.logical_plan_.SetAllocated(logical_plan, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.logical_plan_.IsDefault()) {
    _impl_.logical_plan_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:greptime.v1.InsertIntoPlan.logical_plan)
}

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

// InsertRequests

// repeated .greptime.v1.InsertRequest inserts = 1;
inline int InsertRequests::_internal_inserts_size() const {
  return _impl_.inserts_.size();
}
inline int InsertRequests::inserts_size() const {
  return _internal_inserts_size();
}
inline void InsertRequests::clear_inserts() {
  _impl_.inserts_.Clear();
}
inline ::greptime::v1::InsertRequest* InsertRequests::mutable_inserts(int index) {
  // @@protoc_insertion_point(field_mutable:greptime.v1.InsertRequests.inserts)
  return _impl_.inserts_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::InsertRequest >*
InsertRequests::mutable_inserts() {
  // @@protoc_insertion_point(field_mutable_list:greptime.v1.InsertRequests.inserts)
  return &_impl_.inserts_;
}
inline const ::greptime::v1::InsertRequest& InsertRequests::_internal_inserts(int index) const {
  return _impl_.inserts_.Get(index);
}
inline const ::greptime::v1::InsertRequest& InsertRequests::inserts(int index) const {
  // @@protoc_insertion_point(field_get:greptime.v1.InsertRequests.inserts)
  return _internal_inserts(index);
}
inline ::greptime::v1::InsertRequest* InsertRequests::_internal_add_inserts() {
  return _impl_.inserts_.Add();
}
inline ::greptime::v1::InsertRequest* InsertRequests::add_inserts() {
  ::greptime::v1::InsertRequest* _add = _internal_add_inserts();
  // @@protoc_insertion_point(field_add:greptime.v1.InsertRequests.inserts)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::InsertRequest >&
InsertRequests::inserts() const {
  // @@protoc_insertion_point(field_list:greptime.v1.InsertRequests.inserts)
  return _impl_.inserts_;
}

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

// InsertRequest

// string table_name = 1;
inline void InsertRequest::clear_table_name() {
  _impl_.table_name_.ClearToEmpty();
}
inline const std::string& InsertRequest::table_name() const {
  // @@protoc_insertion_point(field_get:greptime.v1.InsertRequest.table_name)
  return _internal_table_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void InsertRequest::set_table_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.table_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:greptime.v1.InsertRequest.table_name)
}
inline std::string* InsertRequest::mutable_table_name() {
  std::string* _s = _internal_mutable_table_name();
  // @@protoc_insertion_point(field_mutable:greptime.v1.InsertRequest.table_name)
  return _s;
}
inline const std::string& InsertRequest::_internal_table_name() const {
  return _impl_.table_name_.Get();
}
inline void InsertRequest::_internal_set_table_name(const std::string& value) {
  
  _impl_.table_name_.Set(value, GetArenaForAllocation());
}
inline std::string* InsertRequest::_internal_mutable_table_name() {
  
  return _impl_.table_name_.Mutable(GetArenaForAllocation());
}
inline std::string* InsertRequest::release_table_name() {
  // @@protoc_insertion_point(field_release:greptime.v1.InsertRequest.table_name)
  return _impl_.table_name_.Release();
}
inline void InsertRequest::set_allocated_table_name(std::string* table_name) {
  if (table_name != nullptr) {
    
  } else {
    
  }
  _impl_.table_name_.SetAllocated(table_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.table_name_.IsDefault()) {
    _impl_.table_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:greptime.v1.InsertRequest.table_name)
}

// repeated .greptime.v1.Column columns = 3;
inline int InsertRequest::_internal_columns_size() const {
  return _impl_.columns_.size();
}
inline int InsertRequest::columns_size() const {
  return _internal_columns_size();
}
inline ::greptime::v1::Column* InsertRequest::mutable_columns(int index) {
  // @@protoc_insertion_point(field_mutable:greptime.v1.InsertRequest.columns)
  return _impl_.columns_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Column >*
InsertRequest::mutable_columns() {
  // @@protoc_insertion_point(field_mutable_list:greptime.v1.InsertRequest.columns)
  return &_impl_.columns_;
}
inline const ::greptime::v1::Column& InsertRequest::_internal_columns(int index) const {
  return _impl_.columns_.Get(index);
}
inline const ::greptime::v1::Column& InsertRequest::columns(int index) const {
  // @@protoc_insertion_point(field_get:greptime.v1.InsertRequest.columns)
  return _internal_columns(index);
}
inline ::greptime::v1::Column* InsertRequest::_internal_add_columns() {
  return _impl_.columns_.Add();
}
inline ::greptime::v1::Column* InsertRequest::add_columns() {
  ::greptime::v1::Column* _add = _internal_add_columns();
  // @@protoc_insertion_point(field_add:greptime.v1.InsertRequest.columns)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Column >&
InsertRequest::columns() const {
  // @@protoc_insertion_point(field_list:greptime.v1.InsertRequest.columns)
  return _impl_.columns_;
}

// uint32 row_count = 4;
inline void InsertRequest::clear_row_count() {
  _impl_.row_count_ = 0u;
}
inline uint32_t InsertRequest::_internal_row_count() const {
  return _impl_.row_count_;
}
inline uint32_t InsertRequest::row_count() const {
  // @@protoc_insertion_point(field_get:greptime.v1.InsertRequest.row_count)
  return _internal_row_count();
}
inline void InsertRequest::_internal_set_row_count(uint32_t value) {
  
  _impl_.row_count_ = value;
}
inline void InsertRequest::set_row_count(uint32_t value) {
  _internal_set_row_count(value);
  // @@protoc_insertion_point(field_set:greptime.v1.InsertRequest.row_count)
}

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

// DeleteRequests

// repeated .greptime.v1.DeleteRequest deletes = 1;
inline int DeleteRequests::_internal_deletes_size() const {
  return _impl_.deletes_.size();
}
inline int DeleteRequests::deletes_size() const {
  return _internal_deletes_size();
}
inline void DeleteRequests::clear_deletes() {
  _impl_.deletes_.Clear();
}
inline ::greptime::v1::DeleteRequest* DeleteRequests::mutable_deletes(int index) {
  // @@protoc_insertion_point(field_mutable:greptime.v1.DeleteRequests.deletes)
  return _impl_.deletes_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::DeleteRequest >*
DeleteRequests::mutable_deletes() {
  // @@protoc_insertion_point(field_mutable_list:greptime.v1.DeleteRequests.deletes)
  return &_impl_.deletes_;
}
inline const ::greptime::v1::DeleteRequest& DeleteRequests::_internal_deletes(int index) const {
  return _impl_.deletes_.Get(index);
}
inline const ::greptime::v1::DeleteRequest& DeleteRequests::deletes(int index) const {
  // @@protoc_insertion_point(field_get:greptime.v1.DeleteRequests.deletes)
  return _internal_deletes(index);
}
inline ::greptime::v1::DeleteRequest* DeleteRequests::_internal_add_deletes() {
  return _impl_.deletes_.Add();
}
inline ::greptime::v1::DeleteRequest* DeleteRequests::add_deletes() {
  ::greptime::v1::DeleteRequest* _add = _internal_add_deletes();
  // @@protoc_insertion_point(field_add:greptime.v1.DeleteRequests.deletes)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::DeleteRequest >&
DeleteRequests::deletes() const {
  // @@protoc_insertion_point(field_list:greptime.v1.DeleteRequests.deletes)
  return _impl_.deletes_;
}

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

// DeleteRequest

// string table_name = 1;
inline void DeleteRequest::clear_table_name() {
  _impl_.table_name_.ClearToEmpty();
}
inline const std::string& DeleteRequest::table_name() const {
  // @@protoc_insertion_point(field_get:greptime.v1.DeleteRequest.table_name)
  return _internal_table_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DeleteRequest::set_table_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.table_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:greptime.v1.DeleteRequest.table_name)
}
inline std::string* DeleteRequest::mutable_table_name() {
  std::string* _s = _internal_mutable_table_name();
  // @@protoc_insertion_point(field_mutable:greptime.v1.DeleteRequest.table_name)
  return _s;
}
inline const std::string& DeleteRequest::_internal_table_name() const {
  return _impl_.table_name_.Get();
}
inline void DeleteRequest::_internal_set_table_name(const std::string& value) {
  
  _impl_.table_name_.Set(value, GetArenaForAllocation());
}
inline std::string* DeleteRequest::_internal_mutable_table_name() {
  
  return _impl_.table_name_.Mutable(GetArenaForAllocation());
}
inline std::string* DeleteRequest::release_table_name() {
  // @@protoc_insertion_point(field_release:greptime.v1.DeleteRequest.table_name)
  return _impl_.table_name_.Release();
}
inline void DeleteRequest::set_allocated_table_name(std::string* table_name) {
  if (table_name != nullptr) {
    
  } else {
    
  }
  _impl_.table_name_.SetAllocated(table_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.table_name_.IsDefault()) {
    _impl_.table_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:greptime.v1.DeleteRequest.table_name)
}

// repeated .greptime.v1.Column key_columns = 3;
inline int DeleteRequest::_internal_key_columns_size() const {
  return _impl_.key_columns_.size();
}
inline int DeleteRequest::key_columns_size() const {
  return _internal_key_columns_size();
}
inline ::greptime::v1::Column* DeleteRequest::mutable_key_columns(int index) {
  // @@protoc_insertion_point(field_mutable:greptime.v1.DeleteRequest.key_columns)
  return _impl_.key_columns_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Column >*
DeleteRequest::mutable_key_columns() {
  // @@protoc_insertion_point(field_mutable_list:greptime.v1.DeleteRequest.key_columns)
  return &_impl_.key_columns_;
}
inline const ::greptime::v1::Column& DeleteRequest::_internal_key_columns(int index) const {
  return _impl_.key_columns_.Get(index);
}
inline const ::greptime::v1::Column& DeleteRequest::key_columns(int index) const {
  // @@protoc_insertion_point(field_get:greptime.v1.DeleteRequest.key_columns)
  return _internal_key_columns(index);
}
inline ::greptime::v1::Column* DeleteRequest::_internal_add_key_columns() {
  return _impl_.key_columns_.Add();
}
inline ::greptime::v1::Column* DeleteRequest::add_key_columns() {
  ::greptime::v1::Column* _add = _internal_add_key_columns();
  // @@protoc_insertion_point(field_add:greptime.v1.DeleteRequest.key_columns)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Column >&
DeleteRequest::key_columns() const {
  // @@protoc_insertion_point(field_list:greptime.v1.DeleteRequest.key_columns)
  return _impl_.key_columns_;
}

// uint32 row_count = 4;
inline void DeleteRequest::clear_row_count() {
  _impl_.row_count_ = 0u;
}
inline uint32_t DeleteRequest::_internal_row_count() const {
  return _impl_.row_count_;
}
inline uint32_t DeleteRequest::row_count() const {
  // @@protoc_insertion_point(field_get:greptime.v1.DeleteRequest.row_count)
  return _internal_row_count();
}
inline void DeleteRequest::_internal_set_row_count(uint32_t value) {
  
  _impl_.row_count_ = value;
}
inline void DeleteRequest::set_row_count(uint32_t value) {
  _internal_set_row_count(value);
  // @@protoc_insertion_point(field_set:greptime.v1.DeleteRequest.row_count)
}

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

// RowInsertRequests

// repeated .greptime.v1.RowInsertRequest inserts = 1;
inline int RowInsertRequests::_internal_inserts_size() const {
  return _impl_.inserts_.size();
}
inline int RowInsertRequests::inserts_size() const {
  return _internal_inserts_size();
}
inline void RowInsertRequests::clear_inserts() {
  _impl_.inserts_.Clear();
}
inline ::greptime::v1::RowInsertRequest* RowInsertRequests::mutable_inserts(int index) {
  // @@protoc_insertion_point(field_mutable:greptime.v1.RowInsertRequests.inserts)
  return _impl_.inserts_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::RowInsertRequest >*
RowInsertRequests::mutable_inserts() {
  // @@protoc_insertion_point(field_mutable_list:greptime.v1.RowInsertRequests.inserts)
  return &_impl_.inserts_;
}
inline const ::greptime::v1::RowInsertRequest& RowInsertRequests::_internal_inserts(int index) const {
  return _impl_.inserts_.Get(index);
}
inline const ::greptime::v1::RowInsertRequest& RowInsertRequests::inserts(int index) const {
  // @@protoc_insertion_point(field_get:greptime.v1.RowInsertRequests.inserts)
  return _internal_inserts(index);
}
inline ::greptime::v1::RowInsertRequest* RowInsertRequests::_internal_add_inserts() {
  return _impl_.inserts_.Add();
}
inline ::greptime::v1::RowInsertRequest* RowInsertRequests::add_inserts() {
  ::greptime::v1::RowInsertRequest* _add = _internal_add_inserts();
  // @@protoc_insertion_point(field_add:greptime.v1.RowInsertRequests.inserts)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::RowInsertRequest >&
RowInsertRequests::inserts() const {
  // @@protoc_insertion_point(field_list:greptime.v1.RowInsertRequests.inserts)
  return _impl_.inserts_;
}

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

// RowInsertRequest

// string table_name = 1;
inline void RowInsertRequest::clear_table_name() {
  _impl_.table_name_.ClearToEmpty();
}
inline const std::string& RowInsertRequest::table_name() const {
  // @@protoc_insertion_point(field_get:greptime.v1.RowInsertRequest.table_name)
  return _internal_table_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RowInsertRequest::set_table_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.table_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:greptime.v1.RowInsertRequest.table_name)
}
inline std::string* RowInsertRequest::mutable_table_name() {
  std::string* _s = _internal_mutable_table_name();
  // @@protoc_insertion_point(field_mutable:greptime.v1.RowInsertRequest.table_name)
  return _s;
}
inline const std::string& RowInsertRequest::_internal_table_name() const {
  return _impl_.table_name_.Get();
}
inline void RowInsertRequest::_internal_set_table_name(const std::string& value) {
  
  _impl_.table_name_.Set(value, GetArenaForAllocation());
}
inline std::string* RowInsertRequest::_internal_mutable_table_name() {
  
  return _impl_.table_name_.Mutable(GetArenaForAllocation());
}
inline std::string* RowInsertRequest::release_table_name() {
  // @@protoc_insertion_point(field_release:greptime.v1.RowInsertRequest.table_name)
  return _impl_.table_name_.Release();
}
inline void RowInsertRequest::set_allocated_table_name(std::string* table_name) {
  if (table_name != nullptr) {
    
  } else {
    
  }
  _impl_.table_name_.SetAllocated(table_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.table_name_.IsDefault()) {
    _impl_.table_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:greptime.v1.RowInsertRequest.table_name)
}

// .greptime.v1.Rows rows = 2;
inline bool RowInsertRequest::_internal_has_rows() const {
  return this != internal_default_instance() && _impl_.rows_ != nullptr;
}
inline bool RowInsertRequest::has_rows() const {
  return _internal_has_rows();
}
inline const ::greptime::v1::Rows& RowInsertRequest::_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& RowInsertRequest::rows() const {
  // @@protoc_insertion_point(field_get:greptime.v1.RowInsertRequest.rows)
  return _internal_rows();
}
inline void RowInsertRequest::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.RowInsertRequest.rows)
}
inline ::greptime::v1::Rows* RowInsertRequest::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* RowInsertRequest::unsafe_arena_release_rows() {
  // @@protoc_insertion_point(field_release:greptime.v1.RowInsertRequest.rows)
  
  ::greptime::v1::Rows* temp = _impl_.rows_;
  _impl_.rows_ = nullptr;
  return temp;
}
inline ::greptime::v1::Rows* RowInsertRequest::_internal_mutable_rows() {
  
  if (_impl_.rows_ == nullptr) {
    auto* p = CreateMaybeMessage<::greptime::v1::Rows>(GetArenaForAllocation());
    _impl_.rows_ = p;
  }
  return _impl_.rows_;
}
inline ::greptime::v1::Rows* RowInsertRequest::mutable_rows() {
  ::greptime::v1::Rows* _msg = _internal_mutable_rows();
  // @@protoc_insertion_point(field_mutable:greptime.v1.RowInsertRequest.rows)
  return _msg;
}
inline void RowInsertRequest::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.RowInsertRequest.rows)
}

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

// RowDeleteRequests

// repeated .greptime.v1.RowDeleteRequest deletes = 1;
inline int RowDeleteRequests::_internal_deletes_size() const {
  return _impl_.deletes_.size();
}
inline int RowDeleteRequests::deletes_size() const {
  return _internal_deletes_size();
}
inline void RowDeleteRequests::clear_deletes() {
  _impl_.deletes_.Clear();
}
inline ::greptime::v1::RowDeleteRequest* RowDeleteRequests::mutable_deletes(int index) {
  // @@protoc_insertion_point(field_mutable:greptime.v1.RowDeleteRequests.deletes)
  return _impl_.deletes_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::RowDeleteRequest >*
RowDeleteRequests::mutable_deletes() {
  // @@protoc_insertion_point(field_mutable_list:greptime.v1.RowDeleteRequests.deletes)
  return &_impl_.deletes_;
}
inline const ::greptime::v1::RowDeleteRequest& RowDeleteRequests::_internal_deletes(int index) const {
  return _impl_.deletes_.Get(index);
}
inline const ::greptime::v1::RowDeleteRequest& RowDeleteRequests::deletes(int index) const {
  // @@protoc_insertion_point(field_get:greptime.v1.RowDeleteRequests.deletes)
  return _internal_deletes(index);
}
inline ::greptime::v1::RowDeleteRequest* RowDeleteRequests::_internal_add_deletes() {
  return _impl_.deletes_.Add();
}
inline ::greptime::v1::RowDeleteRequest* RowDeleteRequests::add_deletes() {
  ::greptime::v1::RowDeleteRequest* _add = _internal_add_deletes();
  // @@protoc_insertion_point(field_add:greptime.v1.RowDeleteRequests.deletes)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::RowDeleteRequest >&
RowDeleteRequests::deletes() const {
  // @@protoc_insertion_point(field_list:greptime.v1.RowDeleteRequests.deletes)
  return _impl_.deletes_;
}

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

// RowDeleteRequest

// string table_name = 1;
inline void RowDeleteRequest::clear_table_name() {
  _impl_.table_name_.ClearToEmpty();
}
inline const std::string& RowDeleteRequest::table_name() const {
  // @@protoc_insertion_point(field_get:greptime.v1.RowDeleteRequest.table_name)
  return _internal_table_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RowDeleteRequest::set_table_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.table_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:greptime.v1.RowDeleteRequest.table_name)
}
inline std::string* RowDeleteRequest::mutable_table_name() {
  std::string* _s = _internal_mutable_table_name();
  // @@protoc_insertion_point(field_mutable:greptime.v1.RowDeleteRequest.table_name)
  return _s;
}
inline const std::string& RowDeleteRequest::_internal_table_name() const {
  return _impl_.table_name_.Get();
}
inline void RowDeleteRequest::_internal_set_table_name(const std::string& value) {
  
  _impl_.table_name_.Set(value, GetArenaForAllocation());
}
inline std::string* RowDeleteRequest::_internal_mutable_table_name() {
  
  return _impl_.table_name_.Mutable(GetArenaForAllocation());
}
inline std::string* RowDeleteRequest::release_table_name() {
  // @@protoc_insertion_point(field_release:greptime.v1.RowDeleteRequest.table_name)
  return _impl_.table_name_.Release();
}
inline void RowDeleteRequest::set_allocated_table_name(std::string* table_name) {
  if (table_name != nullptr) {
    
  } else {
    
  }
  _impl_.table_name_.SetAllocated(table_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.table_name_.IsDefault()) {
    _impl_.table_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:greptime.v1.RowDeleteRequest.table_name)
}

// .greptime.v1.Rows rows = 2;
inline bool RowDeleteRequest::_internal_has_rows() const {
  return this != internal_default_instance() && _impl_.rows_ != nullptr;
}
inline bool RowDeleteRequest::has_rows() const {
  return _internal_has_rows();
}
inline const ::greptime::v1::Rows& RowDeleteRequest::_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& RowDeleteRequest::rows() const {
  // @@protoc_insertion_point(field_get:greptime.v1.RowDeleteRequest.rows)
  return _internal_rows();
}
inline void RowDeleteRequest::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.RowDeleteRequest.rows)
}
inline ::greptime::v1::Rows* RowDeleteRequest::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* RowDeleteRequest::unsafe_arena_release_rows() {
  // @@protoc_insertion_point(field_release:greptime.v1.RowDeleteRequest.rows)
  
  ::greptime::v1::Rows* temp = _impl_.rows_;
  _impl_.rows_ = nullptr;
  return temp;
}
inline ::greptime::v1::Rows* RowDeleteRequest::_internal_mutable_rows() {
  
  if (_impl_.rows_ == nullptr) {
    auto* p = CreateMaybeMessage<::greptime::v1::Rows>(GetArenaForAllocation());
    _impl_.rows_ = p;
  }
  return _impl_.rows_;
}
inline ::greptime::v1::Rows* RowDeleteRequest::mutable_rows() {
  ::greptime::v1::Rows* _msg = _internal_mutable_rows();
  // @@protoc_insertion_point(field_mutable:greptime.v1.RowDeleteRequest.rows)
  return _msg;
}
inline void RowDeleteRequest::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.RowDeleteRequest.rows)
}

#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_2fdatabase_2eproto
