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

#ifndef GOOGLE_PROTOBUF_INCLUDED_greptime_2fv1_2fmeta_2fddl_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_greptime_2fv1_2fmeta_2fddl_2eproto

#include <limits>
#include <string>

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

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include "greptime/v1/meta/common.pb.h"
#include "greptime/v1/meta/route.pb.h"
#include "greptime/v1/ddl.pb.h"
#include "greptime/v1/common.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_greptime_2fv1_2fmeta_2fddl_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_2fmeta_2fddl_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_greptime_2fv1_2fmeta_2fddl_2eproto;
namespace greptime {
namespace v1 {
namespace meta {
class AlterDatabaseTask;
struct AlterDatabaseTaskDefaultTypeInternal;
extern AlterDatabaseTaskDefaultTypeInternal _AlterDatabaseTask_default_instance_;
class AlterTableTask;
struct AlterTableTaskDefaultTypeInternal;
extern AlterTableTaskDefaultTypeInternal _AlterTableTask_default_instance_;
class AlterTableTasks;
struct AlterTableTasksDefaultTypeInternal;
extern AlterTableTasksDefaultTypeInternal _AlterTableTasks_default_instance_;
class CreateDatabaseTask;
struct CreateDatabaseTaskDefaultTypeInternal;
extern CreateDatabaseTaskDefaultTypeInternal _CreateDatabaseTask_default_instance_;
class CreateFlowTask;
struct CreateFlowTaskDefaultTypeInternal;
extern CreateFlowTaskDefaultTypeInternal _CreateFlowTask_default_instance_;
class CreateTableTask;
struct CreateTableTaskDefaultTypeInternal;
extern CreateTableTaskDefaultTypeInternal _CreateTableTask_default_instance_;
class CreateTableTasks;
struct CreateTableTasksDefaultTypeInternal;
extern CreateTableTasksDefaultTypeInternal _CreateTableTasks_default_instance_;
class CreateViewTask;
struct CreateViewTaskDefaultTypeInternal;
extern CreateViewTaskDefaultTypeInternal _CreateViewTask_default_instance_;
class DdlTaskRequest;
struct DdlTaskRequestDefaultTypeInternal;
extern DdlTaskRequestDefaultTypeInternal _DdlTaskRequest_default_instance_;
class DdlTaskResponse;
struct DdlTaskResponseDefaultTypeInternal;
extern DdlTaskResponseDefaultTypeInternal _DdlTaskResponse_default_instance_;
class DropDatabaseTask;
struct DropDatabaseTaskDefaultTypeInternal;
extern DropDatabaseTaskDefaultTypeInternal _DropDatabaseTask_default_instance_;
class DropFlowTask;
struct DropFlowTaskDefaultTypeInternal;
extern DropFlowTaskDefaultTypeInternal _DropFlowTask_default_instance_;
class DropTableTask;
struct DropTableTaskDefaultTypeInternal;
extern DropTableTaskDefaultTypeInternal _DropTableTask_default_instance_;
class DropTableTasks;
struct DropTableTasksDefaultTypeInternal;
extern DropTableTasksDefaultTypeInternal _DropTableTasks_default_instance_;
class DropViewTask;
struct DropViewTaskDefaultTypeInternal;
extern DropViewTaskDefaultTypeInternal _DropViewTask_default_instance_;
class TruncateTableTask;
struct TruncateTableTaskDefaultTypeInternal;
extern TruncateTableTaskDefaultTypeInternal _TruncateTableTask_default_instance_;
}  // namespace meta
}  // namespace v1
}  // namespace greptime
PROTOBUF_NAMESPACE_OPEN
template<> ::greptime::v1::meta::AlterDatabaseTask* Arena::CreateMaybeMessage<::greptime::v1::meta::AlterDatabaseTask>(Arena*);
template<> ::greptime::v1::meta::AlterTableTask* Arena::CreateMaybeMessage<::greptime::v1::meta::AlterTableTask>(Arena*);
template<> ::greptime::v1::meta::AlterTableTasks* Arena::CreateMaybeMessage<::greptime::v1::meta::AlterTableTasks>(Arena*);
template<> ::greptime::v1::meta::CreateDatabaseTask* Arena::CreateMaybeMessage<::greptime::v1::meta::CreateDatabaseTask>(Arena*);
template<> ::greptime::v1::meta::CreateFlowTask* Arena::CreateMaybeMessage<::greptime::v1::meta::CreateFlowTask>(Arena*);
template<> ::greptime::v1::meta::CreateTableTask* Arena::CreateMaybeMessage<::greptime::v1::meta::CreateTableTask>(Arena*);
template<> ::greptime::v1::meta::CreateTableTasks* Arena::CreateMaybeMessage<::greptime::v1::meta::CreateTableTasks>(Arena*);
template<> ::greptime::v1::meta::CreateViewTask* Arena::CreateMaybeMessage<::greptime::v1::meta::CreateViewTask>(Arena*);
template<> ::greptime::v1::meta::DdlTaskRequest* Arena::CreateMaybeMessage<::greptime::v1::meta::DdlTaskRequest>(Arena*);
template<> ::greptime::v1::meta::DdlTaskResponse* Arena::CreateMaybeMessage<::greptime::v1::meta::DdlTaskResponse>(Arena*);
template<> ::greptime::v1::meta::DropDatabaseTask* Arena::CreateMaybeMessage<::greptime::v1::meta::DropDatabaseTask>(Arena*);
template<> ::greptime::v1::meta::DropFlowTask* Arena::CreateMaybeMessage<::greptime::v1::meta::DropFlowTask>(Arena*);
template<> ::greptime::v1::meta::DropTableTask* Arena::CreateMaybeMessage<::greptime::v1::meta::DropTableTask>(Arena*);
template<> ::greptime::v1::meta::DropTableTasks* Arena::CreateMaybeMessage<::greptime::v1::meta::DropTableTasks>(Arena*);
template<> ::greptime::v1::meta::DropViewTask* Arena::CreateMaybeMessage<::greptime::v1::meta::DropViewTask>(Arena*);
template<> ::greptime::v1::meta::TruncateTableTask* Arena::CreateMaybeMessage<::greptime::v1::meta::TruncateTableTask>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace greptime {
namespace v1 {
namespace meta {

enum DdlTaskType : int {
  Create = 0,
  Drop = 1,
  DdlTaskType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  DdlTaskType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool DdlTaskType_IsValid(int value);
constexpr DdlTaskType DdlTaskType_MIN = Create;
constexpr DdlTaskType DdlTaskType_MAX = Drop;
constexpr int DdlTaskType_ARRAYSIZE = DdlTaskType_MAX + 1;

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

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "greptime.v1.meta.CreateDatabaseTask";
  }
  protected:
  explicit CreateDatabaseTask(::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 {
    kCreateDatabaseFieldNumber = 1,
  };
  // .greptime.v1.CreateDatabaseExpr create_database = 1;
  bool has_create_database() const;
  private:
  bool _internal_has_create_database() const;
  public:
  void clear_create_database();
  const ::greptime::v1::CreateDatabaseExpr& create_database() const;
  PROTOBUF_NODISCARD ::greptime::v1::CreateDatabaseExpr* release_create_database();
  ::greptime::v1::CreateDatabaseExpr* mutable_create_database();
  void set_allocated_create_database(::greptime::v1::CreateDatabaseExpr* create_database);
  private:
  const ::greptime::v1::CreateDatabaseExpr& _internal_create_database() const;
  ::greptime::v1::CreateDatabaseExpr* _internal_mutable_create_database();
  public:
  void unsafe_arena_set_allocated_create_database(
      ::greptime::v1::CreateDatabaseExpr* create_database);
  ::greptime::v1::CreateDatabaseExpr* unsafe_arena_release_create_database();

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::greptime::v1::CreateDatabaseExpr* create_database_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_greptime_2fv1_2fmeta_2fddl_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "greptime.v1.meta.CreateTableTask";
  }
  protected:
  explicit CreateTableTask(::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 {
    kPartitionsFieldNumber = 2,
    kTableInfoFieldNumber = 3,
    kCreateTableFieldNumber = 1,
  };
  // repeated .greptime.v1.meta.Partition partitions = 2;
  int partitions_size() const;
  private:
  int _internal_partitions_size() const;
  public:
  void clear_partitions();
  ::greptime::v1::meta::Partition* mutable_partitions(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::meta::Partition >*
      mutable_partitions();
  private:
  const ::greptime::v1::meta::Partition& _internal_partitions(int index) const;
  ::greptime::v1::meta::Partition* _internal_add_partitions();
  public:
  const ::greptime::v1::meta::Partition& partitions(int index) const;
  ::greptime::v1::meta::Partition* add_partitions();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::meta::Partition >&
      partitions() const;

  // bytes table_info = 3;
  void clear_table_info();
  const std::string& table_info() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_table_info(ArgT0&& arg0, ArgT... args);
  std::string* mutable_table_info();
  PROTOBUF_NODISCARD std::string* release_table_info();
  void set_allocated_table_info(std::string* table_info);
  private:
  const std::string& _internal_table_info() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_table_info(const std::string& value);
  std::string* _internal_mutable_table_info();
  public:

  // .greptime.v1.CreateTableExpr create_table = 1;
  bool has_create_table() const;
  private:
  bool _internal_has_create_table() const;
  public:
  void clear_create_table();
  const ::greptime::v1::CreateTableExpr& create_table() const;
  PROTOBUF_NODISCARD ::greptime::v1::CreateTableExpr* release_create_table();
  ::greptime::v1::CreateTableExpr* mutable_create_table();
  void set_allocated_create_table(::greptime::v1::CreateTableExpr* create_table);
  private:
  const ::greptime::v1::CreateTableExpr& _internal_create_table() const;
  ::greptime::v1::CreateTableExpr* _internal_mutable_create_table();
  public:
  void unsafe_arena_set_allocated_create_table(
      ::greptime::v1::CreateTableExpr* create_table);
  ::greptime::v1::CreateTableExpr* unsafe_arena_release_create_table();

  // @@protoc_insertion_point(class_scope:greptime.v1.meta.CreateTableTask)
 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::meta::Partition > partitions_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_info_;
    ::greptime::v1::CreateTableExpr* create_table_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_greptime_2fv1_2fmeta_2fddl_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "greptime.v1.meta.CreateTableTasks";
  }
  protected:
  explicit CreateTableTasks(::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 {
    kTasksFieldNumber = 1,
  };
  // repeated .greptime.v1.meta.CreateTableTask tasks = 1;
  int tasks_size() const;
  private:
  int _internal_tasks_size() const;
  public:
  void clear_tasks();
  ::greptime::v1::meta::CreateTableTask* mutable_tasks(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::meta::CreateTableTask >*
      mutable_tasks();
  private:
  const ::greptime::v1::meta::CreateTableTask& _internal_tasks(int index) const;
  ::greptime::v1::meta::CreateTableTask* _internal_add_tasks();
  public:
  const ::greptime::v1::meta::CreateTableTask& tasks(int index) const;
  ::greptime::v1::meta::CreateTableTask* add_tasks();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::meta::CreateTableTask >&
      tasks() const;

  // @@protoc_insertion_point(class_scope:greptime.v1.meta.CreateTableTasks)
 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::meta::CreateTableTask > tasks_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_greptime_2fv1_2fmeta_2fddl_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "greptime.v1.meta.DropTableTask";
  }
  protected:
  explicit DropTableTask(::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 {
    kDropTableFieldNumber = 1,
  };
  // .greptime.v1.DropTableExpr drop_table = 1;
  bool has_drop_table() const;
  private:
  bool _internal_has_drop_table() const;
  public:
  void clear_drop_table();
  const ::greptime::v1::DropTableExpr& drop_table() const;
  PROTOBUF_NODISCARD ::greptime::v1::DropTableExpr* release_drop_table();
  ::greptime::v1::DropTableExpr* mutable_drop_table();
  void set_allocated_drop_table(::greptime::v1::DropTableExpr* drop_table);
  private:
  const ::greptime::v1::DropTableExpr& _internal_drop_table() const;
  ::greptime::v1::DropTableExpr* _internal_mutable_drop_table();
  public:
  void unsafe_arena_set_allocated_drop_table(
      ::greptime::v1::DropTableExpr* drop_table);
  ::greptime::v1::DropTableExpr* unsafe_arena_release_drop_table();

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::greptime::v1::DropTableExpr* drop_table_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_greptime_2fv1_2fmeta_2fddl_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "greptime.v1.meta.DropTableTasks";
  }
  protected:
  explicit DropTableTasks(::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 {
    kTasksFieldNumber = 1,
  };
  // repeated .greptime.v1.meta.DropTableTask tasks = 1;
  int tasks_size() const;
  private:
  int _internal_tasks_size() const;
  public:
  void clear_tasks();
  ::greptime::v1::meta::DropTableTask* mutable_tasks(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::meta::DropTableTask >*
      mutable_tasks();
  private:
  const ::greptime::v1::meta::DropTableTask& _internal_tasks(int index) const;
  ::greptime::v1::meta::DropTableTask* _internal_add_tasks();
  public:
  const ::greptime::v1::meta::DropTableTask& tasks(int index) const;
  ::greptime::v1::meta::DropTableTask* add_tasks();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::meta::DropTableTask >&
      tasks() const;

  // @@protoc_insertion_point(class_scope:greptime.v1.meta.DropTableTasks)
 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::meta::DropTableTask > tasks_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_greptime_2fv1_2fmeta_2fddl_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "greptime.v1.meta.AlterTableTask";
  }
  protected:
  explicit AlterTableTask(::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 {
    kAlterTableFieldNumber = 1,
  };
  // .greptime.v1.AlterTableExpr alter_table = 1;
  bool has_alter_table() const;
  private:
  bool _internal_has_alter_table() const;
  public:
  void clear_alter_table();
  const ::greptime::v1::AlterTableExpr& alter_table() const;
  PROTOBUF_NODISCARD ::greptime::v1::AlterTableExpr* release_alter_table();
  ::greptime::v1::AlterTableExpr* mutable_alter_table();
  void set_allocated_alter_table(::greptime::v1::AlterTableExpr* alter_table);
  private:
  const ::greptime::v1::AlterTableExpr& _internal_alter_table() const;
  ::greptime::v1::AlterTableExpr* _internal_mutable_alter_table();
  public:
  void unsafe_arena_set_allocated_alter_table(
      ::greptime::v1::AlterTableExpr* alter_table);
  ::greptime::v1::AlterTableExpr* unsafe_arena_release_alter_table();

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::greptime::v1::AlterTableExpr* alter_table_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_greptime_2fv1_2fmeta_2fddl_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "greptime.v1.meta.AlterTableTasks";
  }
  protected:
  explicit AlterTableTasks(::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 {
    kTasksFieldNumber = 1,
  };
  // repeated .greptime.v1.meta.AlterTableTask tasks = 1;
  int tasks_size() const;
  private:
  int _internal_tasks_size() const;
  public:
  void clear_tasks();
  ::greptime::v1::meta::AlterTableTask* mutable_tasks(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::meta::AlterTableTask >*
      mutable_tasks();
  private:
  const ::greptime::v1::meta::AlterTableTask& _internal_tasks(int index) const;
  ::greptime::v1::meta::AlterTableTask* _internal_add_tasks();
  public:
  const ::greptime::v1::meta::AlterTableTask& tasks(int index) const;
  ::greptime::v1::meta::AlterTableTask* add_tasks();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::meta::AlterTableTask >&
      tasks() const;

  // @@protoc_insertion_point(class_scope:greptime.v1.meta.AlterTableTasks)
 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::meta::AlterTableTask > tasks_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_greptime_2fv1_2fmeta_2fddl_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "greptime.v1.meta.TruncateTableTask";
  }
  protected:
  explicit TruncateTableTask(::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 {
    kTruncateTableFieldNumber = 1,
  };
  // .greptime.v1.TruncateTableExpr truncate_table = 1;
  bool has_truncate_table() const;
  private:
  bool _internal_has_truncate_table() const;
  public:
  void clear_truncate_table();
  const ::greptime::v1::TruncateTableExpr& truncate_table() const;
  PROTOBUF_NODISCARD ::greptime::v1::TruncateTableExpr* release_truncate_table();
  ::greptime::v1::TruncateTableExpr* mutable_truncate_table();
  void set_allocated_truncate_table(::greptime::v1::TruncateTableExpr* truncate_table);
  private:
  const ::greptime::v1::TruncateTableExpr& _internal_truncate_table() const;
  ::greptime::v1::TruncateTableExpr* _internal_mutable_truncate_table();
  public:
  void unsafe_arena_set_allocated_truncate_table(
      ::greptime::v1::TruncateTableExpr* truncate_table);
  ::greptime::v1::TruncateTableExpr* unsafe_arena_release_truncate_table();

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::greptime::v1::TruncateTableExpr* truncate_table_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_greptime_2fv1_2fmeta_2fddl_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "greptime.v1.meta.DropDatabaseTask";
  }
  protected:
  explicit DropDatabaseTask(::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 {
    kDropDatabaseFieldNumber = 1,
  };
  // .greptime.v1.DropDatabaseExpr drop_database = 1;
  bool has_drop_database() const;
  private:
  bool _internal_has_drop_database() const;
  public:
  void clear_drop_database();
  const ::greptime::v1::DropDatabaseExpr& drop_database() const;
  PROTOBUF_NODISCARD ::greptime::v1::DropDatabaseExpr* release_drop_database();
  ::greptime::v1::DropDatabaseExpr* mutable_drop_database();
  void set_allocated_drop_database(::greptime::v1::DropDatabaseExpr* drop_database);
  private:
  const ::greptime::v1::DropDatabaseExpr& _internal_drop_database() const;
  ::greptime::v1::DropDatabaseExpr* _internal_mutable_drop_database();
  public:
  void unsafe_arena_set_allocated_drop_database(
      ::greptime::v1::DropDatabaseExpr* drop_database);
  ::greptime::v1::DropDatabaseExpr* unsafe_arena_release_drop_database();

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::greptime::v1::DropDatabaseExpr* drop_database_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_greptime_2fv1_2fmeta_2fddl_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "greptime.v1.meta.CreateFlowTask";
  }
  protected:
  explicit CreateFlowTask(::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 {
    kCreateFlowFieldNumber = 1,
  };
  // .greptime.v1.CreateFlowExpr create_flow = 1;
  bool has_create_flow() const;
  private:
  bool _internal_has_create_flow() const;
  public:
  void clear_create_flow();
  const ::greptime::v1::CreateFlowExpr& create_flow() const;
  PROTOBUF_NODISCARD ::greptime::v1::CreateFlowExpr* release_create_flow();
  ::greptime::v1::CreateFlowExpr* mutable_create_flow();
  void set_allocated_create_flow(::greptime::v1::CreateFlowExpr* create_flow);
  private:
  const ::greptime::v1::CreateFlowExpr& _internal_create_flow() const;
  ::greptime::v1::CreateFlowExpr* _internal_mutable_create_flow();
  public:
  void unsafe_arena_set_allocated_create_flow(
      ::greptime::v1::CreateFlowExpr* create_flow);
  ::greptime::v1::CreateFlowExpr* unsafe_arena_release_create_flow();

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::greptime::v1::CreateFlowExpr* create_flow_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_greptime_2fv1_2fmeta_2fddl_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "greptime.v1.meta.DropFlowTask";
  }
  protected:
  explicit DropFlowTask(::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 {
    kDropFlowFieldNumber = 1,
  };
  // .greptime.v1.DropFlowExpr drop_flow = 1;
  bool has_drop_flow() const;
  private:
  bool _internal_has_drop_flow() const;
  public:
  void clear_drop_flow();
  const ::greptime::v1::DropFlowExpr& drop_flow() const;
  PROTOBUF_NODISCARD ::greptime::v1::DropFlowExpr* release_drop_flow();
  ::greptime::v1::DropFlowExpr* mutable_drop_flow();
  void set_allocated_drop_flow(::greptime::v1::DropFlowExpr* drop_flow);
  private:
  const ::greptime::v1::DropFlowExpr& _internal_drop_flow() const;
  ::greptime::v1::DropFlowExpr* _internal_mutable_drop_flow();
  public:
  void unsafe_arena_set_allocated_drop_flow(
      ::greptime::v1::DropFlowExpr* drop_flow);
  ::greptime::v1::DropFlowExpr* unsafe_arena_release_drop_flow();

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::greptime::v1::DropFlowExpr* drop_flow_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_greptime_2fv1_2fmeta_2fddl_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "greptime.v1.meta.CreateViewTask";
  }
  protected:
  explicit CreateViewTask(::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 {
    kViewInfoFieldNumber = 2,
    kCreateViewFieldNumber = 1,
  };
  // bytes view_info = 2;
  void clear_view_info();
  const std::string& view_info() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_view_info(ArgT0&& arg0, ArgT... args);
  std::string* mutable_view_info();
  PROTOBUF_NODISCARD std::string* release_view_info();
  void set_allocated_view_info(std::string* view_info);
  private:
  const std::string& _internal_view_info() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_view_info(const std::string& value);
  std::string* _internal_mutable_view_info();
  public:

  // .greptime.v1.CreateViewExpr create_view = 1;
  bool has_create_view() const;
  private:
  bool _internal_has_create_view() const;
  public:
  void clear_create_view();
  const ::greptime::v1::CreateViewExpr& create_view() const;
  PROTOBUF_NODISCARD ::greptime::v1::CreateViewExpr* release_create_view();
  ::greptime::v1::CreateViewExpr* mutable_create_view();
  void set_allocated_create_view(::greptime::v1::CreateViewExpr* create_view);
  private:
  const ::greptime::v1::CreateViewExpr& _internal_create_view() const;
  ::greptime::v1::CreateViewExpr* _internal_mutable_create_view();
  public:
  void unsafe_arena_set_allocated_create_view(
      ::greptime::v1::CreateViewExpr* create_view);
  ::greptime::v1::CreateViewExpr* unsafe_arena_release_create_view();

  // @@protoc_insertion_point(class_scope:greptime.v1.meta.CreateViewTask)
 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 view_info_;
    ::greptime::v1::CreateViewExpr* create_view_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_greptime_2fv1_2fmeta_2fddl_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "greptime.v1.meta.DropViewTask";
  }
  protected:
  explicit DropViewTask(::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 {
    kDropViewFieldNumber = 1,
  };
  // .greptime.v1.DropViewExpr drop_view = 1;
  bool has_drop_view() const;
  private:
  bool _internal_has_drop_view() const;
  public:
  void clear_drop_view();
  const ::greptime::v1::DropViewExpr& drop_view() const;
  PROTOBUF_NODISCARD ::greptime::v1::DropViewExpr* release_drop_view();
  ::greptime::v1::DropViewExpr* mutable_drop_view();
  void set_allocated_drop_view(::greptime::v1::DropViewExpr* drop_view);
  private:
  const ::greptime::v1::DropViewExpr& _internal_drop_view() const;
  ::greptime::v1::DropViewExpr* _internal_mutable_drop_view();
  public:
  void unsafe_arena_set_allocated_drop_view(
      ::greptime::v1::DropViewExpr* drop_view);
  ::greptime::v1::DropViewExpr* unsafe_arena_release_drop_view();

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::greptime::v1::DropViewExpr* drop_view_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_greptime_2fv1_2fmeta_2fddl_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "greptime.v1.meta.AlterDatabaseTask";
  }
  protected:
  explicit AlterDatabaseTask(::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 {
    kTaskFieldNumber = 1,
  };
  // .greptime.v1.AlterDatabaseExpr task = 1;
  bool has_task() const;
  private:
  bool _internal_has_task() const;
  public:
  void clear_task();
  const ::greptime::v1::AlterDatabaseExpr& task() const;
  PROTOBUF_NODISCARD ::greptime::v1::AlterDatabaseExpr* release_task();
  ::greptime::v1::AlterDatabaseExpr* mutable_task();
  void set_allocated_task(::greptime::v1::AlterDatabaseExpr* task);
  private:
  const ::greptime::v1::AlterDatabaseExpr& _internal_task() const;
  ::greptime::v1::AlterDatabaseExpr* _internal_mutable_task();
  public:
  void unsafe_arena_set_allocated_task(
      ::greptime::v1::AlterDatabaseExpr* task);
  ::greptime::v1::AlterDatabaseExpr* unsafe_arena_release_task();

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::greptime::v1::AlterDatabaseExpr* task_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_greptime_2fv1_2fmeta_2fddl_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline DdlTaskRequest& operator=(const DdlTaskRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline DdlTaskRequest& operator=(DdlTaskRequest&& 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 DdlTaskRequest& default_instance() {
    return *internal_default_instance();
  }
  enum TaskCase {
    kCreateTableTask = 2,
    kDropTableTask = 3,
    kAlterTableTask = 4,
    kTruncateTableTask = 5,
    kCreateTableTasks = 6,
    kDropTableTasks = 7,
    kAlterTableTasks = 8,
    kDropDatabaseTask = 9,
    kCreateDatabaseTask = 10,
    kCreateFlowTask = 11,
    kDropFlowTask = 12,
    kCreateViewTask = 13,
    kDropViewTask = 14,
    kAlterDatabaseTask = 15,
    TASK_NOT_SET = 0,
  };

  static inline const DdlTaskRequest* internal_default_instance() {
    return reinterpret_cast<const DdlTaskRequest*>(
               &_DdlTaskRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "greptime.v1.meta.DdlTaskRequest";
  }
  protected:
  explicit DdlTaskRequest(::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,
    kQueryContextFieldNumber = 64,
    kCreateTableTaskFieldNumber = 2,
    kDropTableTaskFieldNumber = 3,
    kAlterTableTaskFieldNumber = 4,
    kTruncateTableTaskFieldNumber = 5,
    kCreateTableTasksFieldNumber = 6,
    kDropTableTasksFieldNumber = 7,
    kAlterTableTasksFieldNumber = 8,
    kDropDatabaseTaskFieldNumber = 9,
    kCreateDatabaseTaskFieldNumber = 10,
    kCreateFlowTaskFieldNumber = 11,
    kDropFlowTaskFieldNumber = 12,
    kCreateViewTaskFieldNumber = 13,
    kDropViewTaskFieldNumber = 14,
    kAlterDatabaseTaskFieldNumber = 15,
  };
  // .greptime.v1.meta.RequestHeader header = 1;
  bool has_header() const;
  private:
  bool _internal_has_header() const;
  public:
  void clear_header();
  const ::greptime::v1::meta::RequestHeader& header() const;
  PROTOBUF_NODISCARD ::greptime::v1::meta::RequestHeader* release_header();
  ::greptime::v1::meta::RequestHeader* mutable_header();
  void set_allocated_header(::greptime::v1::meta::RequestHeader* header);
  private:
  const ::greptime::v1::meta::RequestHeader& _internal_header() const;
  ::greptime::v1::meta::RequestHeader* _internal_mutable_header();
  public:
  void unsafe_arena_set_allocated_header(
      ::greptime::v1::meta::RequestHeader* header);
  ::greptime::v1::meta::RequestHeader* unsafe_arena_release_header();

  // .greptime.v1.QueryContext query_context = 64;
  bool has_query_context() const;
  private:
  bool _internal_has_query_context() const;
  public:
  void clear_query_context();
  const ::greptime::v1::QueryContext& query_context() const;
  PROTOBUF_NODISCARD ::greptime::v1::QueryContext* release_query_context();
  ::greptime::v1::QueryContext* mutable_query_context();
  void set_allocated_query_context(::greptime::v1::QueryContext* query_context);
  private:
  const ::greptime::v1::QueryContext& _internal_query_context() const;
  ::greptime::v1::QueryContext* _internal_mutable_query_context();
  public:
  void unsafe_arena_set_allocated_query_context(
      ::greptime::v1::QueryContext* query_context);
  ::greptime::v1::QueryContext* unsafe_arena_release_query_context();

  // .greptime.v1.meta.CreateTableTask create_table_task = 2;
  bool has_create_table_task() const;
  private:
  bool _internal_has_create_table_task() const;
  public:
  void clear_create_table_task();
  const ::greptime::v1::meta::CreateTableTask& create_table_task() const;
  PROTOBUF_NODISCARD ::greptime::v1::meta::CreateTableTask* release_create_table_task();
  ::greptime::v1::meta::CreateTableTask* mutable_create_table_task();
  void set_allocated_create_table_task(::greptime::v1::meta::CreateTableTask* create_table_task);
  private:
  const ::greptime::v1::meta::CreateTableTask& _internal_create_table_task() const;
  ::greptime::v1::meta::CreateTableTask* _internal_mutable_create_table_task();
  public:
  void unsafe_arena_set_allocated_create_table_task(
      ::greptime::v1::meta::CreateTableTask* create_table_task);
  ::greptime::v1::meta::CreateTableTask* unsafe_arena_release_create_table_task();

  // .greptime.v1.meta.DropTableTask drop_table_task = 3;
  bool has_drop_table_task() const;
  private:
  bool _internal_has_drop_table_task() const;
  public:
  void clear_drop_table_task();
  const ::greptime::v1::meta::DropTableTask& drop_table_task() const;
  PROTOBUF_NODISCARD ::greptime::v1::meta::DropTableTask* release_drop_table_task();
  ::greptime::v1::meta::DropTableTask* mutable_drop_table_task();
  void set_allocated_drop_table_task(::greptime::v1::meta::DropTableTask* drop_table_task);
  private:
  const ::greptime::v1::meta::DropTableTask& _internal_drop_table_task() const;
  ::greptime::v1::meta::DropTableTask* _internal_mutable_drop_table_task();
  public:
  void unsafe_arena_set_allocated_drop_table_task(
      ::greptime::v1::meta::DropTableTask* drop_table_task);
  ::greptime::v1::meta::DropTableTask* unsafe_arena_release_drop_table_task();

  // .greptime.v1.meta.AlterTableTask alter_table_task = 4;
  bool has_alter_table_task() const;
  private:
  bool _internal_has_alter_table_task() const;
  public:
  void clear_alter_table_task();
  const ::greptime::v1::meta::AlterTableTask& alter_table_task() const;
  PROTOBUF_NODISCARD ::greptime::v1::meta::AlterTableTask* release_alter_table_task();
  ::greptime::v1::meta::AlterTableTask* mutable_alter_table_task();
  void set_allocated_alter_table_task(::greptime::v1::meta::AlterTableTask* alter_table_task);
  private:
  const ::greptime::v1::meta::AlterTableTask& _internal_alter_table_task() const;
  ::greptime::v1::meta::AlterTableTask* _internal_mutable_alter_table_task();
  public:
  void unsafe_arena_set_allocated_alter_table_task(
      ::greptime::v1::meta::AlterTableTask* alter_table_task);
  ::greptime::v1::meta::AlterTableTask* unsafe_arena_release_alter_table_task();

  // .greptime.v1.meta.TruncateTableTask truncate_table_task = 5;
  bool has_truncate_table_task() const;
  private:
  bool _internal_has_truncate_table_task() const;
  public:
  void clear_truncate_table_task();
  const ::greptime::v1::meta::TruncateTableTask& truncate_table_task() const;
  PROTOBUF_NODISCARD ::greptime::v1::meta::TruncateTableTask* release_truncate_table_task();
  ::greptime::v1::meta::TruncateTableTask* mutable_truncate_table_task();
  void set_allocated_truncate_table_task(::greptime::v1::meta::TruncateTableTask* truncate_table_task);
  private:
  const ::greptime::v1::meta::TruncateTableTask& _internal_truncate_table_task() const;
  ::greptime::v1::meta::TruncateTableTask* _internal_mutable_truncate_table_task();
  public:
  void unsafe_arena_set_allocated_truncate_table_task(
      ::greptime::v1::meta::TruncateTableTask* truncate_table_task);
  ::greptime::v1::meta::TruncateTableTask* unsafe_arena_release_truncate_table_task();

  // .greptime.v1.meta.CreateTableTasks create_table_tasks = 6;
  bool has_create_table_tasks() const;
  private:
  bool _internal_has_create_table_tasks() const;
  public:
  void clear_create_table_tasks();
  const ::greptime::v1::meta::CreateTableTasks& create_table_tasks() const;
  PROTOBUF_NODISCARD ::greptime::v1::meta::CreateTableTasks* release_create_table_tasks();
  ::greptime::v1::meta::CreateTableTasks* mutable_create_table_tasks();
  void set_allocated_create_table_tasks(::greptime::v1::meta::CreateTableTasks* create_table_tasks);
  private:
  const ::greptime::v1::meta::CreateTableTasks& _internal_create_table_tasks() const;
  ::greptime::v1::meta::CreateTableTasks* _internal_mutable_create_table_tasks();
  public:
  void unsafe_arena_set_allocated_create_table_tasks(
      ::greptime::v1::meta::CreateTableTasks* create_table_tasks);
  ::greptime::v1::meta::CreateTableTasks* unsafe_arena_release_create_table_tasks();

  // .greptime.v1.meta.DropTableTasks drop_table_tasks = 7;
  bool has_drop_table_tasks() const;
  private:
  bool _internal_has_drop_table_tasks() const;
  public:
  void clear_drop_table_tasks();
  const ::greptime::v1::meta::DropTableTasks& drop_table_tasks() const;
  PROTOBUF_NODISCARD ::greptime::v1::meta::DropTableTasks* release_drop_table_tasks();
  ::greptime::v1::meta::DropTableTasks* mutable_drop_table_tasks();
  void set_allocated_drop_table_tasks(::greptime::v1::meta::DropTableTasks* drop_table_tasks);
  private:
  const ::greptime::v1::meta::DropTableTasks& _internal_drop_table_tasks() const;
  ::greptime::v1::meta::DropTableTasks* _internal_mutable_drop_table_tasks();
  public:
  void unsafe_arena_set_allocated_drop_table_tasks(
      ::greptime::v1::meta::DropTableTasks* drop_table_tasks);
  ::greptime::v1::meta::DropTableTasks* unsafe_arena_release_drop_table_tasks();

  // .greptime.v1.meta.AlterTableTasks alter_table_tasks = 8;
  bool has_alter_table_tasks() const;
  private:
  bool _internal_has_alter_table_tasks() const;
  public:
  void clear_alter_table_tasks();
  const ::greptime::v1::meta::AlterTableTasks& alter_table_tasks() const;
  PROTOBUF_NODISCARD ::greptime::v1::meta::AlterTableTasks* release_alter_table_tasks();
  ::greptime::v1::meta::AlterTableTasks* mutable_alter_table_tasks();
  void set_allocated_alter_table_tasks(::greptime::v1::meta::AlterTableTasks* alter_table_tasks);
  private:
  const ::greptime::v1::meta::AlterTableTasks& _internal_alter_table_tasks() const;
  ::greptime::v1::meta::AlterTableTasks* _internal_mutable_alter_table_tasks();
  public:
  void unsafe_arena_set_allocated_alter_table_tasks(
      ::greptime::v1::meta::AlterTableTasks* alter_table_tasks);
  ::greptime::v1::meta::AlterTableTasks* unsafe_arena_release_alter_table_tasks();

  // .greptime.v1.meta.DropDatabaseTask drop_database_task = 9;
  bool has_drop_database_task() const;
  private:
  bool _internal_has_drop_database_task() const;
  public:
  void clear_drop_database_task();
  const ::greptime::v1::meta::DropDatabaseTask& drop_database_task() const;
  PROTOBUF_NODISCARD ::greptime::v1::meta::DropDatabaseTask* release_drop_database_task();
  ::greptime::v1::meta::DropDatabaseTask* mutable_drop_database_task();
  void set_allocated_drop_database_task(::greptime::v1::meta::DropDatabaseTask* drop_database_task);
  private:
  const ::greptime::v1::meta::DropDatabaseTask& _internal_drop_database_task() const;
  ::greptime::v1::meta::DropDatabaseTask* _internal_mutable_drop_database_task();
  public:
  void unsafe_arena_set_allocated_drop_database_task(
      ::greptime::v1::meta::DropDatabaseTask* drop_database_task);
  ::greptime::v1::meta::DropDatabaseTask* unsafe_arena_release_drop_database_task();

  // .greptime.v1.meta.CreateDatabaseTask create_database_task = 10;
  bool has_create_database_task() const;
  private:
  bool _internal_has_create_database_task() const;
  public:
  void clear_create_database_task();
  const ::greptime::v1::meta::CreateDatabaseTask& create_database_task() const;
  PROTOBUF_NODISCARD ::greptime::v1::meta::CreateDatabaseTask* release_create_database_task();
  ::greptime::v1::meta::CreateDatabaseTask* mutable_create_database_task();
  void set_allocated_create_database_task(::greptime::v1::meta::CreateDatabaseTask* create_database_task);
  private:
  const ::greptime::v1::meta::CreateDatabaseTask& _internal_create_database_task() const;
  ::greptime::v1::meta::CreateDatabaseTask* _internal_mutable_create_database_task();
  public:
  void unsafe_arena_set_allocated_create_database_task(
      ::greptime::v1::meta::CreateDatabaseTask* create_database_task);
  ::greptime::v1::meta::CreateDatabaseTask* unsafe_arena_release_create_database_task();

  // .greptime.v1.meta.CreateFlowTask create_flow_task = 11;
  bool has_create_flow_task() const;
  private:
  bool _internal_has_create_flow_task() const;
  public:
  void clear_create_flow_task();
  const ::greptime::v1::meta::CreateFlowTask& create_flow_task() const;
  PROTOBUF_NODISCARD ::greptime::v1::meta::CreateFlowTask* release_create_flow_task();
  ::greptime::v1::meta::CreateFlowTask* mutable_create_flow_task();
  void set_allocated_create_flow_task(::greptime::v1::meta::CreateFlowTask* create_flow_task);
  private:
  const ::greptime::v1::meta::CreateFlowTask& _internal_create_flow_task() const;
  ::greptime::v1::meta::CreateFlowTask* _internal_mutable_create_flow_task();
  public:
  void unsafe_arena_set_allocated_create_flow_task(
      ::greptime::v1::meta::CreateFlowTask* create_flow_task);
  ::greptime::v1::meta::CreateFlowTask* unsafe_arena_release_create_flow_task();

  // .greptime.v1.meta.DropFlowTask drop_flow_task = 12;
  bool has_drop_flow_task() const;
  private:
  bool _internal_has_drop_flow_task() const;
  public:
  void clear_drop_flow_task();
  const ::greptime::v1::meta::DropFlowTask& drop_flow_task() const;
  PROTOBUF_NODISCARD ::greptime::v1::meta::DropFlowTask* release_drop_flow_task();
  ::greptime::v1::meta::DropFlowTask* mutable_drop_flow_task();
  void set_allocated_drop_flow_task(::greptime::v1::meta::DropFlowTask* drop_flow_task);
  private:
  const ::greptime::v1::meta::DropFlowTask& _internal_drop_flow_task() const;
  ::greptime::v1::meta::DropFlowTask* _internal_mutable_drop_flow_task();
  public:
  void unsafe_arena_set_allocated_drop_flow_task(
      ::greptime::v1::meta::DropFlowTask* drop_flow_task);
  ::greptime::v1::meta::DropFlowTask* unsafe_arena_release_drop_flow_task();

  // .greptime.v1.meta.CreateViewTask create_view_task = 13;
  bool has_create_view_task() const;
  private:
  bool _internal_has_create_view_task() const;
  public:
  void clear_create_view_task();
  const ::greptime::v1::meta::CreateViewTask& create_view_task() const;
  PROTOBUF_NODISCARD ::greptime::v1::meta::CreateViewTask* release_create_view_task();
  ::greptime::v1::meta::CreateViewTask* mutable_create_view_task();
  void set_allocated_create_view_task(::greptime::v1::meta::CreateViewTask* create_view_task);
  private:
  const ::greptime::v1::meta::CreateViewTask& _internal_create_view_task() const;
  ::greptime::v1::meta::CreateViewTask* _internal_mutable_create_view_task();
  public:
  void unsafe_arena_set_allocated_create_view_task(
      ::greptime::v1::meta::CreateViewTask* create_view_task);
  ::greptime::v1::meta::CreateViewTask* unsafe_arena_release_create_view_task();

  // .greptime.v1.meta.DropViewTask drop_view_task = 14;
  bool has_drop_view_task() const;
  private:
  bool _internal_has_drop_view_task() const;
  public:
  void clear_drop_view_task();
  const ::greptime::v1::meta::DropViewTask& drop_view_task() const;
  PROTOBUF_NODISCARD ::greptime::v1::meta::DropViewTask* release_drop_view_task();
  ::greptime::v1::meta::DropViewTask* mutable_drop_view_task();
  void set_allocated_drop_view_task(::greptime::v1::meta::DropViewTask* drop_view_task);
  private:
  const ::greptime::v1::meta::DropViewTask& _internal_drop_view_task() const;
  ::greptime::v1::meta::DropViewTask* _internal_mutable_drop_view_task();
  public:
  void unsafe_arena_set_allocated_drop_view_task(
      ::greptime::v1::meta::DropViewTask* drop_view_task);
  ::greptime::v1::meta::DropViewTask* unsafe_arena_release_drop_view_task();

  // .greptime.v1.meta.AlterDatabaseTask alter_database_task = 15;
  bool has_alter_database_task() const;
  private:
  bool _internal_has_alter_database_task() const;
  public:
  void clear_alter_database_task();
  const ::greptime::v1::meta::AlterDatabaseTask& alter_database_task() const;
  PROTOBUF_NODISCARD ::greptime::v1::meta::AlterDatabaseTask* release_alter_database_task();
  ::greptime::v1::meta::AlterDatabaseTask* mutable_alter_database_task();
  void set_allocated_alter_database_task(::greptime::v1::meta::AlterDatabaseTask* alter_database_task);
  private:
  const ::greptime::v1::meta::AlterDatabaseTask& _internal_alter_database_task() const;
  ::greptime::v1::meta::AlterDatabaseTask* _internal_mutable_alter_database_task();
  public:
  void unsafe_arena_set_allocated_alter_database_task(
      ::greptime::v1::meta::AlterDatabaseTask* alter_database_task);
  ::greptime::v1::meta::AlterDatabaseTask* unsafe_arena_release_alter_database_task();

  void clear_task();
  TaskCase task_case() const;
  // @@protoc_insertion_point(class_scope:greptime.v1.meta.DdlTaskRequest)
 private:
  class _Internal;
  void set_has_create_table_task();
  void set_has_drop_table_task();
  void set_has_alter_table_task();
  void set_has_truncate_table_task();
  void set_has_create_table_tasks();
  void set_has_drop_table_tasks();
  void set_has_alter_table_tasks();
  void set_has_drop_database_task();
  void set_has_create_database_task();
  void set_has_create_flow_task();
  void set_has_drop_flow_task();
  void set_has_create_view_task();
  void set_has_drop_view_task();
  void set_has_alter_database_task();

  inline bool has_task() const;
  inline void clear_has_task();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::greptime::v1::meta::RequestHeader* header_;
    ::greptime::v1::QueryContext* query_context_;
    union TaskUnion {
      constexpr TaskUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::greptime::v1::meta::CreateTableTask* create_table_task_;
      ::greptime::v1::meta::DropTableTask* drop_table_task_;
      ::greptime::v1::meta::AlterTableTask* alter_table_task_;
      ::greptime::v1::meta::TruncateTableTask* truncate_table_task_;
      ::greptime::v1::meta::CreateTableTasks* create_table_tasks_;
      ::greptime::v1::meta::DropTableTasks* drop_table_tasks_;
      ::greptime::v1::meta::AlterTableTasks* alter_table_tasks_;
      ::greptime::v1::meta::DropDatabaseTask* drop_database_task_;
      ::greptime::v1::meta::CreateDatabaseTask* create_database_task_;
      ::greptime::v1::meta::CreateFlowTask* create_flow_task_;
      ::greptime::v1::meta::DropFlowTask* drop_flow_task_;
      ::greptime::v1::meta::CreateViewTask* create_view_task_;
      ::greptime::v1::meta::DropViewTask* drop_view_task_;
      ::greptime::v1::meta::AlterDatabaseTask* alter_database_task_;
    } task_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t _oneof_case_[1];

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

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "greptime.v1.meta.DdlTaskResponse";
  }
  protected:
  explicit DdlTaskResponse(::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 {
    kTableIdsFieldNumber = 5,
    kHeaderFieldNumber = 1,
    kPidFieldNumber = 2,
  };
  // repeated .greptime.v1.TableId table_ids = 5;
  int table_ids_size() const;
  private:
  int _internal_table_ids_size() const;
  public:
  void clear_table_ids();
  ::greptime::v1::TableId* mutable_table_ids(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::TableId >*
      mutable_table_ids();
  private:
  const ::greptime::v1::TableId& _internal_table_ids(int index) const;
  ::greptime::v1::TableId* _internal_add_table_ids();
  public:
  const ::greptime::v1::TableId& table_ids(int index) const;
  ::greptime::v1::TableId* add_table_ids();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::TableId >&
      table_ids() const;

  // .greptime.v1.meta.ResponseHeader header = 1;
  bool has_header() const;
  private:
  bool _internal_has_header() const;
  public:
  void clear_header();
  const ::greptime::v1::meta::ResponseHeader& header() const;
  PROTOBUF_NODISCARD ::greptime::v1::meta::ResponseHeader* release_header();
  ::greptime::v1::meta::ResponseHeader* mutable_header();
  void set_allocated_header(::greptime::v1::meta::ResponseHeader* header);
  private:
  const ::greptime::v1::meta::ResponseHeader& _internal_header() const;
  ::greptime::v1::meta::ResponseHeader* _internal_mutable_header();
  public:
  void unsafe_arena_set_allocated_header(
      ::greptime::v1::meta::ResponseHeader* header);
  ::greptime::v1::meta::ResponseHeader* unsafe_arena_release_header();

  // .greptime.v1.meta.ProcedureId pid = 2;
  bool has_pid() const;
  private:
  bool _internal_has_pid() const;
  public:
  void clear_pid();
  const ::greptime::v1::meta::ProcedureId& pid() const;
  PROTOBUF_NODISCARD ::greptime::v1::meta::ProcedureId* release_pid();
  ::greptime::v1::meta::ProcedureId* mutable_pid();
  void set_allocated_pid(::greptime::v1::meta::ProcedureId* pid);
  private:
  const ::greptime::v1::meta::ProcedureId& _internal_pid() const;
  ::greptime::v1::meta::ProcedureId* _internal_mutable_pid();
  public:
  void unsafe_arena_set_allocated_pid(
      ::greptime::v1::meta::ProcedureId* pid);
  ::greptime::v1::meta::ProcedureId* unsafe_arena_release_pid();

  // @@protoc_insertion_point(class_scope:greptime.v1.meta.DdlTaskResponse)
 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::TableId > table_ids_;
    ::greptime::v1::meta::ResponseHeader* header_;
    ::greptime::v1::meta::ProcedureId* pid_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_greptime_2fv1_2fmeta_2fddl_2eproto;
};
// ===================================================================


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

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

// .greptime.v1.CreateDatabaseExpr create_database = 1;
inline bool CreateDatabaseTask::_internal_has_create_database() const {
  return this != internal_default_instance() && _impl_.create_database_ != nullptr;
}
inline bool CreateDatabaseTask::has_create_database() const {
  return _internal_has_create_database();
}
inline const ::greptime::v1::CreateDatabaseExpr& CreateDatabaseTask::_internal_create_database() const {
  const ::greptime::v1::CreateDatabaseExpr* p = _impl_.create_database_;
  return p != nullptr ? *p : reinterpret_cast<const ::greptime::v1::CreateDatabaseExpr&>(
      ::greptime::v1::_CreateDatabaseExpr_default_instance_);
}
inline const ::greptime::v1::CreateDatabaseExpr& CreateDatabaseTask::create_database() const {
  // @@protoc_insertion_point(field_get:greptime.v1.meta.CreateDatabaseTask.create_database)
  return _internal_create_database();
}
inline void CreateDatabaseTask::unsafe_arena_set_allocated_create_database(
    ::greptime::v1::CreateDatabaseExpr* create_database) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.create_database_);
  }
  _impl_.create_database_ = create_database;
  if (create_database) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.meta.CreateDatabaseTask.create_database)
}
inline ::greptime::v1::CreateDatabaseExpr* CreateDatabaseTask::release_create_database() {
  
  ::greptime::v1::CreateDatabaseExpr* temp = _impl_.create_database_;
  _impl_.create_database_ = 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::CreateDatabaseExpr* CreateDatabaseTask::unsafe_arena_release_create_database() {
  // @@protoc_insertion_point(field_release:greptime.v1.meta.CreateDatabaseTask.create_database)
  
  ::greptime::v1::CreateDatabaseExpr* temp = _impl_.create_database_;
  _impl_.create_database_ = nullptr;
  return temp;
}
inline ::greptime::v1::CreateDatabaseExpr* CreateDatabaseTask::_internal_mutable_create_database() {
  
  if (_impl_.create_database_ == nullptr) {
    auto* p = CreateMaybeMessage<::greptime::v1::CreateDatabaseExpr>(GetArenaForAllocation());
    _impl_.create_database_ = p;
  }
  return _impl_.create_database_;
}
inline ::greptime::v1::CreateDatabaseExpr* CreateDatabaseTask::mutable_create_database() {
  ::greptime::v1::CreateDatabaseExpr* _msg = _internal_mutable_create_database();
  // @@protoc_insertion_point(field_mutable:greptime.v1.meta.CreateDatabaseTask.create_database)
  return _msg;
}
inline void CreateDatabaseTask::set_allocated_create_database(::greptime::v1::CreateDatabaseExpr* create_database) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.create_database_);
  }
  if (create_database) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(create_database));
    if (message_arena != submessage_arena) {
      create_database = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, create_database, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.create_database_ = create_database;
  // @@protoc_insertion_point(field_set_allocated:greptime.v1.meta.CreateDatabaseTask.create_database)
}

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

// CreateTableTask

// .greptime.v1.CreateTableExpr create_table = 1;
inline bool CreateTableTask::_internal_has_create_table() const {
  return this != internal_default_instance() && _impl_.create_table_ != nullptr;
}
inline bool CreateTableTask::has_create_table() const {
  return _internal_has_create_table();
}
inline const ::greptime::v1::CreateTableExpr& CreateTableTask::_internal_create_table() const {
  const ::greptime::v1::CreateTableExpr* p = _impl_.create_table_;
  return p != nullptr ? *p : reinterpret_cast<const ::greptime::v1::CreateTableExpr&>(
      ::greptime::v1::_CreateTableExpr_default_instance_);
}
inline const ::greptime::v1::CreateTableExpr& CreateTableTask::create_table() const {
  // @@protoc_insertion_point(field_get:greptime.v1.meta.CreateTableTask.create_table)
  return _internal_create_table();
}
inline void CreateTableTask::unsafe_arena_set_allocated_create_table(
    ::greptime::v1::CreateTableExpr* create_table) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.create_table_);
  }
  _impl_.create_table_ = create_table;
  if (create_table) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.meta.CreateTableTask.create_table)
}
inline ::greptime::v1::CreateTableExpr* CreateTableTask::release_create_table() {
  
  ::greptime::v1::CreateTableExpr* temp = _impl_.create_table_;
  _impl_.create_table_ = 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::CreateTableExpr* CreateTableTask::unsafe_arena_release_create_table() {
  // @@protoc_insertion_point(field_release:greptime.v1.meta.CreateTableTask.create_table)
  
  ::greptime::v1::CreateTableExpr* temp = _impl_.create_table_;
  _impl_.create_table_ = nullptr;
  return temp;
}
inline ::greptime::v1::CreateTableExpr* CreateTableTask::_internal_mutable_create_table() {
  
  if (_impl_.create_table_ == nullptr) {
    auto* p = CreateMaybeMessage<::greptime::v1::CreateTableExpr>(GetArenaForAllocation());
    _impl_.create_table_ = p;
  }
  return _impl_.create_table_;
}
inline ::greptime::v1::CreateTableExpr* CreateTableTask::mutable_create_table() {
  ::greptime::v1::CreateTableExpr* _msg = _internal_mutable_create_table();
  // @@protoc_insertion_point(field_mutable:greptime.v1.meta.CreateTableTask.create_table)
  return _msg;
}
inline void CreateTableTask::set_allocated_create_table(::greptime::v1::CreateTableExpr* create_table) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.create_table_);
  }
  if (create_table) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(create_table));
    if (message_arena != submessage_arena) {
      create_table = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, create_table, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.create_table_ = create_table;
  // @@protoc_insertion_point(field_set_allocated:greptime.v1.meta.CreateTableTask.create_table)
}

// repeated .greptime.v1.meta.Partition partitions = 2;
inline int CreateTableTask::_internal_partitions_size() const {
  return _impl_.partitions_.size();
}
inline int CreateTableTask::partitions_size() const {
  return _internal_partitions_size();
}
inline ::greptime::v1::meta::Partition* CreateTableTask::mutable_partitions(int index) {
  // @@protoc_insertion_point(field_mutable:greptime.v1.meta.CreateTableTask.partitions)
  return _impl_.partitions_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::meta::Partition >*
CreateTableTask::mutable_partitions() {
  // @@protoc_insertion_point(field_mutable_list:greptime.v1.meta.CreateTableTask.partitions)
  return &_impl_.partitions_;
}
inline const ::greptime::v1::meta::Partition& CreateTableTask::_internal_partitions(int index) const {
  return _impl_.partitions_.Get(index);
}
inline const ::greptime::v1::meta::Partition& CreateTableTask::partitions(int index) const {
  // @@protoc_insertion_point(field_get:greptime.v1.meta.CreateTableTask.partitions)
  return _internal_partitions(index);
}
inline ::greptime::v1::meta::Partition* CreateTableTask::_internal_add_partitions() {
  return _impl_.partitions_.Add();
}
inline ::greptime::v1::meta::Partition* CreateTableTask::add_partitions() {
  ::greptime::v1::meta::Partition* _add = _internal_add_partitions();
  // @@protoc_insertion_point(field_add:greptime.v1.meta.CreateTableTask.partitions)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::meta::Partition >&
CreateTableTask::partitions() const {
  // @@protoc_insertion_point(field_list:greptime.v1.meta.CreateTableTask.partitions)
  return _impl_.partitions_;
}

// bytes table_info = 3;
inline void CreateTableTask::clear_table_info() {
  _impl_.table_info_.ClearToEmpty();
}
inline const std::string& CreateTableTask::table_info() const {
  // @@protoc_insertion_point(field_get:greptime.v1.meta.CreateTableTask.table_info)
  return _internal_table_info();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CreateTableTask::set_table_info(ArgT0&& arg0, ArgT... args) {
 
 _impl_.table_info_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:greptime.v1.meta.CreateTableTask.table_info)
}
inline std::string* CreateTableTask::mutable_table_info() {
  std::string* _s = _internal_mutable_table_info();
  // @@protoc_insertion_point(field_mutable:greptime.v1.meta.CreateTableTask.table_info)
  return _s;
}
inline const std::string& CreateTableTask::_internal_table_info() const {
  return _impl_.table_info_.Get();
}
inline void CreateTableTask::_internal_set_table_info(const std::string& value) {
  
  _impl_.table_info_.Set(value, GetArenaForAllocation());
}
inline std::string* CreateTableTask::_internal_mutable_table_info() {
  
  return _impl_.table_info_.Mutable(GetArenaForAllocation());
}
inline std::string* CreateTableTask::release_table_info() {
  // @@protoc_insertion_point(field_release:greptime.v1.meta.CreateTableTask.table_info)
  return _impl_.table_info_.Release();
}
inline void CreateTableTask::set_allocated_table_info(std::string* table_info) {
  if (table_info != nullptr) {
    
  } else {
    
  }
  _impl_.table_info_.SetAllocated(table_info, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.table_info_.IsDefault()) {
    _impl_.table_info_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:greptime.v1.meta.CreateTableTask.table_info)
}

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

// CreateTableTasks

// repeated .greptime.v1.meta.CreateTableTask tasks = 1;
inline int CreateTableTasks::_internal_tasks_size() const {
  return _impl_.tasks_.size();
}
inline int CreateTableTasks::tasks_size() const {
  return _internal_tasks_size();
}
inline void CreateTableTasks::clear_tasks() {
  _impl_.tasks_.Clear();
}
inline ::greptime::v1::meta::CreateTableTask* CreateTableTasks::mutable_tasks(int index) {
  // @@protoc_insertion_point(field_mutable:greptime.v1.meta.CreateTableTasks.tasks)
  return _impl_.tasks_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::meta::CreateTableTask >*
CreateTableTasks::mutable_tasks() {
  // @@protoc_insertion_point(field_mutable_list:greptime.v1.meta.CreateTableTasks.tasks)
  return &_impl_.tasks_;
}
inline const ::greptime::v1::meta::CreateTableTask& CreateTableTasks::_internal_tasks(int index) const {
  return _impl_.tasks_.Get(index);
}
inline const ::greptime::v1::meta::CreateTableTask& CreateTableTasks::tasks(int index) const {
  // @@protoc_insertion_point(field_get:greptime.v1.meta.CreateTableTasks.tasks)
  return _internal_tasks(index);
}
inline ::greptime::v1::meta::CreateTableTask* CreateTableTasks::_internal_add_tasks() {
  return _impl_.tasks_.Add();
}
inline ::greptime::v1::meta::CreateTableTask* CreateTableTasks::add_tasks() {
  ::greptime::v1::meta::CreateTableTask* _add = _internal_add_tasks();
  // @@protoc_insertion_point(field_add:greptime.v1.meta.CreateTableTasks.tasks)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::meta::CreateTableTask >&
CreateTableTasks::tasks() const {
  // @@protoc_insertion_point(field_list:greptime.v1.meta.CreateTableTasks.tasks)
  return _impl_.tasks_;
}

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

// DropTableTask

// .greptime.v1.DropTableExpr drop_table = 1;
inline bool DropTableTask::_internal_has_drop_table() const {
  return this != internal_default_instance() && _impl_.drop_table_ != nullptr;
}
inline bool DropTableTask::has_drop_table() const {
  return _internal_has_drop_table();
}
inline const ::greptime::v1::DropTableExpr& DropTableTask::_internal_drop_table() const {
  const ::greptime::v1::DropTableExpr* p = _impl_.drop_table_;
  return p != nullptr ? *p : reinterpret_cast<const ::greptime::v1::DropTableExpr&>(
      ::greptime::v1::_DropTableExpr_default_instance_);
}
inline const ::greptime::v1::DropTableExpr& DropTableTask::drop_table() const {
  // @@protoc_insertion_point(field_get:greptime.v1.meta.DropTableTask.drop_table)
  return _internal_drop_table();
}
inline void DropTableTask::unsafe_arena_set_allocated_drop_table(
    ::greptime::v1::DropTableExpr* drop_table) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.drop_table_);
  }
  _impl_.drop_table_ = drop_table;
  if (drop_table) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.meta.DropTableTask.drop_table)
}
inline ::greptime::v1::DropTableExpr* DropTableTask::release_drop_table() {
  
  ::greptime::v1::DropTableExpr* temp = _impl_.drop_table_;
  _impl_.drop_table_ = 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::DropTableExpr* DropTableTask::unsafe_arena_release_drop_table() {
  // @@protoc_insertion_point(field_release:greptime.v1.meta.DropTableTask.drop_table)
  
  ::greptime::v1::DropTableExpr* temp = _impl_.drop_table_;
  _impl_.drop_table_ = nullptr;
  return temp;
}
inline ::greptime::v1::DropTableExpr* DropTableTask::_internal_mutable_drop_table() {
  
  if (_impl_.drop_table_ == nullptr) {
    auto* p = CreateMaybeMessage<::greptime::v1::DropTableExpr>(GetArenaForAllocation());
    _impl_.drop_table_ = p;
  }
  return _impl_.drop_table_;
}
inline ::greptime::v1::DropTableExpr* DropTableTask::mutable_drop_table() {
  ::greptime::v1::DropTableExpr* _msg = _internal_mutable_drop_table();
  // @@protoc_insertion_point(field_mutable:greptime.v1.meta.DropTableTask.drop_table)
  return _msg;
}
inline void DropTableTask::set_allocated_drop_table(::greptime::v1::DropTableExpr* drop_table) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.drop_table_);
  }
  if (drop_table) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(drop_table));
    if (message_arena != submessage_arena) {
      drop_table = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, drop_table, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.drop_table_ = drop_table;
  // @@protoc_insertion_point(field_set_allocated:greptime.v1.meta.DropTableTask.drop_table)
}

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

// DropTableTasks

// repeated .greptime.v1.meta.DropTableTask tasks = 1;
inline int DropTableTasks::_internal_tasks_size() const {
  return _impl_.tasks_.size();
}
inline int DropTableTasks::tasks_size() const {
  return _internal_tasks_size();
}
inline void DropTableTasks::clear_tasks() {
  _impl_.tasks_.Clear();
}
inline ::greptime::v1::meta::DropTableTask* DropTableTasks::mutable_tasks(int index) {
  // @@protoc_insertion_point(field_mutable:greptime.v1.meta.DropTableTasks.tasks)
  return _impl_.tasks_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::meta::DropTableTask >*
DropTableTasks::mutable_tasks() {
  // @@protoc_insertion_point(field_mutable_list:greptime.v1.meta.DropTableTasks.tasks)
  return &_impl_.tasks_;
}
inline const ::greptime::v1::meta::DropTableTask& DropTableTasks::_internal_tasks(int index) const {
  return _impl_.tasks_.Get(index);
}
inline const ::greptime::v1::meta::DropTableTask& DropTableTasks::tasks(int index) const {
  // @@protoc_insertion_point(field_get:greptime.v1.meta.DropTableTasks.tasks)
  return _internal_tasks(index);
}
inline ::greptime::v1::meta::DropTableTask* DropTableTasks::_internal_add_tasks() {
  return _impl_.tasks_.Add();
}
inline ::greptime::v1::meta::DropTableTask* DropTableTasks::add_tasks() {
  ::greptime::v1::meta::DropTableTask* _add = _internal_add_tasks();
  // @@protoc_insertion_point(field_add:greptime.v1.meta.DropTableTasks.tasks)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::meta::DropTableTask >&
DropTableTasks::tasks() const {
  // @@protoc_insertion_point(field_list:greptime.v1.meta.DropTableTasks.tasks)
  return _impl_.tasks_;
}

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

// AlterTableTask

// .greptime.v1.AlterTableExpr alter_table = 1;
inline bool AlterTableTask::_internal_has_alter_table() const {
  return this != internal_default_instance() && _impl_.alter_table_ != nullptr;
}
inline bool AlterTableTask::has_alter_table() const {
  return _internal_has_alter_table();
}
inline const ::greptime::v1::AlterTableExpr& AlterTableTask::_internal_alter_table() const {
  const ::greptime::v1::AlterTableExpr* p = _impl_.alter_table_;
  return p != nullptr ? *p : reinterpret_cast<const ::greptime::v1::AlterTableExpr&>(
      ::greptime::v1::_AlterTableExpr_default_instance_);
}
inline const ::greptime::v1::AlterTableExpr& AlterTableTask::alter_table() const {
  // @@protoc_insertion_point(field_get:greptime.v1.meta.AlterTableTask.alter_table)
  return _internal_alter_table();
}
inline void AlterTableTask::unsafe_arena_set_allocated_alter_table(
    ::greptime::v1::AlterTableExpr* alter_table) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.alter_table_);
  }
  _impl_.alter_table_ = alter_table;
  if (alter_table) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.meta.AlterTableTask.alter_table)
}
inline ::greptime::v1::AlterTableExpr* AlterTableTask::release_alter_table() {
  
  ::greptime::v1::AlterTableExpr* temp = _impl_.alter_table_;
  _impl_.alter_table_ = 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::AlterTableExpr* AlterTableTask::unsafe_arena_release_alter_table() {
  // @@protoc_insertion_point(field_release:greptime.v1.meta.AlterTableTask.alter_table)
  
  ::greptime::v1::AlterTableExpr* temp = _impl_.alter_table_;
  _impl_.alter_table_ = nullptr;
  return temp;
}
inline ::greptime::v1::AlterTableExpr* AlterTableTask::_internal_mutable_alter_table() {
  
  if (_impl_.alter_table_ == nullptr) {
    auto* p = CreateMaybeMessage<::greptime::v1::AlterTableExpr>(GetArenaForAllocation());
    _impl_.alter_table_ = p;
  }
  return _impl_.alter_table_;
}
inline ::greptime::v1::AlterTableExpr* AlterTableTask::mutable_alter_table() {
  ::greptime::v1::AlterTableExpr* _msg = _internal_mutable_alter_table();
  // @@protoc_insertion_point(field_mutable:greptime.v1.meta.AlterTableTask.alter_table)
  return _msg;
}
inline void AlterTableTask::set_allocated_alter_table(::greptime::v1::AlterTableExpr* alter_table) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.alter_table_);
  }
  if (alter_table) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(alter_table));
    if (message_arena != submessage_arena) {
      alter_table = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, alter_table, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.alter_table_ = alter_table;
  // @@protoc_insertion_point(field_set_allocated:greptime.v1.meta.AlterTableTask.alter_table)
}

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

// AlterTableTasks

// repeated .greptime.v1.meta.AlterTableTask tasks = 1;
inline int AlterTableTasks::_internal_tasks_size() const {
  return _impl_.tasks_.size();
}
inline int AlterTableTasks::tasks_size() const {
  return _internal_tasks_size();
}
inline void AlterTableTasks::clear_tasks() {
  _impl_.tasks_.Clear();
}
inline ::greptime::v1::meta::AlterTableTask* AlterTableTasks::mutable_tasks(int index) {
  // @@protoc_insertion_point(field_mutable:greptime.v1.meta.AlterTableTasks.tasks)
  return _impl_.tasks_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::meta::AlterTableTask >*
AlterTableTasks::mutable_tasks() {
  // @@protoc_insertion_point(field_mutable_list:greptime.v1.meta.AlterTableTasks.tasks)
  return &_impl_.tasks_;
}
inline const ::greptime::v1::meta::AlterTableTask& AlterTableTasks::_internal_tasks(int index) const {
  return _impl_.tasks_.Get(index);
}
inline const ::greptime::v1::meta::AlterTableTask& AlterTableTasks::tasks(int index) const {
  // @@protoc_insertion_point(field_get:greptime.v1.meta.AlterTableTasks.tasks)
  return _internal_tasks(index);
}
inline ::greptime::v1::meta::AlterTableTask* AlterTableTasks::_internal_add_tasks() {
  return _impl_.tasks_.Add();
}
inline ::greptime::v1::meta::AlterTableTask* AlterTableTasks::add_tasks() {
  ::greptime::v1::meta::AlterTableTask* _add = _internal_add_tasks();
  // @@protoc_insertion_point(field_add:greptime.v1.meta.AlterTableTasks.tasks)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::meta::AlterTableTask >&
AlterTableTasks::tasks() const {
  // @@protoc_insertion_point(field_list:greptime.v1.meta.AlterTableTasks.tasks)
  return _impl_.tasks_;
}

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

// TruncateTableTask

// .greptime.v1.TruncateTableExpr truncate_table = 1;
inline bool TruncateTableTask::_internal_has_truncate_table() const {
  return this != internal_default_instance() && _impl_.truncate_table_ != nullptr;
}
inline bool TruncateTableTask::has_truncate_table() const {
  return _internal_has_truncate_table();
}
inline const ::greptime::v1::TruncateTableExpr& TruncateTableTask::_internal_truncate_table() const {
  const ::greptime::v1::TruncateTableExpr* p = _impl_.truncate_table_;
  return p != nullptr ? *p : reinterpret_cast<const ::greptime::v1::TruncateTableExpr&>(
      ::greptime::v1::_TruncateTableExpr_default_instance_);
}
inline const ::greptime::v1::TruncateTableExpr& TruncateTableTask::truncate_table() const {
  // @@protoc_insertion_point(field_get:greptime.v1.meta.TruncateTableTask.truncate_table)
  return _internal_truncate_table();
}
inline void TruncateTableTask::unsafe_arena_set_allocated_truncate_table(
    ::greptime::v1::TruncateTableExpr* truncate_table) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.truncate_table_);
  }
  _impl_.truncate_table_ = truncate_table;
  if (truncate_table) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.meta.TruncateTableTask.truncate_table)
}
inline ::greptime::v1::TruncateTableExpr* TruncateTableTask::release_truncate_table() {
  
  ::greptime::v1::TruncateTableExpr* temp = _impl_.truncate_table_;
  _impl_.truncate_table_ = 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::TruncateTableExpr* TruncateTableTask::unsafe_arena_release_truncate_table() {
  // @@protoc_insertion_point(field_release:greptime.v1.meta.TruncateTableTask.truncate_table)
  
  ::greptime::v1::TruncateTableExpr* temp = _impl_.truncate_table_;
  _impl_.truncate_table_ = nullptr;
  return temp;
}
inline ::greptime::v1::TruncateTableExpr* TruncateTableTask::_internal_mutable_truncate_table() {
  
  if (_impl_.truncate_table_ == nullptr) {
    auto* p = CreateMaybeMessage<::greptime::v1::TruncateTableExpr>(GetArenaForAllocation());
    _impl_.truncate_table_ = p;
  }
  return _impl_.truncate_table_;
}
inline ::greptime::v1::TruncateTableExpr* TruncateTableTask::mutable_truncate_table() {
  ::greptime::v1::TruncateTableExpr* _msg = _internal_mutable_truncate_table();
  // @@protoc_insertion_point(field_mutable:greptime.v1.meta.TruncateTableTask.truncate_table)
  return _msg;
}
inline void TruncateTableTask::set_allocated_truncate_table(::greptime::v1::TruncateTableExpr* truncate_table) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.truncate_table_);
  }
  if (truncate_table) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(truncate_table));
    if (message_arena != submessage_arena) {
      truncate_table = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, truncate_table, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.truncate_table_ = truncate_table;
  // @@protoc_insertion_point(field_set_allocated:greptime.v1.meta.TruncateTableTask.truncate_table)
}

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

// DropDatabaseTask

// .greptime.v1.DropDatabaseExpr drop_database = 1;
inline bool DropDatabaseTask::_internal_has_drop_database() const {
  return this != internal_default_instance() && _impl_.drop_database_ != nullptr;
}
inline bool DropDatabaseTask::has_drop_database() const {
  return _internal_has_drop_database();
}
inline const ::greptime::v1::DropDatabaseExpr& DropDatabaseTask::_internal_drop_database() const {
  const ::greptime::v1::DropDatabaseExpr* p = _impl_.drop_database_;
  return p != nullptr ? *p : reinterpret_cast<const ::greptime::v1::DropDatabaseExpr&>(
      ::greptime::v1::_DropDatabaseExpr_default_instance_);
}
inline const ::greptime::v1::DropDatabaseExpr& DropDatabaseTask::drop_database() const {
  // @@protoc_insertion_point(field_get:greptime.v1.meta.DropDatabaseTask.drop_database)
  return _internal_drop_database();
}
inline void DropDatabaseTask::unsafe_arena_set_allocated_drop_database(
    ::greptime::v1::DropDatabaseExpr* drop_database) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.drop_database_);
  }
  _impl_.drop_database_ = drop_database;
  if (drop_database) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.meta.DropDatabaseTask.drop_database)
}
inline ::greptime::v1::DropDatabaseExpr* DropDatabaseTask::release_drop_database() {
  
  ::greptime::v1::DropDatabaseExpr* temp = _impl_.drop_database_;
  _impl_.drop_database_ = 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::DropDatabaseExpr* DropDatabaseTask::unsafe_arena_release_drop_database() {
  // @@protoc_insertion_point(field_release:greptime.v1.meta.DropDatabaseTask.drop_database)
  
  ::greptime::v1::DropDatabaseExpr* temp = _impl_.drop_database_;
  _impl_.drop_database_ = nullptr;
  return temp;
}
inline ::greptime::v1::DropDatabaseExpr* DropDatabaseTask::_internal_mutable_drop_database() {
  
  if (_impl_.drop_database_ == nullptr) {
    auto* p = CreateMaybeMessage<::greptime::v1::DropDatabaseExpr>(GetArenaForAllocation());
    _impl_.drop_database_ = p;
  }
  return _impl_.drop_database_;
}
inline ::greptime::v1::DropDatabaseExpr* DropDatabaseTask::mutable_drop_database() {
  ::greptime::v1::DropDatabaseExpr* _msg = _internal_mutable_drop_database();
  // @@protoc_insertion_point(field_mutable:greptime.v1.meta.DropDatabaseTask.drop_database)
  return _msg;
}
inline void DropDatabaseTask::set_allocated_drop_database(::greptime::v1::DropDatabaseExpr* drop_database) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.drop_database_);
  }
  if (drop_database) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(drop_database));
    if (message_arena != submessage_arena) {
      drop_database = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, drop_database, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.drop_database_ = drop_database;
  // @@protoc_insertion_point(field_set_allocated:greptime.v1.meta.DropDatabaseTask.drop_database)
}

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

// CreateFlowTask

// .greptime.v1.CreateFlowExpr create_flow = 1;
inline bool CreateFlowTask::_internal_has_create_flow() const {
  return this != internal_default_instance() && _impl_.create_flow_ != nullptr;
}
inline bool CreateFlowTask::has_create_flow() const {
  return _internal_has_create_flow();
}
inline const ::greptime::v1::CreateFlowExpr& CreateFlowTask::_internal_create_flow() const {
  const ::greptime::v1::CreateFlowExpr* p = _impl_.create_flow_;
  return p != nullptr ? *p : reinterpret_cast<const ::greptime::v1::CreateFlowExpr&>(
      ::greptime::v1::_CreateFlowExpr_default_instance_);
}
inline const ::greptime::v1::CreateFlowExpr& CreateFlowTask::create_flow() const {
  // @@protoc_insertion_point(field_get:greptime.v1.meta.CreateFlowTask.create_flow)
  return _internal_create_flow();
}
inline void CreateFlowTask::unsafe_arena_set_allocated_create_flow(
    ::greptime::v1::CreateFlowExpr* create_flow) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.create_flow_);
  }
  _impl_.create_flow_ = create_flow;
  if (create_flow) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.meta.CreateFlowTask.create_flow)
}
inline ::greptime::v1::CreateFlowExpr* CreateFlowTask::release_create_flow() {
  
  ::greptime::v1::CreateFlowExpr* temp = _impl_.create_flow_;
  _impl_.create_flow_ = 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::CreateFlowExpr* CreateFlowTask::unsafe_arena_release_create_flow() {
  // @@protoc_insertion_point(field_release:greptime.v1.meta.CreateFlowTask.create_flow)
  
  ::greptime::v1::CreateFlowExpr* temp = _impl_.create_flow_;
  _impl_.create_flow_ = nullptr;
  return temp;
}
inline ::greptime::v1::CreateFlowExpr* CreateFlowTask::_internal_mutable_create_flow() {
  
  if (_impl_.create_flow_ == nullptr) {
    auto* p = CreateMaybeMessage<::greptime::v1::CreateFlowExpr>(GetArenaForAllocation());
    _impl_.create_flow_ = p;
  }
  return _impl_.create_flow_;
}
inline ::greptime::v1::CreateFlowExpr* CreateFlowTask::mutable_create_flow() {
  ::greptime::v1::CreateFlowExpr* _msg = _internal_mutable_create_flow();
  // @@protoc_insertion_point(field_mutable:greptime.v1.meta.CreateFlowTask.create_flow)
  return _msg;
}
inline void CreateFlowTask::set_allocated_create_flow(::greptime::v1::CreateFlowExpr* create_flow) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.create_flow_);
  }
  if (create_flow) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(create_flow));
    if (message_arena != submessage_arena) {
      create_flow = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, create_flow, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.create_flow_ = create_flow;
  // @@protoc_insertion_point(field_set_allocated:greptime.v1.meta.CreateFlowTask.create_flow)
}

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

// DropFlowTask

// .greptime.v1.DropFlowExpr drop_flow = 1;
inline bool DropFlowTask::_internal_has_drop_flow() const {
  return this != internal_default_instance() && _impl_.drop_flow_ != nullptr;
}
inline bool DropFlowTask::has_drop_flow() const {
  return _internal_has_drop_flow();
}
inline const ::greptime::v1::DropFlowExpr& DropFlowTask::_internal_drop_flow() const {
  const ::greptime::v1::DropFlowExpr* p = _impl_.drop_flow_;
  return p != nullptr ? *p : reinterpret_cast<const ::greptime::v1::DropFlowExpr&>(
      ::greptime::v1::_DropFlowExpr_default_instance_);
}
inline const ::greptime::v1::DropFlowExpr& DropFlowTask::drop_flow() const {
  // @@protoc_insertion_point(field_get:greptime.v1.meta.DropFlowTask.drop_flow)
  return _internal_drop_flow();
}
inline void DropFlowTask::unsafe_arena_set_allocated_drop_flow(
    ::greptime::v1::DropFlowExpr* drop_flow) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.drop_flow_);
  }
  _impl_.drop_flow_ = drop_flow;
  if (drop_flow) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.meta.DropFlowTask.drop_flow)
}
inline ::greptime::v1::DropFlowExpr* DropFlowTask::release_drop_flow() {
  
  ::greptime::v1::DropFlowExpr* temp = _impl_.drop_flow_;
  _impl_.drop_flow_ = 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::DropFlowExpr* DropFlowTask::unsafe_arena_release_drop_flow() {
  // @@protoc_insertion_point(field_release:greptime.v1.meta.DropFlowTask.drop_flow)
  
  ::greptime::v1::DropFlowExpr* temp = _impl_.drop_flow_;
  _impl_.drop_flow_ = nullptr;
  return temp;
}
inline ::greptime::v1::DropFlowExpr* DropFlowTask::_internal_mutable_drop_flow() {
  
  if (_impl_.drop_flow_ == nullptr) {
    auto* p = CreateMaybeMessage<::greptime::v1::DropFlowExpr>(GetArenaForAllocation());
    _impl_.drop_flow_ = p;
  }
  return _impl_.drop_flow_;
}
inline ::greptime::v1::DropFlowExpr* DropFlowTask::mutable_drop_flow() {
  ::greptime::v1::DropFlowExpr* _msg = _internal_mutable_drop_flow();
  // @@protoc_insertion_point(field_mutable:greptime.v1.meta.DropFlowTask.drop_flow)
  return _msg;
}
inline void DropFlowTask::set_allocated_drop_flow(::greptime::v1::DropFlowExpr* drop_flow) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.drop_flow_);
  }
  if (drop_flow) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(drop_flow));
    if (message_arena != submessage_arena) {
      drop_flow = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, drop_flow, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.drop_flow_ = drop_flow;
  // @@protoc_insertion_point(field_set_allocated:greptime.v1.meta.DropFlowTask.drop_flow)
}

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

// CreateViewTask

// .greptime.v1.CreateViewExpr create_view = 1;
inline bool CreateViewTask::_internal_has_create_view() const {
  return this != internal_default_instance() && _impl_.create_view_ != nullptr;
}
inline bool CreateViewTask::has_create_view() const {
  return _internal_has_create_view();
}
inline const ::greptime::v1::CreateViewExpr& CreateViewTask::_internal_create_view() const {
  const ::greptime::v1::CreateViewExpr* p = _impl_.create_view_;
  return p != nullptr ? *p : reinterpret_cast<const ::greptime::v1::CreateViewExpr&>(
      ::greptime::v1::_CreateViewExpr_default_instance_);
}
inline const ::greptime::v1::CreateViewExpr& CreateViewTask::create_view() const {
  // @@protoc_insertion_point(field_get:greptime.v1.meta.CreateViewTask.create_view)
  return _internal_create_view();
}
inline void CreateViewTask::unsafe_arena_set_allocated_create_view(
    ::greptime::v1::CreateViewExpr* create_view) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.create_view_);
  }
  _impl_.create_view_ = create_view;
  if (create_view) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.meta.CreateViewTask.create_view)
}
inline ::greptime::v1::CreateViewExpr* CreateViewTask::release_create_view() {
  
  ::greptime::v1::CreateViewExpr* temp = _impl_.create_view_;
  _impl_.create_view_ = 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::CreateViewExpr* CreateViewTask::unsafe_arena_release_create_view() {
  // @@protoc_insertion_point(field_release:greptime.v1.meta.CreateViewTask.create_view)
  
  ::greptime::v1::CreateViewExpr* temp = _impl_.create_view_;
  _impl_.create_view_ = nullptr;
  return temp;
}
inline ::greptime::v1::CreateViewExpr* CreateViewTask::_internal_mutable_create_view() {
  
  if (_impl_.create_view_ == nullptr) {
    auto* p = CreateMaybeMessage<::greptime::v1::CreateViewExpr>(GetArenaForAllocation());
    _impl_.create_view_ = p;
  }
  return _impl_.create_view_;
}
inline ::greptime::v1::CreateViewExpr* CreateViewTask::mutable_create_view() {
  ::greptime::v1::CreateViewExpr* _msg = _internal_mutable_create_view();
  // @@protoc_insertion_point(field_mutable:greptime.v1.meta.CreateViewTask.create_view)
  return _msg;
}
inline void CreateViewTask::set_allocated_create_view(::greptime::v1::CreateViewExpr* create_view) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.create_view_);
  }
  if (create_view) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(create_view));
    if (message_arena != submessage_arena) {
      create_view = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, create_view, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.create_view_ = create_view;
  // @@protoc_insertion_point(field_set_allocated:greptime.v1.meta.CreateViewTask.create_view)
}

// bytes view_info = 2;
inline void CreateViewTask::clear_view_info() {
  _impl_.view_info_.ClearToEmpty();
}
inline const std::string& CreateViewTask::view_info() const {
  // @@protoc_insertion_point(field_get:greptime.v1.meta.CreateViewTask.view_info)
  return _internal_view_info();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CreateViewTask::set_view_info(ArgT0&& arg0, ArgT... args) {
 
 _impl_.view_info_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:greptime.v1.meta.CreateViewTask.view_info)
}
inline std::string* CreateViewTask::mutable_view_info() {
  std::string* _s = _internal_mutable_view_info();
  // @@protoc_insertion_point(field_mutable:greptime.v1.meta.CreateViewTask.view_info)
  return _s;
}
inline const std::string& CreateViewTask::_internal_view_info() const {
  return _impl_.view_info_.Get();
}
inline void CreateViewTask::_internal_set_view_info(const std::string& value) {
  
  _impl_.view_info_.Set(value, GetArenaForAllocation());
}
inline std::string* CreateViewTask::_internal_mutable_view_info() {
  
  return _impl_.view_info_.Mutable(GetArenaForAllocation());
}
inline std::string* CreateViewTask::release_view_info() {
  // @@protoc_insertion_point(field_release:greptime.v1.meta.CreateViewTask.view_info)
  return _impl_.view_info_.Release();
}
inline void CreateViewTask::set_allocated_view_info(std::string* view_info) {
  if (view_info != nullptr) {
    
  } else {
    
  }
  _impl_.view_info_.SetAllocated(view_info, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.view_info_.IsDefault()) {
    _impl_.view_info_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:greptime.v1.meta.CreateViewTask.view_info)
}

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

// DropViewTask

// .greptime.v1.DropViewExpr drop_view = 1;
inline bool DropViewTask::_internal_has_drop_view() const {
  return this != internal_default_instance() && _impl_.drop_view_ != nullptr;
}
inline bool DropViewTask::has_drop_view() const {
  return _internal_has_drop_view();
}
inline const ::greptime::v1::DropViewExpr& DropViewTask::_internal_drop_view() const {
  const ::greptime::v1::DropViewExpr* p = _impl_.drop_view_;
  return p != nullptr ? *p : reinterpret_cast<const ::greptime::v1::DropViewExpr&>(
      ::greptime::v1::_DropViewExpr_default_instance_);
}
inline const ::greptime::v1::DropViewExpr& DropViewTask::drop_view() const {
  // @@protoc_insertion_point(field_get:greptime.v1.meta.DropViewTask.drop_view)
  return _internal_drop_view();
}
inline void DropViewTask::unsafe_arena_set_allocated_drop_view(
    ::greptime::v1::DropViewExpr* drop_view) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.drop_view_);
  }
  _impl_.drop_view_ = drop_view;
  if (drop_view) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.meta.DropViewTask.drop_view)
}
inline ::greptime::v1::DropViewExpr* DropViewTask::release_drop_view() {
  
  ::greptime::v1::DropViewExpr* temp = _impl_.drop_view_;
  _impl_.drop_view_ = 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::DropViewExpr* DropViewTask::unsafe_arena_release_drop_view() {
  // @@protoc_insertion_point(field_release:greptime.v1.meta.DropViewTask.drop_view)
  
  ::greptime::v1::DropViewExpr* temp = _impl_.drop_view_;
  _impl_.drop_view_ = nullptr;
  return temp;
}
inline ::greptime::v1::DropViewExpr* DropViewTask::_internal_mutable_drop_view() {
  
  if (_impl_.drop_view_ == nullptr) {
    auto* p = CreateMaybeMessage<::greptime::v1::DropViewExpr>(GetArenaForAllocation());
    _impl_.drop_view_ = p;
  }
  return _impl_.drop_view_;
}
inline ::greptime::v1::DropViewExpr* DropViewTask::mutable_drop_view() {
  ::greptime::v1::DropViewExpr* _msg = _internal_mutable_drop_view();
  // @@protoc_insertion_point(field_mutable:greptime.v1.meta.DropViewTask.drop_view)
  return _msg;
}
inline void DropViewTask::set_allocated_drop_view(::greptime::v1::DropViewExpr* drop_view) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.drop_view_);
  }
  if (drop_view) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(drop_view));
    if (message_arena != submessage_arena) {
      drop_view = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, drop_view, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.drop_view_ = drop_view;
  // @@protoc_insertion_point(field_set_allocated:greptime.v1.meta.DropViewTask.drop_view)
}

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

// AlterDatabaseTask

// .greptime.v1.AlterDatabaseExpr task = 1;
inline bool AlterDatabaseTask::_internal_has_task() const {
  return this != internal_default_instance() && _impl_.task_ != nullptr;
}
inline bool AlterDatabaseTask::has_task() const {
  return _internal_has_task();
}
inline const ::greptime::v1::AlterDatabaseExpr& AlterDatabaseTask::_internal_task() const {
  const ::greptime::v1::AlterDatabaseExpr* p = _impl_.task_;
  return p != nullptr ? *p : reinterpret_cast<const ::greptime::v1::AlterDatabaseExpr&>(
      ::greptime::v1::_AlterDatabaseExpr_default_instance_);
}
inline const ::greptime::v1::AlterDatabaseExpr& AlterDatabaseTask::task() const {
  // @@protoc_insertion_point(field_get:greptime.v1.meta.AlterDatabaseTask.task)
  return _internal_task();
}
inline void AlterDatabaseTask::unsafe_arena_set_allocated_task(
    ::greptime::v1::AlterDatabaseExpr* task) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.task_);
  }
  _impl_.task_ = task;
  if (task) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.meta.AlterDatabaseTask.task)
}
inline ::greptime::v1::AlterDatabaseExpr* AlterDatabaseTask::release_task() {
  
  ::greptime::v1::AlterDatabaseExpr* temp = _impl_.task_;
  _impl_.task_ = 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::AlterDatabaseExpr* AlterDatabaseTask::unsafe_arena_release_task() {
  // @@protoc_insertion_point(field_release:greptime.v1.meta.AlterDatabaseTask.task)
  
  ::greptime::v1::AlterDatabaseExpr* temp = _impl_.task_;
  _impl_.task_ = nullptr;
  return temp;
}
inline ::greptime::v1::AlterDatabaseExpr* AlterDatabaseTask::_internal_mutable_task() {
  
  if (_impl_.task_ == nullptr) {
    auto* p = CreateMaybeMessage<::greptime::v1::AlterDatabaseExpr>(GetArenaForAllocation());
    _impl_.task_ = p;
  }
  return _impl_.task_;
}
inline ::greptime::v1::AlterDatabaseExpr* AlterDatabaseTask::mutable_task() {
  ::greptime::v1::AlterDatabaseExpr* _msg = _internal_mutable_task();
  // @@protoc_insertion_point(field_mutable:greptime.v1.meta.AlterDatabaseTask.task)
  return _msg;
}
inline void AlterDatabaseTask::set_allocated_task(::greptime::v1::AlterDatabaseExpr* task) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.task_);
  }
  if (task) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(task));
    if (message_arena != submessage_arena) {
      task = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, task, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.task_ = task;
  // @@protoc_insertion_point(field_set_allocated:greptime.v1.meta.AlterDatabaseTask.task)
}

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

// DdlTaskRequest

// .greptime.v1.meta.RequestHeader header = 1;
inline bool DdlTaskRequest::_internal_has_header() const {
  return this != internal_default_instance() && _impl_.header_ != nullptr;
}
inline bool DdlTaskRequest::has_header() const {
  return _internal_has_header();
}
inline const ::greptime::v1::meta::RequestHeader& DdlTaskRequest::_internal_header() const {
  const ::greptime::v1::meta::RequestHeader* p = _impl_.header_;
  return p != nullptr ? *p : reinterpret_cast<const ::greptime::v1::meta::RequestHeader&>(
      ::greptime::v1::meta::_RequestHeader_default_instance_);
}
inline const ::greptime::v1::meta::RequestHeader& DdlTaskRequest::header() const {
  // @@protoc_insertion_point(field_get:greptime.v1.meta.DdlTaskRequest.header)
  return _internal_header();
}
inline void DdlTaskRequest::unsafe_arena_set_allocated_header(
    ::greptime::v1::meta::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.meta.DdlTaskRequest.header)
}
inline ::greptime::v1::meta::RequestHeader* DdlTaskRequest::release_header() {
  
  ::greptime::v1::meta::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::meta::RequestHeader* DdlTaskRequest::unsafe_arena_release_header() {
  // @@protoc_insertion_point(field_release:greptime.v1.meta.DdlTaskRequest.header)
  
  ::greptime::v1::meta::RequestHeader* temp = _impl_.header_;
  _impl_.header_ = nullptr;
  return temp;
}
inline ::greptime::v1::meta::RequestHeader* DdlTaskRequest::_internal_mutable_header() {
  
  if (_impl_.header_ == nullptr) {
    auto* p = CreateMaybeMessage<::greptime::v1::meta::RequestHeader>(GetArenaForAllocation());
    _impl_.header_ = p;
  }
  return _impl_.header_;
}
inline ::greptime::v1::meta::RequestHeader* DdlTaskRequest::mutable_header() {
  ::greptime::v1::meta::RequestHeader* _msg = _internal_mutable_header();
  // @@protoc_insertion_point(field_mutable:greptime.v1.meta.DdlTaskRequest.header)
  return _msg;
}
inline void DdlTaskRequest::set_allocated_header(::greptime::v1::meta::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.meta.DdlTaskRequest.header)
}

// .greptime.v1.QueryContext query_context = 64;
inline bool DdlTaskRequest::_internal_has_query_context() const {
  return this != internal_default_instance() && _impl_.query_context_ != nullptr;
}
inline bool DdlTaskRequest::has_query_context() const {
  return _internal_has_query_context();
}
inline const ::greptime::v1::QueryContext& DdlTaskRequest::_internal_query_context() const {
  const ::greptime::v1::QueryContext* p = _impl_.query_context_;
  return p != nullptr ? *p : reinterpret_cast<const ::greptime::v1::QueryContext&>(
      ::greptime::v1::_QueryContext_default_instance_);
}
inline const ::greptime::v1::QueryContext& DdlTaskRequest::query_context() const {
  // @@protoc_insertion_point(field_get:greptime.v1.meta.DdlTaskRequest.query_context)
  return _internal_query_context();
}
inline void DdlTaskRequest::unsafe_arena_set_allocated_query_context(
    ::greptime::v1::QueryContext* query_context) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.query_context_);
  }
  _impl_.query_context_ = query_context;
  if (query_context) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.meta.DdlTaskRequest.query_context)
}
inline ::greptime::v1::QueryContext* DdlTaskRequest::release_query_context() {
  
  ::greptime::v1::QueryContext* temp = _impl_.query_context_;
  _impl_.query_context_ = 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::QueryContext* DdlTaskRequest::unsafe_arena_release_query_context() {
  // @@protoc_insertion_point(field_release:greptime.v1.meta.DdlTaskRequest.query_context)
  
  ::greptime::v1::QueryContext* temp = _impl_.query_context_;
  _impl_.query_context_ = nullptr;
  return temp;
}
inline ::greptime::v1::QueryContext* DdlTaskRequest::_internal_mutable_query_context() {
  
  if (_impl_.query_context_ == nullptr) {
    auto* p = CreateMaybeMessage<::greptime::v1::QueryContext>(GetArenaForAllocation());
    _impl_.query_context_ = p;
  }
  return _impl_.query_context_;
}
inline ::greptime::v1::QueryContext* DdlTaskRequest::mutable_query_context() {
  ::greptime::v1::QueryContext* _msg = _internal_mutable_query_context();
  // @@protoc_insertion_point(field_mutable:greptime.v1.meta.DdlTaskRequest.query_context)
  return _msg;
}
inline void DdlTaskRequest::set_allocated_query_context(::greptime::v1::QueryContext* query_context) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.query_context_);
  }
  if (query_context) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(query_context));
    if (message_arena != submessage_arena) {
      query_context = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, query_context, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.query_context_ = query_context;
  // @@protoc_insertion_point(field_set_allocated:greptime.v1.meta.DdlTaskRequest.query_context)
}

// .greptime.v1.meta.CreateTableTask create_table_task = 2;
inline bool DdlTaskRequest::_internal_has_create_table_task() const {
  return task_case() == kCreateTableTask;
}
inline bool DdlTaskRequest::has_create_table_task() const {
  return _internal_has_create_table_task();
}
inline void DdlTaskRequest::set_has_create_table_task() {
  _impl_._oneof_case_[0] = kCreateTableTask;
}
inline void DdlTaskRequest::clear_create_table_task() {
  if (_internal_has_create_table_task()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.task_.create_table_task_;
    }
    clear_has_task();
  }
}
inline ::greptime::v1::meta::CreateTableTask* DdlTaskRequest::release_create_table_task() {
  // @@protoc_insertion_point(field_release:greptime.v1.meta.DdlTaskRequest.create_table_task)
  if (_internal_has_create_table_task()) {
    clear_has_task();
    ::greptime::v1::meta::CreateTableTask* temp = _impl_.task_.create_table_task_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.task_.create_table_task_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::greptime::v1::meta::CreateTableTask& DdlTaskRequest::_internal_create_table_task() const {
  return _internal_has_create_table_task()
      ? *_impl_.task_.create_table_task_
      : reinterpret_cast< ::greptime::v1::meta::CreateTableTask&>(::greptime::v1::meta::_CreateTableTask_default_instance_);
}
inline const ::greptime::v1::meta::CreateTableTask& DdlTaskRequest::create_table_task() const {
  // @@protoc_insertion_point(field_get:greptime.v1.meta.DdlTaskRequest.create_table_task)
  return _internal_create_table_task();
}
inline ::greptime::v1::meta::CreateTableTask* DdlTaskRequest::unsafe_arena_release_create_table_task() {
  // @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.meta.DdlTaskRequest.create_table_task)
  if (_internal_has_create_table_task()) {
    clear_has_task();
    ::greptime::v1::meta::CreateTableTask* temp = _impl_.task_.create_table_task_;
    _impl_.task_.create_table_task_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DdlTaskRequest::unsafe_arena_set_allocated_create_table_task(::greptime::v1::meta::CreateTableTask* create_table_task) {
  clear_task();
  if (create_table_task) {
    set_has_create_table_task();
    _impl_.task_.create_table_task_ = create_table_task;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.meta.DdlTaskRequest.create_table_task)
}
inline ::greptime::v1::meta::CreateTableTask* DdlTaskRequest::_internal_mutable_create_table_task() {
  if (!_internal_has_create_table_task()) {
    clear_task();
    set_has_create_table_task();
    _impl_.task_.create_table_task_ = CreateMaybeMessage< ::greptime::v1::meta::CreateTableTask >(GetArenaForAllocation());
  }
  return _impl_.task_.create_table_task_;
}
inline ::greptime::v1::meta::CreateTableTask* DdlTaskRequest::mutable_create_table_task() {
  ::greptime::v1::meta::CreateTableTask* _msg = _internal_mutable_create_table_task();
  // @@protoc_insertion_point(field_mutable:greptime.v1.meta.DdlTaskRequest.create_table_task)
  return _msg;
}

// .greptime.v1.meta.DropTableTask drop_table_task = 3;
inline bool DdlTaskRequest::_internal_has_drop_table_task() const {
  return task_case() == kDropTableTask;
}
inline bool DdlTaskRequest::has_drop_table_task() const {
  return _internal_has_drop_table_task();
}
inline void DdlTaskRequest::set_has_drop_table_task() {
  _impl_._oneof_case_[0] = kDropTableTask;
}
inline void DdlTaskRequest::clear_drop_table_task() {
  if (_internal_has_drop_table_task()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.task_.drop_table_task_;
    }
    clear_has_task();
  }
}
inline ::greptime::v1::meta::DropTableTask* DdlTaskRequest::release_drop_table_task() {
  // @@protoc_insertion_point(field_release:greptime.v1.meta.DdlTaskRequest.drop_table_task)
  if (_internal_has_drop_table_task()) {
    clear_has_task();
    ::greptime::v1::meta::DropTableTask* temp = _impl_.task_.drop_table_task_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.task_.drop_table_task_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::greptime::v1::meta::DropTableTask& DdlTaskRequest::_internal_drop_table_task() const {
  return _internal_has_drop_table_task()
      ? *_impl_.task_.drop_table_task_
      : reinterpret_cast< ::greptime::v1::meta::DropTableTask&>(::greptime::v1::meta::_DropTableTask_default_instance_);
}
inline const ::greptime::v1::meta::DropTableTask& DdlTaskRequest::drop_table_task() const {
  // @@protoc_insertion_point(field_get:greptime.v1.meta.DdlTaskRequest.drop_table_task)
  return _internal_drop_table_task();
}
inline ::greptime::v1::meta::DropTableTask* DdlTaskRequest::unsafe_arena_release_drop_table_task() {
  // @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.meta.DdlTaskRequest.drop_table_task)
  if (_internal_has_drop_table_task()) {
    clear_has_task();
    ::greptime::v1::meta::DropTableTask* temp = _impl_.task_.drop_table_task_;
    _impl_.task_.drop_table_task_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DdlTaskRequest::unsafe_arena_set_allocated_drop_table_task(::greptime::v1::meta::DropTableTask* drop_table_task) {
  clear_task();
  if (drop_table_task) {
    set_has_drop_table_task();
    _impl_.task_.drop_table_task_ = drop_table_task;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.meta.DdlTaskRequest.drop_table_task)
}
inline ::greptime::v1::meta::DropTableTask* DdlTaskRequest::_internal_mutable_drop_table_task() {
  if (!_internal_has_drop_table_task()) {
    clear_task();
    set_has_drop_table_task();
    _impl_.task_.drop_table_task_ = CreateMaybeMessage< ::greptime::v1::meta::DropTableTask >(GetArenaForAllocation());
  }
  return _impl_.task_.drop_table_task_;
}
inline ::greptime::v1::meta::DropTableTask* DdlTaskRequest::mutable_drop_table_task() {
  ::greptime::v1::meta::DropTableTask* _msg = _internal_mutable_drop_table_task();
  // @@protoc_insertion_point(field_mutable:greptime.v1.meta.DdlTaskRequest.drop_table_task)
  return _msg;
}

// .greptime.v1.meta.AlterTableTask alter_table_task = 4;
inline bool DdlTaskRequest::_internal_has_alter_table_task() const {
  return task_case() == kAlterTableTask;
}
inline bool DdlTaskRequest::has_alter_table_task() const {
  return _internal_has_alter_table_task();
}
inline void DdlTaskRequest::set_has_alter_table_task() {
  _impl_._oneof_case_[0] = kAlterTableTask;
}
inline void DdlTaskRequest::clear_alter_table_task() {
  if (_internal_has_alter_table_task()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.task_.alter_table_task_;
    }
    clear_has_task();
  }
}
inline ::greptime::v1::meta::AlterTableTask* DdlTaskRequest::release_alter_table_task() {
  // @@protoc_insertion_point(field_release:greptime.v1.meta.DdlTaskRequest.alter_table_task)
  if (_internal_has_alter_table_task()) {
    clear_has_task();
    ::greptime::v1::meta::AlterTableTask* temp = _impl_.task_.alter_table_task_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.task_.alter_table_task_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::greptime::v1::meta::AlterTableTask& DdlTaskRequest::_internal_alter_table_task() const {
  return _internal_has_alter_table_task()
      ? *_impl_.task_.alter_table_task_
      : reinterpret_cast< ::greptime::v1::meta::AlterTableTask&>(::greptime::v1::meta::_AlterTableTask_default_instance_);
}
inline const ::greptime::v1::meta::AlterTableTask& DdlTaskRequest::alter_table_task() const {
  // @@protoc_insertion_point(field_get:greptime.v1.meta.DdlTaskRequest.alter_table_task)
  return _internal_alter_table_task();
}
inline ::greptime::v1::meta::AlterTableTask* DdlTaskRequest::unsafe_arena_release_alter_table_task() {
  // @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.meta.DdlTaskRequest.alter_table_task)
  if (_internal_has_alter_table_task()) {
    clear_has_task();
    ::greptime::v1::meta::AlterTableTask* temp = _impl_.task_.alter_table_task_;
    _impl_.task_.alter_table_task_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DdlTaskRequest::unsafe_arena_set_allocated_alter_table_task(::greptime::v1::meta::AlterTableTask* alter_table_task) {
  clear_task();
  if (alter_table_task) {
    set_has_alter_table_task();
    _impl_.task_.alter_table_task_ = alter_table_task;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.meta.DdlTaskRequest.alter_table_task)
}
inline ::greptime::v1::meta::AlterTableTask* DdlTaskRequest::_internal_mutable_alter_table_task() {
  if (!_internal_has_alter_table_task()) {
    clear_task();
    set_has_alter_table_task();
    _impl_.task_.alter_table_task_ = CreateMaybeMessage< ::greptime::v1::meta::AlterTableTask >(GetArenaForAllocation());
  }
  return _impl_.task_.alter_table_task_;
}
inline ::greptime::v1::meta::AlterTableTask* DdlTaskRequest::mutable_alter_table_task() {
  ::greptime::v1::meta::AlterTableTask* _msg = _internal_mutable_alter_table_task();
  // @@protoc_insertion_point(field_mutable:greptime.v1.meta.DdlTaskRequest.alter_table_task)
  return _msg;
}

// .greptime.v1.meta.TruncateTableTask truncate_table_task = 5;
inline bool DdlTaskRequest::_internal_has_truncate_table_task() const {
  return task_case() == kTruncateTableTask;
}
inline bool DdlTaskRequest::has_truncate_table_task() const {
  return _internal_has_truncate_table_task();
}
inline void DdlTaskRequest::set_has_truncate_table_task() {
  _impl_._oneof_case_[0] = kTruncateTableTask;
}
inline void DdlTaskRequest::clear_truncate_table_task() {
  if (_internal_has_truncate_table_task()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.task_.truncate_table_task_;
    }
    clear_has_task();
  }
}
inline ::greptime::v1::meta::TruncateTableTask* DdlTaskRequest::release_truncate_table_task() {
  // @@protoc_insertion_point(field_release:greptime.v1.meta.DdlTaskRequest.truncate_table_task)
  if (_internal_has_truncate_table_task()) {
    clear_has_task();
    ::greptime::v1::meta::TruncateTableTask* temp = _impl_.task_.truncate_table_task_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.task_.truncate_table_task_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::greptime::v1::meta::TruncateTableTask& DdlTaskRequest::_internal_truncate_table_task() const {
  return _internal_has_truncate_table_task()
      ? *_impl_.task_.truncate_table_task_
      : reinterpret_cast< ::greptime::v1::meta::TruncateTableTask&>(::greptime::v1::meta::_TruncateTableTask_default_instance_);
}
inline const ::greptime::v1::meta::TruncateTableTask& DdlTaskRequest::truncate_table_task() const {
  // @@protoc_insertion_point(field_get:greptime.v1.meta.DdlTaskRequest.truncate_table_task)
  return _internal_truncate_table_task();
}
inline ::greptime::v1::meta::TruncateTableTask* DdlTaskRequest::unsafe_arena_release_truncate_table_task() {
  // @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.meta.DdlTaskRequest.truncate_table_task)
  if (_internal_has_truncate_table_task()) {
    clear_has_task();
    ::greptime::v1::meta::TruncateTableTask* temp = _impl_.task_.truncate_table_task_;
    _impl_.task_.truncate_table_task_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DdlTaskRequest::unsafe_arena_set_allocated_truncate_table_task(::greptime::v1::meta::TruncateTableTask* truncate_table_task) {
  clear_task();
  if (truncate_table_task) {
    set_has_truncate_table_task();
    _impl_.task_.truncate_table_task_ = truncate_table_task;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.meta.DdlTaskRequest.truncate_table_task)
}
inline ::greptime::v1::meta::TruncateTableTask* DdlTaskRequest::_internal_mutable_truncate_table_task() {
  if (!_internal_has_truncate_table_task()) {
    clear_task();
    set_has_truncate_table_task();
    _impl_.task_.truncate_table_task_ = CreateMaybeMessage< ::greptime::v1::meta::TruncateTableTask >(GetArenaForAllocation());
  }
  return _impl_.task_.truncate_table_task_;
}
inline ::greptime::v1::meta::TruncateTableTask* DdlTaskRequest::mutable_truncate_table_task() {
  ::greptime::v1::meta::TruncateTableTask* _msg = _internal_mutable_truncate_table_task();
  // @@protoc_insertion_point(field_mutable:greptime.v1.meta.DdlTaskRequest.truncate_table_task)
  return _msg;
}

// .greptime.v1.meta.CreateTableTasks create_table_tasks = 6;
inline bool DdlTaskRequest::_internal_has_create_table_tasks() const {
  return task_case() == kCreateTableTasks;
}
inline bool DdlTaskRequest::has_create_table_tasks() const {
  return _internal_has_create_table_tasks();
}
inline void DdlTaskRequest::set_has_create_table_tasks() {
  _impl_._oneof_case_[0] = kCreateTableTasks;
}
inline void DdlTaskRequest::clear_create_table_tasks() {
  if (_internal_has_create_table_tasks()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.task_.create_table_tasks_;
    }
    clear_has_task();
  }
}
inline ::greptime::v1::meta::CreateTableTasks* DdlTaskRequest::release_create_table_tasks() {
  // @@protoc_insertion_point(field_release:greptime.v1.meta.DdlTaskRequest.create_table_tasks)
  if (_internal_has_create_table_tasks()) {
    clear_has_task();
    ::greptime::v1::meta::CreateTableTasks* temp = _impl_.task_.create_table_tasks_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.task_.create_table_tasks_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::greptime::v1::meta::CreateTableTasks& DdlTaskRequest::_internal_create_table_tasks() const {
  return _internal_has_create_table_tasks()
      ? *_impl_.task_.create_table_tasks_
      : reinterpret_cast< ::greptime::v1::meta::CreateTableTasks&>(::greptime::v1::meta::_CreateTableTasks_default_instance_);
}
inline const ::greptime::v1::meta::CreateTableTasks& DdlTaskRequest::create_table_tasks() const {
  // @@protoc_insertion_point(field_get:greptime.v1.meta.DdlTaskRequest.create_table_tasks)
  return _internal_create_table_tasks();
}
inline ::greptime::v1::meta::CreateTableTasks* DdlTaskRequest::unsafe_arena_release_create_table_tasks() {
  // @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.meta.DdlTaskRequest.create_table_tasks)
  if (_internal_has_create_table_tasks()) {
    clear_has_task();
    ::greptime::v1::meta::CreateTableTasks* temp = _impl_.task_.create_table_tasks_;
    _impl_.task_.create_table_tasks_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DdlTaskRequest::unsafe_arena_set_allocated_create_table_tasks(::greptime::v1::meta::CreateTableTasks* create_table_tasks) {
  clear_task();
  if (create_table_tasks) {
    set_has_create_table_tasks();
    _impl_.task_.create_table_tasks_ = create_table_tasks;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.meta.DdlTaskRequest.create_table_tasks)
}
inline ::greptime::v1::meta::CreateTableTasks* DdlTaskRequest::_internal_mutable_create_table_tasks() {
  if (!_internal_has_create_table_tasks()) {
    clear_task();
    set_has_create_table_tasks();
    _impl_.task_.create_table_tasks_ = CreateMaybeMessage< ::greptime::v1::meta::CreateTableTasks >(GetArenaForAllocation());
  }
  return _impl_.task_.create_table_tasks_;
}
inline ::greptime::v1::meta::CreateTableTasks* DdlTaskRequest::mutable_create_table_tasks() {
  ::greptime::v1::meta::CreateTableTasks* _msg = _internal_mutable_create_table_tasks();
  // @@protoc_insertion_point(field_mutable:greptime.v1.meta.DdlTaskRequest.create_table_tasks)
  return _msg;
}

// .greptime.v1.meta.DropTableTasks drop_table_tasks = 7;
inline bool DdlTaskRequest::_internal_has_drop_table_tasks() const {
  return task_case() == kDropTableTasks;
}
inline bool DdlTaskRequest::has_drop_table_tasks() const {
  return _internal_has_drop_table_tasks();
}
inline void DdlTaskRequest::set_has_drop_table_tasks() {
  _impl_._oneof_case_[0] = kDropTableTasks;
}
inline void DdlTaskRequest::clear_drop_table_tasks() {
  if (_internal_has_drop_table_tasks()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.task_.drop_table_tasks_;
    }
    clear_has_task();
  }
}
inline ::greptime::v1::meta::DropTableTasks* DdlTaskRequest::release_drop_table_tasks() {
  // @@protoc_insertion_point(field_release:greptime.v1.meta.DdlTaskRequest.drop_table_tasks)
  if (_internal_has_drop_table_tasks()) {
    clear_has_task();
    ::greptime::v1::meta::DropTableTasks* temp = _impl_.task_.drop_table_tasks_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.task_.drop_table_tasks_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::greptime::v1::meta::DropTableTasks& DdlTaskRequest::_internal_drop_table_tasks() const {
  return _internal_has_drop_table_tasks()
      ? *_impl_.task_.drop_table_tasks_
      : reinterpret_cast< ::greptime::v1::meta::DropTableTasks&>(::greptime::v1::meta::_DropTableTasks_default_instance_);
}
inline const ::greptime::v1::meta::DropTableTasks& DdlTaskRequest::drop_table_tasks() const {
  // @@protoc_insertion_point(field_get:greptime.v1.meta.DdlTaskRequest.drop_table_tasks)
  return _internal_drop_table_tasks();
}
inline ::greptime::v1::meta::DropTableTasks* DdlTaskRequest::unsafe_arena_release_drop_table_tasks() {
  // @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.meta.DdlTaskRequest.drop_table_tasks)
  if (_internal_has_drop_table_tasks()) {
    clear_has_task();
    ::greptime::v1::meta::DropTableTasks* temp = _impl_.task_.drop_table_tasks_;
    _impl_.task_.drop_table_tasks_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DdlTaskRequest::unsafe_arena_set_allocated_drop_table_tasks(::greptime::v1::meta::DropTableTasks* drop_table_tasks) {
  clear_task();
  if (drop_table_tasks) {
    set_has_drop_table_tasks();
    _impl_.task_.drop_table_tasks_ = drop_table_tasks;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.meta.DdlTaskRequest.drop_table_tasks)
}
inline ::greptime::v1::meta::DropTableTasks* DdlTaskRequest::_internal_mutable_drop_table_tasks() {
  if (!_internal_has_drop_table_tasks()) {
    clear_task();
    set_has_drop_table_tasks();
    _impl_.task_.drop_table_tasks_ = CreateMaybeMessage< ::greptime::v1::meta::DropTableTasks >(GetArenaForAllocation());
  }
  return _impl_.task_.drop_table_tasks_;
}
inline ::greptime::v1::meta::DropTableTasks* DdlTaskRequest::mutable_drop_table_tasks() {
  ::greptime::v1::meta::DropTableTasks* _msg = _internal_mutable_drop_table_tasks();
  // @@protoc_insertion_point(field_mutable:greptime.v1.meta.DdlTaskRequest.drop_table_tasks)
  return _msg;
}

// .greptime.v1.meta.AlterTableTasks alter_table_tasks = 8;
inline bool DdlTaskRequest::_internal_has_alter_table_tasks() const {
  return task_case() == kAlterTableTasks;
}
inline bool DdlTaskRequest::has_alter_table_tasks() const {
  return _internal_has_alter_table_tasks();
}
inline void DdlTaskRequest::set_has_alter_table_tasks() {
  _impl_._oneof_case_[0] = kAlterTableTasks;
}
inline void DdlTaskRequest::clear_alter_table_tasks() {
  if (_internal_has_alter_table_tasks()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.task_.alter_table_tasks_;
    }
    clear_has_task();
  }
}
inline ::greptime::v1::meta::AlterTableTasks* DdlTaskRequest::release_alter_table_tasks() {
  // @@protoc_insertion_point(field_release:greptime.v1.meta.DdlTaskRequest.alter_table_tasks)
  if (_internal_has_alter_table_tasks()) {
    clear_has_task();
    ::greptime::v1::meta::AlterTableTasks* temp = _impl_.task_.alter_table_tasks_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.task_.alter_table_tasks_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::greptime::v1::meta::AlterTableTasks& DdlTaskRequest::_internal_alter_table_tasks() const {
  return _internal_has_alter_table_tasks()
      ? *_impl_.task_.alter_table_tasks_
      : reinterpret_cast< ::greptime::v1::meta::AlterTableTasks&>(::greptime::v1::meta::_AlterTableTasks_default_instance_);
}
inline const ::greptime::v1::meta::AlterTableTasks& DdlTaskRequest::alter_table_tasks() const {
  // @@protoc_insertion_point(field_get:greptime.v1.meta.DdlTaskRequest.alter_table_tasks)
  return _internal_alter_table_tasks();
}
inline ::greptime::v1::meta::AlterTableTasks* DdlTaskRequest::unsafe_arena_release_alter_table_tasks() {
  // @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.meta.DdlTaskRequest.alter_table_tasks)
  if (_internal_has_alter_table_tasks()) {
    clear_has_task();
    ::greptime::v1::meta::AlterTableTasks* temp = _impl_.task_.alter_table_tasks_;
    _impl_.task_.alter_table_tasks_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DdlTaskRequest::unsafe_arena_set_allocated_alter_table_tasks(::greptime::v1::meta::AlterTableTasks* alter_table_tasks) {
  clear_task();
  if (alter_table_tasks) {
    set_has_alter_table_tasks();
    _impl_.task_.alter_table_tasks_ = alter_table_tasks;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.meta.DdlTaskRequest.alter_table_tasks)
}
inline ::greptime::v1::meta::AlterTableTasks* DdlTaskRequest::_internal_mutable_alter_table_tasks() {
  if (!_internal_has_alter_table_tasks()) {
    clear_task();
    set_has_alter_table_tasks();
    _impl_.task_.alter_table_tasks_ = CreateMaybeMessage< ::greptime::v1::meta::AlterTableTasks >(GetArenaForAllocation());
  }
  return _impl_.task_.alter_table_tasks_;
}
inline ::greptime::v1::meta::AlterTableTasks* DdlTaskRequest::mutable_alter_table_tasks() {
  ::greptime::v1::meta::AlterTableTasks* _msg = _internal_mutable_alter_table_tasks();
  // @@protoc_insertion_point(field_mutable:greptime.v1.meta.DdlTaskRequest.alter_table_tasks)
  return _msg;
}

// .greptime.v1.meta.DropDatabaseTask drop_database_task = 9;
inline bool DdlTaskRequest::_internal_has_drop_database_task() const {
  return task_case() == kDropDatabaseTask;
}
inline bool DdlTaskRequest::has_drop_database_task() const {
  return _internal_has_drop_database_task();
}
inline void DdlTaskRequest::set_has_drop_database_task() {
  _impl_._oneof_case_[0] = kDropDatabaseTask;
}
inline void DdlTaskRequest::clear_drop_database_task() {
  if (_internal_has_drop_database_task()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.task_.drop_database_task_;
    }
    clear_has_task();
  }
}
inline ::greptime::v1::meta::DropDatabaseTask* DdlTaskRequest::release_drop_database_task() {
  // @@protoc_insertion_point(field_release:greptime.v1.meta.DdlTaskRequest.drop_database_task)
  if (_internal_has_drop_database_task()) {
    clear_has_task();
    ::greptime::v1::meta::DropDatabaseTask* temp = _impl_.task_.drop_database_task_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.task_.drop_database_task_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::greptime::v1::meta::DropDatabaseTask& DdlTaskRequest::_internal_drop_database_task() const {
  return _internal_has_drop_database_task()
      ? *_impl_.task_.drop_database_task_
      : reinterpret_cast< ::greptime::v1::meta::DropDatabaseTask&>(::greptime::v1::meta::_DropDatabaseTask_default_instance_);
}
inline const ::greptime::v1::meta::DropDatabaseTask& DdlTaskRequest::drop_database_task() const {
  // @@protoc_insertion_point(field_get:greptime.v1.meta.DdlTaskRequest.drop_database_task)
  return _internal_drop_database_task();
}
inline ::greptime::v1::meta::DropDatabaseTask* DdlTaskRequest::unsafe_arena_release_drop_database_task() {
  // @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.meta.DdlTaskRequest.drop_database_task)
  if (_internal_has_drop_database_task()) {
    clear_has_task();
    ::greptime::v1::meta::DropDatabaseTask* temp = _impl_.task_.drop_database_task_;
    _impl_.task_.drop_database_task_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DdlTaskRequest::unsafe_arena_set_allocated_drop_database_task(::greptime::v1::meta::DropDatabaseTask* drop_database_task) {
  clear_task();
  if (drop_database_task) {
    set_has_drop_database_task();
    _impl_.task_.drop_database_task_ = drop_database_task;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.meta.DdlTaskRequest.drop_database_task)
}
inline ::greptime::v1::meta::DropDatabaseTask* DdlTaskRequest::_internal_mutable_drop_database_task() {
  if (!_internal_has_drop_database_task()) {
    clear_task();
    set_has_drop_database_task();
    _impl_.task_.drop_database_task_ = CreateMaybeMessage< ::greptime::v1::meta::DropDatabaseTask >(GetArenaForAllocation());
  }
  return _impl_.task_.drop_database_task_;
}
inline ::greptime::v1::meta::DropDatabaseTask* DdlTaskRequest::mutable_drop_database_task() {
  ::greptime::v1::meta::DropDatabaseTask* _msg = _internal_mutable_drop_database_task();
  // @@protoc_insertion_point(field_mutable:greptime.v1.meta.DdlTaskRequest.drop_database_task)
  return _msg;
}

// .greptime.v1.meta.CreateDatabaseTask create_database_task = 10;
inline bool DdlTaskRequest::_internal_has_create_database_task() const {
  return task_case() == kCreateDatabaseTask;
}
inline bool DdlTaskRequest::has_create_database_task() const {
  return _internal_has_create_database_task();
}
inline void DdlTaskRequest::set_has_create_database_task() {
  _impl_._oneof_case_[0] = kCreateDatabaseTask;
}
inline void DdlTaskRequest::clear_create_database_task() {
  if (_internal_has_create_database_task()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.task_.create_database_task_;
    }
    clear_has_task();
  }
}
inline ::greptime::v1::meta::CreateDatabaseTask* DdlTaskRequest::release_create_database_task() {
  // @@protoc_insertion_point(field_release:greptime.v1.meta.DdlTaskRequest.create_database_task)
  if (_internal_has_create_database_task()) {
    clear_has_task();
    ::greptime::v1::meta::CreateDatabaseTask* temp = _impl_.task_.create_database_task_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.task_.create_database_task_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::greptime::v1::meta::CreateDatabaseTask& DdlTaskRequest::_internal_create_database_task() const {
  return _internal_has_create_database_task()
      ? *_impl_.task_.create_database_task_
      : reinterpret_cast< ::greptime::v1::meta::CreateDatabaseTask&>(::greptime::v1::meta::_CreateDatabaseTask_default_instance_);
}
inline const ::greptime::v1::meta::CreateDatabaseTask& DdlTaskRequest::create_database_task() const {
  // @@protoc_insertion_point(field_get:greptime.v1.meta.DdlTaskRequest.create_database_task)
  return _internal_create_database_task();
}
inline ::greptime::v1::meta::CreateDatabaseTask* DdlTaskRequest::unsafe_arena_release_create_database_task() {
  // @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.meta.DdlTaskRequest.create_database_task)
  if (_internal_has_create_database_task()) {
    clear_has_task();
    ::greptime::v1::meta::CreateDatabaseTask* temp = _impl_.task_.create_database_task_;
    _impl_.task_.create_database_task_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DdlTaskRequest::unsafe_arena_set_allocated_create_database_task(::greptime::v1::meta::CreateDatabaseTask* create_database_task) {
  clear_task();
  if (create_database_task) {
    set_has_create_database_task();
    _impl_.task_.create_database_task_ = create_database_task;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.meta.DdlTaskRequest.create_database_task)
}
inline ::greptime::v1::meta::CreateDatabaseTask* DdlTaskRequest::_internal_mutable_create_database_task() {
  if (!_internal_has_create_database_task()) {
    clear_task();
    set_has_create_database_task();
    _impl_.task_.create_database_task_ = CreateMaybeMessage< ::greptime::v1::meta::CreateDatabaseTask >(GetArenaForAllocation());
  }
  return _impl_.task_.create_database_task_;
}
inline ::greptime::v1::meta::CreateDatabaseTask* DdlTaskRequest::mutable_create_database_task() {
  ::greptime::v1::meta::CreateDatabaseTask* _msg = _internal_mutable_create_database_task();
  // @@protoc_insertion_point(field_mutable:greptime.v1.meta.DdlTaskRequest.create_database_task)
  return _msg;
}

// .greptime.v1.meta.CreateFlowTask create_flow_task = 11;
inline bool DdlTaskRequest::_internal_has_create_flow_task() const {
  return task_case() == kCreateFlowTask;
}
inline bool DdlTaskRequest::has_create_flow_task() const {
  return _internal_has_create_flow_task();
}
inline void DdlTaskRequest::set_has_create_flow_task() {
  _impl_._oneof_case_[0] = kCreateFlowTask;
}
inline void DdlTaskRequest::clear_create_flow_task() {
  if (_internal_has_create_flow_task()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.task_.create_flow_task_;
    }
    clear_has_task();
  }
}
inline ::greptime::v1::meta::CreateFlowTask* DdlTaskRequest::release_create_flow_task() {
  // @@protoc_insertion_point(field_release:greptime.v1.meta.DdlTaskRequest.create_flow_task)
  if (_internal_has_create_flow_task()) {
    clear_has_task();
    ::greptime::v1::meta::CreateFlowTask* temp = _impl_.task_.create_flow_task_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.task_.create_flow_task_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::greptime::v1::meta::CreateFlowTask& DdlTaskRequest::_internal_create_flow_task() const {
  return _internal_has_create_flow_task()
      ? *_impl_.task_.create_flow_task_
      : reinterpret_cast< ::greptime::v1::meta::CreateFlowTask&>(::greptime::v1::meta::_CreateFlowTask_default_instance_);
}
inline const ::greptime::v1::meta::CreateFlowTask& DdlTaskRequest::create_flow_task() const {
  // @@protoc_insertion_point(field_get:greptime.v1.meta.DdlTaskRequest.create_flow_task)
  return _internal_create_flow_task();
}
inline ::greptime::v1::meta::CreateFlowTask* DdlTaskRequest::unsafe_arena_release_create_flow_task() {
  // @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.meta.DdlTaskRequest.create_flow_task)
  if (_internal_has_create_flow_task()) {
    clear_has_task();
    ::greptime::v1::meta::CreateFlowTask* temp = _impl_.task_.create_flow_task_;
    _impl_.task_.create_flow_task_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DdlTaskRequest::unsafe_arena_set_allocated_create_flow_task(::greptime::v1::meta::CreateFlowTask* create_flow_task) {
  clear_task();
  if (create_flow_task) {
    set_has_create_flow_task();
    _impl_.task_.create_flow_task_ = create_flow_task;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.meta.DdlTaskRequest.create_flow_task)
}
inline ::greptime::v1::meta::CreateFlowTask* DdlTaskRequest::_internal_mutable_create_flow_task() {
  if (!_internal_has_create_flow_task()) {
    clear_task();
    set_has_create_flow_task();
    _impl_.task_.create_flow_task_ = CreateMaybeMessage< ::greptime::v1::meta::CreateFlowTask >(GetArenaForAllocation());
  }
  return _impl_.task_.create_flow_task_;
}
inline ::greptime::v1::meta::CreateFlowTask* DdlTaskRequest::mutable_create_flow_task() {
  ::greptime::v1::meta::CreateFlowTask* _msg = _internal_mutable_create_flow_task();
  // @@protoc_insertion_point(field_mutable:greptime.v1.meta.DdlTaskRequest.create_flow_task)
  return _msg;
}

// .greptime.v1.meta.DropFlowTask drop_flow_task = 12;
inline bool DdlTaskRequest::_internal_has_drop_flow_task() const {
  return task_case() == kDropFlowTask;
}
inline bool DdlTaskRequest::has_drop_flow_task() const {
  return _internal_has_drop_flow_task();
}
inline void DdlTaskRequest::set_has_drop_flow_task() {
  _impl_._oneof_case_[0] = kDropFlowTask;
}
inline void DdlTaskRequest::clear_drop_flow_task() {
  if (_internal_has_drop_flow_task()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.task_.drop_flow_task_;
    }
    clear_has_task();
  }
}
inline ::greptime::v1::meta::DropFlowTask* DdlTaskRequest::release_drop_flow_task() {
  // @@protoc_insertion_point(field_release:greptime.v1.meta.DdlTaskRequest.drop_flow_task)
  if (_internal_has_drop_flow_task()) {
    clear_has_task();
    ::greptime::v1::meta::DropFlowTask* temp = _impl_.task_.drop_flow_task_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.task_.drop_flow_task_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::greptime::v1::meta::DropFlowTask& DdlTaskRequest::_internal_drop_flow_task() const {
  return _internal_has_drop_flow_task()
      ? *_impl_.task_.drop_flow_task_
      : reinterpret_cast< ::greptime::v1::meta::DropFlowTask&>(::greptime::v1::meta::_DropFlowTask_default_instance_);
}
inline const ::greptime::v1::meta::DropFlowTask& DdlTaskRequest::drop_flow_task() const {
  // @@protoc_insertion_point(field_get:greptime.v1.meta.DdlTaskRequest.drop_flow_task)
  return _internal_drop_flow_task();
}
inline ::greptime::v1::meta::DropFlowTask* DdlTaskRequest::unsafe_arena_release_drop_flow_task() {
  // @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.meta.DdlTaskRequest.drop_flow_task)
  if (_internal_has_drop_flow_task()) {
    clear_has_task();
    ::greptime::v1::meta::DropFlowTask* temp = _impl_.task_.drop_flow_task_;
    _impl_.task_.drop_flow_task_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DdlTaskRequest::unsafe_arena_set_allocated_drop_flow_task(::greptime::v1::meta::DropFlowTask* drop_flow_task) {
  clear_task();
  if (drop_flow_task) {
    set_has_drop_flow_task();
    _impl_.task_.drop_flow_task_ = drop_flow_task;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.meta.DdlTaskRequest.drop_flow_task)
}
inline ::greptime::v1::meta::DropFlowTask* DdlTaskRequest::_internal_mutable_drop_flow_task() {
  if (!_internal_has_drop_flow_task()) {
    clear_task();
    set_has_drop_flow_task();
    _impl_.task_.drop_flow_task_ = CreateMaybeMessage< ::greptime::v1::meta::DropFlowTask >(GetArenaForAllocation());
  }
  return _impl_.task_.drop_flow_task_;
}
inline ::greptime::v1::meta::DropFlowTask* DdlTaskRequest::mutable_drop_flow_task() {
  ::greptime::v1::meta::DropFlowTask* _msg = _internal_mutable_drop_flow_task();
  // @@protoc_insertion_point(field_mutable:greptime.v1.meta.DdlTaskRequest.drop_flow_task)
  return _msg;
}

// .greptime.v1.meta.CreateViewTask create_view_task = 13;
inline bool DdlTaskRequest::_internal_has_create_view_task() const {
  return task_case() == kCreateViewTask;
}
inline bool DdlTaskRequest::has_create_view_task() const {
  return _internal_has_create_view_task();
}
inline void DdlTaskRequest::set_has_create_view_task() {
  _impl_._oneof_case_[0] = kCreateViewTask;
}
inline void DdlTaskRequest::clear_create_view_task() {
  if (_internal_has_create_view_task()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.task_.create_view_task_;
    }
    clear_has_task();
  }
}
inline ::greptime::v1::meta::CreateViewTask* DdlTaskRequest::release_create_view_task() {
  // @@protoc_insertion_point(field_release:greptime.v1.meta.DdlTaskRequest.create_view_task)
  if (_internal_has_create_view_task()) {
    clear_has_task();
    ::greptime::v1::meta::CreateViewTask* temp = _impl_.task_.create_view_task_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.task_.create_view_task_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::greptime::v1::meta::CreateViewTask& DdlTaskRequest::_internal_create_view_task() const {
  return _internal_has_create_view_task()
      ? *_impl_.task_.create_view_task_
      : reinterpret_cast< ::greptime::v1::meta::CreateViewTask&>(::greptime::v1::meta::_CreateViewTask_default_instance_);
}
inline const ::greptime::v1::meta::CreateViewTask& DdlTaskRequest::create_view_task() const {
  // @@protoc_insertion_point(field_get:greptime.v1.meta.DdlTaskRequest.create_view_task)
  return _internal_create_view_task();
}
inline ::greptime::v1::meta::CreateViewTask* DdlTaskRequest::unsafe_arena_release_create_view_task() {
  // @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.meta.DdlTaskRequest.create_view_task)
  if (_internal_has_create_view_task()) {
    clear_has_task();
    ::greptime::v1::meta::CreateViewTask* temp = _impl_.task_.create_view_task_;
    _impl_.task_.create_view_task_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DdlTaskRequest::unsafe_arena_set_allocated_create_view_task(::greptime::v1::meta::CreateViewTask* create_view_task) {
  clear_task();
  if (create_view_task) {
    set_has_create_view_task();
    _impl_.task_.create_view_task_ = create_view_task;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.meta.DdlTaskRequest.create_view_task)
}
inline ::greptime::v1::meta::CreateViewTask* DdlTaskRequest::_internal_mutable_create_view_task() {
  if (!_internal_has_create_view_task()) {
    clear_task();
    set_has_create_view_task();
    _impl_.task_.create_view_task_ = CreateMaybeMessage< ::greptime::v1::meta::CreateViewTask >(GetArenaForAllocation());
  }
  return _impl_.task_.create_view_task_;
}
inline ::greptime::v1::meta::CreateViewTask* DdlTaskRequest::mutable_create_view_task() {
  ::greptime::v1::meta::CreateViewTask* _msg = _internal_mutable_create_view_task();
  // @@protoc_insertion_point(field_mutable:greptime.v1.meta.DdlTaskRequest.create_view_task)
  return _msg;
}

// .greptime.v1.meta.DropViewTask drop_view_task = 14;
inline bool DdlTaskRequest::_internal_has_drop_view_task() const {
  return task_case() == kDropViewTask;
}
inline bool DdlTaskRequest::has_drop_view_task() const {
  return _internal_has_drop_view_task();
}
inline void DdlTaskRequest::set_has_drop_view_task() {
  _impl_._oneof_case_[0] = kDropViewTask;
}
inline void DdlTaskRequest::clear_drop_view_task() {
  if (_internal_has_drop_view_task()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.task_.drop_view_task_;
    }
    clear_has_task();
  }
}
inline ::greptime::v1::meta::DropViewTask* DdlTaskRequest::release_drop_view_task() {
  // @@protoc_insertion_point(field_release:greptime.v1.meta.DdlTaskRequest.drop_view_task)
  if (_internal_has_drop_view_task()) {
    clear_has_task();
    ::greptime::v1::meta::DropViewTask* temp = _impl_.task_.drop_view_task_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.task_.drop_view_task_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::greptime::v1::meta::DropViewTask& DdlTaskRequest::_internal_drop_view_task() const {
  return _internal_has_drop_view_task()
      ? *_impl_.task_.drop_view_task_
      : reinterpret_cast< ::greptime::v1::meta::DropViewTask&>(::greptime::v1::meta::_DropViewTask_default_instance_);
}
inline const ::greptime::v1::meta::DropViewTask& DdlTaskRequest::drop_view_task() const {
  // @@protoc_insertion_point(field_get:greptime.v1.meta.DdlTaskRequest.drop_view_task)
  return _internal_drop_view_task();
}
inline ::greptime::v1::meta::DropViewTask* DdlTaskRequest::unsafe_arena_release_drop_view_task() {
  // @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.meta.DdlTaskRequest.drop_view_task)
  if (_internal_has_drop_view_task()) {
    clear_has_task();
    ::greptime::v1::meta::DropViewTask* temp = _impl_.task_.drop_view_task_;
    _impl_.task_.drop_view_task_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DdlTaskRequest::unsafe_arena_set_allocated_drop_view_task(::greptime::v1::meta::DropViewTask* drop_view_task) {
  clear_task();
  if (drop_view_task) {
    set_has_drop_view_task();
    _impl_.task_.drop_view_task_ = drop_view_task;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.meta.DdlTaskRequest.drop_view_task)
}
inline ::greptime::v1::meta::DropViewTask* DdlTaskRequest::_internal_mutable_drop_view_task() {
  if (!_internal_has_drop_view_task()) {
    clear_task();
    set_has_drop_view_task();
    _impl_.task_.drop_view_task_ = CreateMaybeMessage< ::greptime::v1::meta::DropViewTask >(GetArenaForAllocation());
  }
  return _impl_.task_.drop_view_task_;
}
inline ::greptime::v1::meta::DropViewTask* DdlTaskRequest::mutable_drop_view_task() {
  ::greptime::v1::meta::DropViewTask* _msg = _internal_mutable_drop_view_task();
  // @@protoc_insertion_point(field_mutable:greptime.v1.meta.DdlTaskRequest.drop_view_task)
  return _msg;
}

// .greptime.v1.meta.AlterDatabaseTask alter_database_task = 15;
inline bool DdlTaskRequest::_internal_has_alter_database_task() const {
  return task_case() == kAlterDatabaseTask;
}
inline bool DdlTaskRequest::has_alter_database_task() const {
  return _internal_has_alter_database_task();
}
inline void DdlTaskRequest::set_has_alter_database_task() {
  _impl_._oneof_case_[0] = kAlterDatabaseTask;
}
inline void DdlTaskRequest::clear_alter_database_task() {
  if (_internal_has_alter_database_task()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.task_.alter_database_task_;
    }
    clear_has_task();
  }
}
inline ::greptime::v1::meta::AlterDatabaseTask* DdlTaskRequest::release_alter_database_task() {
  // @@protoc_insertion_point(field_release:greptime.v1.meta.DdlTaskRequest.alter_database_task)
  if (_internal_has_alter_database_task()) {
    clear_has_task();
    ::greptime::v1::meta::AlterDatabaseTask* temp = _impl_.task_.alter_database_task_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.task_.alter_database_task_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::greptime::v1::meta::AlterDatabaseTask& DdlTaskRequest::_internal_alter_database_task() const {
  return _internal_has_alter_database_task()
      ? *_impl_.task_.alter_database_task_
      : reinterpret_cast< ::greptime::v1::meta::AlterDatabaseTask&>(::greptime::v1::meta::_AlterDatabaseTask_default_instance_);
}
inline const ::greptime::v1::meta::AlterDatabaseTask& DdlTaskRequest::alter_database_task() const {
  // @@protoc_insertion_point(field_get:greptime.v1.meta.DdlTaskRequest.alter_database_task)
  return _internal_alter_database_task();
}
inline ::greptime::v1::meta::AlterDatabaseTask* DdlTaskRequest::unsafe_arena_release_alter_database_task() {
  // @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.meta.DdlTaskRequest.alter_database_task)
  if (_internal_has_alter_database_task()) {
    clear_has_task();
    ::greptime::v1::meta::AlterDatabaseTask* temp = _impl_.task_.alter_database_task_;
    _impl_.task_.alter_database_task_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DdlTaskRequest::unsafe_arena_set_allocated_alter_database_task(::greptime::v1::meta::AlterDatabaseTask* alter_database_task) {
  clear_task();
  if (alter_database_task) {
    set_has_alter_database_task();
    _impl_.task_.alter_database_task_ = alter_database_task;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.meta.DdlTaskRequest.alter_database_task)
}
inline ::greptime::v1::meta::AlterDatabaseTask* DdlTaskRequest::_internal_mutable_alter_database_task() {
  if (!_internal_has_alter_database_task()) {
    clear_task();
    set_has_alter_database_task();
    _impl_.task_.alter_database_task_ = CreateMaybeMessage< ::greptime::v1::meta::AlterDatabaseTask >(GetArenaForAllocation());
  }
  return _impl_.task_.alter_database_task_;
}
inline ::greptime::v1::meta::AlterDatabaseTask* DdlTaskRequest::mutable_alter_database_task() {
  ::greptime::v1::meta::AlterDatabaseTask* _msg = _internal_mutable_alter_database_task();
  // @@protoc_insertion_point(field_mutable:greptime.v1.meta.DdlTaskRequest.alter_database_task)
  return _msg;
}

inline bool DdlTaskRequest::has_task() const {
  return task_case() != TASK_NOT_SET;
}
inline void DdlTaskRequest::clear_has_task() {
  _impl_._oneof_case_[0] = TASK_NOT_SET;
}
inline DdlTaskRequest::TaskCase DdlTaskRequest::task_case() const {
  return DdlTaskRequest::TaskCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// DdlTaskResponse

// .greptime.v1.meta.ResponseHeader header = 1;
inline bool DdlTaskResponse::_internal_has_header() const {
  return this != internal_default_instance() && _impl_.header_ != nullptr;
}
inline bool DdlTaskResponse::has_header() const {
  return _internal_has_header();
}
inline const ::greptime::v1::meta::ResponseHeader& DdlTaskResponse::_internal_header() const {
  const ::greptime::v1::meta::ResponseHeader* p = _impl_.header_;
  return p != nullptr ? *p : reinterpret_cast<const ::greptime::v1::meta::ResponseHeader&>(
      ::greptime::v1::meta::_ResponseHeader_default_instance_);
}
inline const ::greptime::v1::meta::ResponseHeader& DdlTaskResponse::header() const {
  // @@protoc_insertion_point(field_get:greptime.v1.meta.DdlTaskResponse.header)
  return _internal_header();
}
inline void DdlTaskResponse::unsafe_arena_set_allocated_header(
    ::greptime::v1::meta::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.meta.DdlTaskResponse.header)
}
inline ::greptime::v1::meta::ResponseHeader* DdlTaskResponse::release_header() {
  
  ::greptime::v1::meta::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::meta::ResponseHeader* DdlTaskResponse::unsafe_arena_release_header() {
  // @@protoc_insertion_point(field_release:greptime.v1.meta.DdlTaskResponse.header)
  
  ::greptime::v1::meta::ResponseHeader* temp = _impl_.header_;
  _impl_.header_ = nullptr;
  return temp;
}
inline ::greptime::v1::meta::ResponseHeader* DdlTaskResponse::_internal_mutable_header() {
  
  if (_impl_.header_ == nullptr) {
    auto* p = CreateMaybeMessage<::greptime::v1::meta::ResponseHeader>(GetArenaForAllocation());
    _impl_.header_ = p;
  }
  return _impl_.header_;
}
inline ::greptime::v1::meta::ResponseHeader* DdlTaskResponse::mutable_header() {
  ::greptime::v1::meta::ResponseHeader* _msg = _internal_mutable_header();
  // @@protoc_insertion_point(field_mutable:greptime.v1.meta.DdlTaskResponse.header)
  return _msg;
}
inline void DdlTaskResponse::set_allocated_header(::greptime::v1::meta::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.meta.DdlTaskResponse.header)
}

// .greptime.v1.meta.ProcedureId pid = 2;
inline bool DdlTaskResponse::_internal_has_pid() const {
  return this != internal_default_instance() && _impl_.pid_ != nullptr;
}
inline bool DdlTaskResponse::has_pid() const {
  return _internal_has_pid();
}
inline const ::greptime::v1::meta::ProcedureId& DdlTaskResponse::_internal_pid() const {
  const ::greptime::v1::meta::ProcedureId* p = _impl_.pid_;
  return p != nullptr ? *p : reinterpret_cast<const ::greptime::v1::meta::ProcedureId&>(
      ::greptime::v1::meta::_ProcedureId_default_instance_);
}
inline const ::greptime::v1::meta::ProcedureId& DdlTaskResponse::pid() const {
  // @@protoc_insertion_point(field_get:greptime.v1.meta.DdlTaskResponse.pid)
  return _internal_pid();
}
inline void DdlTaskResponse::unsafe_arena_set_allocated_pid(
    ::greptime::v1::meta::ProcedureId* pid) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pid_);
  }
  _impl_.pid_ = pid;
  if (pid) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.meta.DdlTaskResponse.pid)
}
inline ::greptime::v1::meta::ProcedureId* DdlTaskResponse::release_pid() {
  
  ::greptime::v1::meta::ProcedureId* temp = _impl_.pid_;
  _impl_.pid_ = 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::meta::ProcedureId* DdlTaskResponse::unsafe_arena_release_pid() {
  // @@protoc_insertion_point(field_release:greptime.v1.meta.DdlTaskResponse.pid)
  
  ::greptime::v1::meta::ProcedureId* temp = _impl_.pid_;
  _impl_.pid_ = nullptr;
  return temp;
}
inline ::greptime::v1::meta::ProcedureId* DdlTaskResponse::_internal_mutable_pid() {
  
  if (_impl_.pid_ == nullptr) {
    auto* p = CreateMaybeMessage<::greptime::v1::meta::ProcedureId>(GetArenaForAllocation());
    _impl_.pid_ = p;
  }
  return _impl_.pid_;
}
inline ::greptime::v1::meta::ProcedureId* DdlTaskResponse::mutable_pid() {
  ::greptime::v1::meta::ProcedureId* _msg = _internal_mutable_pid();
  // @@protoc_insertion_point(field_mutable:greptime.v1.meta.DdlTaskResponse.pid)
  return _msg;
}
inline void DdlTaskResponse::set_allocated_pid(::greptime::v1::meta::ProcedureId* pid) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pid_);
  }
  if (pid) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(pid));
    if (message_arena != submessage_arena) {
      pid = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, pid, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.pid_ = pid;
  // @@protoc_insertion_point(field_set_allocated:greptime.v1.meta.DdlTaskResponse.pid)
}

// repeated .greptime.v1.TableId table_ids = 5;
inline int DdlTaskResponse::_internal_table_ids_size() const {
  return _impl_.table_ids_.size();
}
inline int DdlTaskResponse::table_ids_size() const {
  return _internal_table_ids_size();
}
inline ::greptime::v1::TableId* DdlTaskResponse::mutable_table_ids(int index) {
  // @@protoc_insertion_point(field_mutable:greptime.v1.meta.DdlTaskResponse.table_ids)
  return _impl_.table_ids_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::TableId >*
DdlTaskResponse::mutable_table_ids() {
  // @@protoc_insertion_point(field_mutable_list:greptime.v1.meta.DdlTaskResponse.table_ids)
  return &_impl_.table_ids_;
}
inline const ::greptime::v1::TableId& DdlTaskResponse::_internal_table_ids(int index) const {
  return _impl_.table_ids_.Get(index);
}
inline const ::greptime::v1::TableId& DdlTaskResponse::table_ids(int index) const {
  // @@protoc_insertion_point(field_get:greptime.v1.meta.DdlTaskResponse.table_ids)
  return _internal_table_ids(index);
}
inline ::greptime::v1::TableId* DdlTaskResponse::_internal_add_table_ids() {
  return _impl_.table_ids_.Add();
}
inline ::greptime::v1::TableId* DdlTaskResponse::add_table_ids() {
  ::greptime::v1::TableId* _add = _internal_add_table_ids();
  // @@protoc_insertion_point(field_add:greptime.v1.meta.DdlTaskResponse.table_ids)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::TableId >&
DdlTaskResponse::table_ids() const {
  // @@protoc_insertion_point(field_list:greptime.v1.meta.DdlTaskResponse.table_ids)
  return _impl_.table_ids_;
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace meta
}  // namespace v1
}  // namespace greptime

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::greptime::v1::meta::DdlTaskType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::greptime::v1::meta::DdlTaskType>() {
  return ::greptime::v1::meta::DdlTaskType_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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