contrib/native/client/src/protobuf/UserBitShared.pb.cc

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: UserBitShared.proto

#include "UserBitShared.pb.h"

#include <algorithm>

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/reflection_ops.h>
#include <google/protobuf/wire_format.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
extern PROTOBUF_INTERNAL_EXPORT_Types_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_MajorType_Types_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_Coordination_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_DrillbitEndpoint_Coordination_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_UserBitShared_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_DrillPBError_UserBitShared_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_UserBitShared_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ExceptionWrapper_UserBitShared_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_UserBitShared_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Jar_UserBitShared_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_UserBitShared_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_MajorFragmentProfile_UserBitShared_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_UserBitShared_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_MetricValue_UserBitShared_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_UserBitShared_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_MinorFragmentProfile_UserBitShared_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_UserBitShared_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_NamePart_UserBitShared_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_UserBitShared_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_OperatorProfile_UserBitShared_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_UserBitShared_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ParsingError_UserBitShared_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_UserBitShared_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_QueryId_UserBitShared_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_UserBitShared_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_RecordBatchDef_UserBitShared_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_UserBitShared_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_SerializedField_UserBitShared_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_UserBitShared_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_StackTraceElementWrapper_UserBitShared_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_UserBitShared_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_StreamProfile_UserBitShared_2eproto;
namespace exec {
namespace shared {
class UserCredentialsDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<UserCredentials> _instance;
} _UserCredentials_default_instance_;
class QueryIdDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<QueryId> _instance;
} _QueryId_default_instance_;
class DrillPBErrorDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<DrillPBError> _instance;
} _DrillPBError_default_instance_;
class ExceptionWrapperDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ExceptionWrapper> _instance;
} _ExceptionWrapper_default_instance_;
class StackTraceElementWrapperDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<StackTraceElementWrapper> _instance;
} _StackTraceElementWrapper_default_instance_;
class ParsingErrorDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ParsingError> _instance;
} _ParsingError_default_instance_;
class RecordBatchDefDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RecordBatchDef> _instance;
} _RecordBatchDef_default_instance_;
class NamePartDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<NamePart> _instance;
} _NamePart_default_instance_;
class SerializedFieldDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<SerializedField> _instance;
} _SerializedField_default_instance_;
class NodeStatusDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<NodeStatus> _instance;
} _NodeStatus_default_instance_;
class QueryResultDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<QueryResult> _instance;
} _QueryResult_default_instance_;
class QueryDataDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<QueryData> _instance;
} _QueryData_default_instance_;
class QueryInfoDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<QueryInfo> _instance;
} _QueryInfo_default_instance_;
class QueryProfileDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<QueryProfile> _instance;
} _QueryProfile_default_instance_;
class MajorFragmentProfileDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<MajorFragmentProfile> _instance;
} _MajorFragmentProfile_default_instance_;
class MinorFragmentProfileDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<MinorFragmentProfile> _instance;
} _MinorFragmentProfile_default_instance_;
class OperatorProfileDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<OperatorProfile> _instance;
} _OperatorProfile_default_instance_;
class StreamProfileDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<StreamProfile> _instance;
} _StreamProfile_default_instance_;
class MetricValueDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<MetricValue> _instance;
} _MetricValue_default_instance_;
class RegistryDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Registry> _instance;
} _Registry_default_instance_;
class JarDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Jar> _instance;
} _Jar_default_instance_;
class SaslMessageDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<SaslMessage> _instance;
} _SaslMessage_default_instance_;
}  // namespace shared
}  // namespace exec
static void InitDefaultsscc_info_DrillPBError_UserBitShared_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::exec::shared::_DrillPBError_default_instance_;
    new (ptr) ::exec::shared::DrillPBError();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::exec::shared::DrillPBError::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_DrillPBError_UserBitShared_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 3, 0, InitDefaultsscc_info_DrillPBError_UserBitShared_2eproto}, {
      &scc_info_DrillbitEndpoint_Coordination_2eproto.base,
      &scc_info_ExceptionWrapper_UserBitShared_2eproto.base,
      &scc_info_ParsingError_UserBitShared_2eproto.base,}};

static void InitDefaultsscc_info_ExceptionWrapper_UserBitShared_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::exec::shared::_ExceptionWrapper_default_instance_;
    new (ptr) ::exec::shared::ExceptionWrapper();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::exec::shared::ExceptionWrapper::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ExceptionWrapper_UserBitShared_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_ExceptionWrapper_UserBitShared_2eproto}, {
      &scc_info_StackTraceElementWrapper_UserBitShared_2eproto.base,}};

static void InitDefaultsscc_info_Jar_UserBitShared_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::exec::shared::_Jar_default_instance_;
    new (ptr) ::exec::shared::Jar();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::exec::shared::Jar::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Jar_UserBitShared_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_Jar_UserBitShared_2eproto}, {}};

static void InitDefaultsscc_info_MajorFragmentProfile_UserBitShared_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::exec::shared::_MajorFragmentProfile_default_instance_;
    new (ptr) ::exec::shared::MajorFragmentProfile();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::exec::shared::MajorFragmentProfile::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_MajorFragmentProfile_UserBitShared_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_MajorFragmentProfile_UserBitShared_2eproto}, {
      &scc_info_MinorFragmentProfile_UserBitShared_2eproto.base,}};

static void InitDefaultsscc_info_MetricValue_UserBitShared_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::exec::shared::_MetricValue_default_instance_;
    new (ptr) ::exec::shared::MetricValue();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::exec::shared::MetricValue::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_MetricValue_UserBitShared_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_MetricValue_UserBitShared_2eproto}, {}};

static void InitDefaultsscc_info_MinorFragmentProfile_UserBitShared_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::exec::shared::_MinorFragmentProfile_default_instance_;
    new (ptr) ::exec::shared::MinorFragmentProfile();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::exec::shared::MinorFragmentProfile::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_MinorFragmentProfile_UserBitShared_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 3, 0, InitDefaultsscc_info_MinorFragmentProfile_UserBitShared_2eproto}, {
      &scc_info_DrillPBError_UserBitShared_2eproto.base,
      &scc_info_OperatorProfile_UserBitShared_2eproto.base,
      &scc_info_DrillbitEndpoint_Coordination_2eproto.base,}};

static void InitDefaultsscc_info_NamePart_UserBitShared_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::exec::shared::_NamePart_default_instance_;
    new (ptr) ::exec::shared::NamePart();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::exec::shared::NamePart::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_NamePart_UserBitShared_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_NamePart_UserBitShared_2eproto}, {}};

static void InitDefaultsscc_info_NodeStatus_UserBitShared_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::exec::shared::_NodeStatus_default_instance_;
    new (ptr) ::exec::shared::NodeStatus();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::exec::shared::NodeStatus::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_NodeStatus_UserBitShared_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_NodeStatus_UserBitShared_2eproto}, {}};

static void InitDefaultsscc_info_OperatorProfile_UserBitShared_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::exec::shared::_OperatorProfile_default_instance_;
    new (ptr) ::exec::shared::OperatorProfile();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::exec::shared::OperatorProfile::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_OperatorProfile_UserBitShared_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_OperatorProfile_UserBitShared_2eproto}, {
      &scc_info_StreamProfile_UserBitShared_2eproto.base,
      &scc_info_MetricValue_UserBitShared_2eproto.base,}};

static void InitDefaultsscc_info_ParsingError_UserBitShared_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::exec::shared::_ParsingError_default_instance_;
    new (ptr) ::exec::shared::ParsingError();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::exec::shared::ParsingError::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ParsingError_UserBitShared_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ParsingError_UserBitShared_2eproto}, {}};

static void InitDefaultsscc_info_QueryData_UserBitShared_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::exec::shared::_QueryData_default_instance_;
    new (ptr) ::exec::shared::QueryData();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::exec::shared::QueryData::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_QueryData_UserBitShared_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_QueryData_UserBitShared_2eproto}, {
      &scc_info_QueryId_UserBitShared_2eproto.base,
      &scc_info_RecordBatchDef_UserBitShared_2eproto.base,}};

static void InitDefaultsscc_info_QueryId_UserBitShared_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::exec::shared::_QueryId_default_instance_;
    new (ptr) ::exec::shared::QueryId();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::exec::shared::QueryId::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_QueryId_UserBitShared_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_QueryId_UserBitShared_2eproto}, {}};

static void InitDefaultsscc_info_QueryInfo_UserBitShared_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  ::exec::shared::QueryInfo::_i_give_permission_to_break_this_code_default_user_.DefaultConstruct();
  *::exec::shared::QueryInfo::_i_give_permission_to_break_this_code_default_user_.get_mutable() = std::string("-", 1);
  ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyString(
      ::exec::shared::QueryInfo::_i_give_permission_to_break_this_code_default_user_.get_mutable());
  ::exec::shared::QueryInfo::_i_give_permission_to_break_this_code_default_queue_name_.DefaultConstruct();
  *::exec::shared::QueryInfo::_i_give_permission_to_break_this_code_default_queue_name_.get_mutable() = std::string("-", 1);
  ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyString(
      ::exec::shared::QueryInfo::_i_give_permission_to_break_this_code_default_queue_name_.get_mutable());
  {
    void* ptr = &::exec::shared::_QueryInfo_default_instance_;
    new (ptr) ::exec::shared::QueryInfo();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::exec::shared::QueryInfo::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_QueryInfo_UserBitShared_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_QueryInfo_UserBitShared_2eproto}, {
      &scc_info_DrillbitEndpoint_Coordination_2eproto.base,}};

static void InitDefaultsscc_info_QueryProfile_UserBitShared_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  ::exec::shared::QueryProfile::_i_give_permission_to_break_this_code_default_user_.DefaultConstruct();
  *::exec::shared::QueryProfile::_i_give_permission_to_break_this_code_default_user_.get_mutable() = std::string("-", 1);
  ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyString(
      ::exec::shared::QueryProfile::_i_give_permission_to_break_this_code_default_user_.get_mutable());
  ::exec::shared::QueryProfile::_i_give_permission_to_break_this_code_default_queue_name_.DefaultConstruct();
  *::exec::shared::QueryProfile::_i_give_permission_to_break_this_code_default_queue_name_.get_mutable() = std::string("-", 1);
  ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyString(
      ::exec::shared::QueryProfile::_i_give_permission_to_break_this_code_default_queue_name_.get_mutable());
  {
    void* ptr = &::exec::shared::_QueryProfile_default_instance_;
    new (ptr) ::exec::shared::QueryProfile();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::exec::shared::QueryProfile::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_QueryProfile_UserBitShared_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 3, 0, InitDefaultsscc_info_QueryProfile_UserBitShared_2eproto}, {
      &scc_info_QueryId_UserBitShared_2eproto.base,
      &scc_info_DrillbitEndpoint_Coordination_2eproto.base,
      &scc_info_MajorFragmentProfile_UserBitShared_2eproto.base,}};

static void InitDefaultsscc_info_QueryResult_UserBitShared_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::exec::shared::_QueryResult_default_instance_;
    new (ptr) ::exec::shared::QueryResult();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::exec::shared::QueryResult::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_QueryResult_UserBitShared_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_QueryResult_UserBitShared_2eproto}, {
      &scc_info_QueryId_UserBitShared_2eproto.base,
      &scc_info_DrillPBError_UserBitShared_2eproto.base,}};

static void InitDefaultsscc_info_RecordBatchDef_UserBitShared_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::exec::shared::_RecordBatchDef_default_instance_;
    new (ptr) ::exec::shared::RecordBatchDef();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::exec::shared::RecordBatchDef::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_RecordBatchDef_UserBitShared_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_RecordBatchDef_UserBitShared_2eproto}, {
      &scc_info_SerializedField_UserBitShared_2eproto.base,}};

static void InitDefaultsscc_info_Registry_UserBitShared_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::exec::shared::_Registry_default_instance_;
    new (ptr) ::exec::shared::Registry();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::exec::shared::Registry::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_Registry_UserBitShared_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_Registry_UserBitShared_2eproto}, {
      &scc_info_Jar_UserBitShared_2eproto.base,}};

static void InitDefaultsscc_info_SaslMessage_UserBitShared_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::exec::shared::_SaslMessage_default_instance_;
    new (ptr) ::exec::shared::SaslMessage();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::exec::shared::SaslMessage::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_SaslMessage_UserBitShared_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_SaslMessage_UserBitShared_2eproto}, {}};

static void InitDefaultsscc_info_SerializedField_UserBitShared_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::exec::shared::_SerializedField_default_instance_;
    new (ptr) ::exec::shared::SerializedField();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::exec::shared::SerializedField::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_SerializedField_UserBitShared_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_SerializedField_UserBitShared_2eproto}, {
      &scc_info_MajorType_Types_2eproto.base,
      &scc_info_NamePart_UserBitShared_2eproto.base,}};

static void InitDefaultsscc_info_StackTraceElementWrapper_UserBitShared_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::exec::shared::_StackTraceElementWrapper_default_instance_;
    new (ptr) ::exec::shared::StackTraceElementWrapper();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::exec::shared::StackTraceElementWrapper::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_StackTraceElementWrapper_UserBitShared_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_StackTraceElementWrapper_UserBitShared_2eproto}, {}};

static void InitDefaultsscc_info_StreamProfile_UserBitShared_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::exec::shared::_StreamProfile_default_instance_;
    new (ptr) ::exec::shared::StreamProfile();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::exec::shared::StreamProfile::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_StreamProfile_UserBitShared_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_StreamProfile_UserBitShared_2eproto}, {}};

static void InitDefaultsscc_info_UserCredentials_UserBitShared_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::exec::shared::_UserCredentials_default_instance_;
    new (ptr) ::exec::shared::UserCredentials();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::exec::shared::UserCredentials::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_UserCredentials_UserBitShared_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_UserCredentials_UserBitShared_2eproto}, {}};

static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_UserBitShared_2eproto[22];
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_UserBitShared_2eproto[8];
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_UserBitShared_2eproto = nullptr;

const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_UserBitShared_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  PROTOBUF_FIELD_OFFSET(::exec::shared::UserCredentials, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::UserCredentials, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::exec::shared::UserCredentials, user_name_),
  0,
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryId, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryId, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryId, part1_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryId, part2_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::exec::shared::DrillPBError, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::DrillPBError, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::exec::shared::DrillPBError, error_id_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::DrillPBError, endpoint_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::DrillPBError, error_type_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::DrillPBError, message_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::DrillPBError, exception_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::DrillPBError, parsing_error_),
  0,
  2,
  4,
  1,
  3,
  ~0u,
  PROTOBUF_FIELD_OFFSET(::exec::shared::ExceptionWrapper, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::ExceptionWrapper, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::exec::shared::ExceptionWrapper, exception_class_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::ExceptionWrapper, message_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::ExceptionWrapper, stack_trace_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::ExceptionWrapper, cause_),
  0,
  1,
  ~0u,
  2,
  PROTOBUF_FIELD_OFFSET(::exec::shared::StackTraceElementWrapper, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::StackTraceElementWrapper, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::exec::shared::StackTraceElementWrapper, class_name_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::StackTraceElementWrapper, file_name_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::StackTraceElementWrapper, line_number_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::StackTraceElementWrapper, method_name_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::StackTraceElementWrapper, is_native_method_),
  0,
  1,
  3,
  2,
  4,
  PROTOBUF_FIELD_OFFSET(::exec::shared::ParsingError, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::ParsingError, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::exec::shared::ParsingError, start_column_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::ParsingError, start_row_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::ParsingError, end_column_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::ParsingError, end_row_),
  0,
  1,
  2,
  3,
  PROTOBUF_FIELD_OFFSET(::exec::shared::RecordBatchDef, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::RecordBatchDef, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::exec::shared::RecordBatchDef, record_count_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::RecordBatchDef, field_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::RecordBatchDef, carries_two_byte_selection_vector_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::RecordBatchDef, affected_rows_count_),
  0,
  ~0u,
  1,
  2,
  PROTOBUF_FIELD_OFFSET(::exec::shared::NamePart, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::NamePart, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::exec::shared::NamePart, type_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::NamePart, name_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::NamePart, child_),
  2,
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::exec::shared::SerializedField, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::SerializedField, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::exec::shared::SerializedField, major_type_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::SerializedField, name_part_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::SerializedField, child_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::SerializedField, value_count_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::SerializedField, var_byte_length_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::SerializedField, buffer_length_),
  0,
  1,
  ~0u,
  2,
  3,
  4,
  PROTOBUF_FIELD_OFFSET(::exec::shared::NodeStatus, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::NodeStatus, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::exec::shared::NodeStatus, node_id_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::NodeStatus, memory_footprint_),
  1,
  0,
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryResult, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryResult, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryResult, query_state_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryResult, query_id_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryResult, error_),
  1,
  0,
  ~0u,
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryData, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryData, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryData, query_id_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryData, row_count_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryData, def_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryData, affected_rows_count_),
  0,
  2,
  1,
  3,
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryInfo, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryInfo, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryInfo, query_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryInfo, start_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryInfo, state_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryInfo, user_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryInfo, foreman_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryInfo, options_json_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryInfo, total_cost_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryInfo, queue_name_),
  0,
  5,
  7,
  1,
  4,
  2,
  6,
  3,
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryProfile, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryProfile, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryProfile, id_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryProfile, type_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryProfile, start_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryProfile, end_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryProfile, query_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryProfile, plan_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryProfile, foreman_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryProfile, state_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryProfile, total_fragments_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryProfile, finished_fragments_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryProfile, fragment_profile_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryProfile, user_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryProfile, error_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryProfile, verboseerror_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryProfile, error_id_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryProfile, error_node_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryProfile, options_json_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryProfile, planend_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryProfile, queuewaitend_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryProfile, total_cost_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryProfile, queue_name_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryProfile, queryid_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::QueryProfile, autolimit_),
  10,
  21,
  12,
  13,
  0,
  1,
  11,
  14,
  15,
  16,
  ~0u,
  2,
  3,
  4,
  5,
  6,
  7,
  18,
  19,
  20,
  8,
  9,
  17,
  PROTOBUF_FIELD_OFFSET(::exec::shared::MajorFragmentProfile, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::MajorFragmentProfile, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::exec::shared::MajorFragmentProfile, major_fragment_id_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::MajorFragmentProfile, minor_fragment_profile_),
  0,
  ~0u,
  PROTOBUF_FIELD_OFFSET(::exec::shared::MinorFragmentProfile, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::MinorFragmentProfile, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::exec::shared::MinorFragmentProfile, state_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::MinorFragmentProfile, error_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::MinorFragmentProfile, minor_fragment_id_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::MinorFragmentProfile, operator_profile_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::MinorFragmentProfile, start_time_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::MinorFragmentProfile, end_time_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::MinorFragmentProfile, memory_used_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::MinorFragmentProfile, max_memory_used_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::MinorFragmentProfile, endpoint_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::MinorFragmentProfile, last_update_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::MinorFragmentProfile, last_progress_),
  2,
  0,
  3,
  ~0u,
  4,
  5,
  6,
  7,
  1,
  8,
  9,
  PROTOBUF_FIELD_OFFSET(::exec::shared::OperatorProfile, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::OperatorProfile, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::exec::shared::OperatorProfile, input_profile_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::OperatorProfile, operator_id_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::OperatorProfile, operator_type_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::OperatorProfile, setup_nanos_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::OperatorProfile, process_nanos_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::OperatorProfile, peak_local_memory_allocated_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::OperatorProfile, metric_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::OperatorProfile, wait_nanos_),
  ~0u,
  0,
  1,
  2,
  3,
  4,
  ~0u,
  5,
  PROTOBUF_FIELD_OFFSET(::exec::shared::StreamProfile, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::StreamProfile, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::exec::shared::StreamProfile, records_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::StreamProfile, batches_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::StreamProfile, schemas_),
  0,
  1,
  2,
  PROTOBUF_FIELD_OFFSET(::exec::shared::MetricValue, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::MetricValue, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::exec::shared::MetricValue, metric_id_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::MetricValue, long_value_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::MetricValue, double_value_),
  2,
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::exec::shared::Registry, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::Registry, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::exec::shared::Registry, jar_),
  ~0u,
  PROTOBUF_FIELD_OFFSET(::exec::shared::Jar, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::Jar, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::exec::shared::Jar, name_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::Jar, function_signature_),
  0,
  ~0u,
  PROTOBUF_FIELD_OFFSET(::exec::shared::SaslMessage, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::SaslMessage, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::exec::shared::SaslMessage, mechanism_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::SaslMessage, data_),
  PROTOBUF_FIELD_OFFSET(::exec::shared::SaslMessage, status_),
  0,
  1,
  2,
};
static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  { 0, 6, sizeof(::exec::shared::UserCredentials)},
  { 7, 14, sizeof(::exec::shared::QueryId)},
  { 16, 27, sizeof(::exec::shared::DrillPBError)},
  { 33, 42, sizeof(::exec::shared::ExceptionWrapper)},
  { 46, 56, sizeof(::exec::shared::StackTraceElementWrapper)},
  { 61, 70, sizeof(::exec::shared::ParsingError)},
  { 74, 83, sizeof(::exec::shared::RecordBatchDef)},
  { 87, 95, sizeof(::exec::shared::NamePart)},
  { 98, 109, sizeof(::exec::shared::SerializedField)},
  { 115, 122, sizeof(::exec::shared::NodeStatus)},
  { 124, 132, sizeof(::exec::shared::QueryResult)},
  { 135, 144, sizeof(::exec::shared::QueryData)},
  { 148, 161, sizeof(::exec::shared::QueryInfo)},
  { 169, 197, sizeof(::exec::shared::QueryProfile)},
  { 220, 227, sizeof(::exec::shared::MajorFragmentProfile)},
  { 229, 245, sizeof(::exec::shared::MinorFragmentProfile)},
  { 256, 269, sizeof(::exec::shared::OperatorProfile)},
  { 277, 285, sizeof(::exec::shared::StreamProfile)},
  { 288, 296, sizeof(::exec::shared::MetricValue)},
  { 299, 305, sizeof(::exec::shared::Registry)},
  { 306, 313, sizeof(::exec::shared::Jar)},
  { 315, 323, sizeof(::exec::shared::SaslMessage)},
};

static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::exec::shared::_UserCredentials_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::exec::shared::_QueryId_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::exec::shared::_DrillPBError_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::exec::shared::_ExceptionWrapper_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::exec::shared::_StackTraceElementWrapper_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::exec::shared::_ParsingError_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::exec::shared::_RecordBatchDef_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::exec::shared::_NamePart_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::exec::shared::_SerializedField_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::exec::shared::_NodeStatus_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::exec::shared::_QueryResult_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::exec::shared::_QueryData_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::exec::shared::_QueryInfo_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::exec::shared::_QueryProfile_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::exec::shared::_MajorFragmentProfile_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::exec::shared::_MinorFragmentProfile_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::exec::shared::_OperatorProfile_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::exec::shared::_StreamProfile_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::exec::shared::_MetricValue_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::exec::shared::_Registry_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::exec::shared::_Jar_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::exec::shared::_SaslMessage_default_instance_),
};

const char descriptor_table_protodef_UserBitShared_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
  "\n\023UserBitShared.proto\022\013exec.shared\032\013Type"
  "s.proto\032\022Coordination.proto\032\017SchemaDef.p"
  "roto\"$\n\017UserCredentials\022\021\n\tuser_name\030\001 \001"
  "(\t\"\'\n\007QueryId\022\r\n\005part1\030\001 \001(\020\022\r\n\005part2\030\002 "
  "\001(\020\"\355\003\n\014DrillPBError\022\020\n\010error_id\030\001 \001(\t\022("
  "\n\010endpoint\030\002 \001(\0132\026.exec.DrillbitEndpoint"
  "\0227\n\nerror_type\030\003 \001(\0162#.exec.shared.Drill"
  "PBError.ErrorType\022\017\n\007message\030\004 \001(\t\0220\n\tex"
  "ception\030\005 \001(\0132\035.exec.shared.ExceptionWra"
  "pper\0220\n\rparsing_error\030\006 \003(\0132\031.exec.share"
  "d.ParsingError\"\362\001\n\tErrorType\022\016\n\nCONNECTI"
  "ON\020\000\022\r\n\tDATA_READ\020\001\022\016\n\nDATA_WRITE\020\002\022\014\n\010F"
  "UNCTION\020\003\022\t\n\005PARSE\020\004\022\016\n\nPERMISSION\020\005\022\010\n\004"
  "PLAN\020\006\022\014\n\010RESOURCE\020\007\022\n\n\006SYSTEM\020\010\022\031\n\025UNSU"
  "PPORTED_OPERATION\020\t\022\016\n\nVALIDATION\020\n\022\023\n\017E"
  "XECUTION_ERROR\020\013\022\022\n\016INTERNAL_ERROR\020\014\022\025\n\021"
  "UNSPECIFIED_ERROR\020\r\"\246\001\n\020ExceptionWrapper"
  "\022\027\n\017exception_class\030\001 \001(\t\022\017\n\007message\030\002 \001"
  "(\t\022:\n\013stack_trace\030\003 \003(\0132%.exec.shared.St"
  "ackTraceElementWrapper\022,\n\005cause\030\004 \001(\0132\035."
  "exec.shared.ExceptionWrapper\"\205\001\n\030StackTr"
  "aceElementWrapper\022\022\n\nclass_name\030\001 \001(\t\022\021\n"
  "\tfile_name\030\002 \001(\t\022\023\n\013line_number\030\003 \001(\005\022\023\n"
  "\013method_name\030\004 \001(\t\022\030\n\020is_native_method\030\005"
  " \001(\010\"\\\n\014ParsingError\022\024\n\014start_column\030\002 \001"
  "(\005\022\021\n\tstart_row\030\003 \001(\005\022\022\n\nend_column\030\004 \001("
  "\005\022\017\n\007end_row\030\005 \001(\005\"\233\001\n\016RecordBatchDef\022\024\n"
  "\014record_count\030\001 \001(\005\022+\n\005field\030\002 \003(\0132\034.exe"
  "c.shared.SerializedField\022)\n!carries_two_"
  "byte_selection_vector\030\003 \001(\010\022\033\n\023affected_"
  "rows_count\030\004 \001(\005\"\205\001\n\010NamePart\022(\n\004type\030\001 "
  "\001(\0162\032.exec.shared.NamePart.Type\022\014\n\004name\030"
  "\002 \001(\t\022$\n\005child\030\003 \001(\0132\025.exec.shared.NameP"
  "art\"\033\n\004Type\022\010\n\004NAME\020\000\022\t\n\005ARRAY\020\001\"\324\001\n\017Ser"
  "ializedField\022%\n\nmajor_type\030\001 \001(\0132\021.commo"
  "n.MajorType\022(\n\tname_part\030\002 \001(\0132\025.exec.sh"
  "ared.NamePart\022+\n\005child\030\003 \003(\0132\034.exec.shar"
  "ed.SerializedField\022\023\n\013value_count\030\004 \001(\005\022"
  "\027\n\017var_byte_length\030\005 \001(\005\022\025\n\rbuffer_lengt"
  "h\030\007 \001(\005\"7\n\nNodeStatus\022\017\n\007node_id\030\001 \001(\005\022\030"
  "\n\020memory_footprint\030\002 \001(\003\"\263\002\n\013QueryResult"
  "\0228\n\013query_state\030\001 \001(\0162#.exec.shared.Quer"
  "yResult.QueryState\022&\n\010query_id\030\002 \001(\0132\024.e"
  "xec.shared.QueryId\022(\n\005error\030\003 \003(\0132\031.exec"
  ".shared.DrillPBError\"\227\001\n\nQueryState\022\014\n\010S"
  "TARTING\020\000\022\013\n\007RUNNING\020\001\022\r\n\tCOMPLETED\020\002\022\014\n"
  "\010CANCELED\020\003\022\n\n\006FAILED\020\004\022\032\n\026CANCELLATION_"
  "REQUESTED\020\005\022\014\n\010ENQUEUED\020\006\022\r\n\tPREPARING\020\007"
  "\022\014\n\010PLANNING\020\010\"\215\001\n\tQueryData\022&\n\010query_id"
  "\030\001 \001(\0132\024.exec.shared.QueryId\022\021\n\trow_coun"
  "t\030\002 \001(\005\022(\n\003def\030\003 \001(\0132\033.exec.shared.Recor"
  "dBatchDef\022\033\n\023affected_rows_count\030\004 \001(\005\"\330"
  "\001\n\tQueryInfo\022\r\n\005query\030\001 \001(\t\022\r\n\005start\030\002 \001"
  "(\003\0222\n\005state\030\003 \001(\0162#.exec.shared.QueryRes"
  "ult.QueryState\022\017\n\004user\030\004 \001(\t:\001-\022\'\n\007forem"
  "an\030\005 \001(\0132\026.exec.DrillbitEndpoint\022\024\n\014opti"
  "ons_json\030\006 \001(\t\022\022\n\ntotal_cost\030\007 \001(\001\022\025\n\nqu"
  "eue_name\030\010 \001(\t:\001-\"\306\004\n\014QueryProfile\022 \n\002id"
  "\030\001 \001(\0132\024.exec.shared.QueryId\022$\n\004type\030\002 \001"
  "(\0162\026.exec.shared.QueryType\022\r\n\005start\030\003 \001("
  "\003\022\013\n\003end\030\004 \001(\003\022\r\n\005query\030\005 \001(\t\022\014\n\004plan\030\006 "
  "\001(\t\022\'\n\007foreman\030\007 \001(\0132\026.exec.DrillbitEndp"
  "oint\0222\n\005state\030\010 \001(\0162#.exec.shared.QueryR"
  "esult.QueryState\022\027\n\017total_fragments\030\t \001("
  "\005\022\032\n\022finished_fragments\030\n \001(\005\022;\n\020fragmen"
  "t_profile\030\013 \003(\0132!.exec.shared.MajorFragm"
  "entProfile\022\017\n\004user\030\014 \001(\t:\001-\022\r\n\005error\030\r \001"
  "(\t\022\024\n\014verboseError\030\016 \001(\t\022\020\n\010error_id\030\017 \001"
  "(\t\022\022\n\nerror_node\030\020 \001(\t\022\024\n\014options_json\030\021"
  " \001(\t\022\017\n\007planEnd\030\022 \001(\003\022\024\n\014queueWaitEnd\030\023 "
  "\001(\003\022\022\n\ntotal_cost\030\024 \001(\001\022\025\n\nqueue_name\030\025 "
  "\001(\t:\001-\022\017\n\007queryId\030\026 \001(\t\022\021\n\tautoLimit\030\027 \001"
  "(\005\"t\n\024MajorFragmentProfile\022\031\n\021major_frag"
  "ment_id\030\001 \001(\005\022A\n\026minor_fragment_profile\030"
  "\002 \003(\0132!.exec.shared.MinorFragmentProfile"
  "\"\350\002\n\024MinorFragmentProfile\022)\n\005state\030\001 \001(\016"
  "2\032.exec.shared.FragmentState\022(\n\005error\030\002 "
  "\001(\0132\031.exec.shared.DrillPBError\022\031\n\021minor_"
  "fragment_id\030\003 \001(\005\0226\n\020operator_profile\030\004 "
  "\003(\0132\034.exec.shared.OperatorProfile\022\022\n\nsta"
  "rt_time\030\005 \001(\003\022\020\n\010end_time\030\006 \001(\003\022\023\n\013memor"
  "y_used\030\007 \001(\003\022\027\n\017max_memory_used\030\010 \001(\003\022(\n"
  "\010endpoint\030\t \001(\0132\026.exec.DrillbitEndpoint\022"
  "\023\n\013last_update\030\n \001(\003\022\025\n\rlast_progress\030\013 "
  "\001(\003\"\377\001\n\017OperatorProfile\0221\n\rinput_profile"
  "\030\001 \003(\0132\032.exec.shared.StreamProfile\022\023\n\013op"
  "erator_id\030\003 \001(\005\022\025\n\roperator_type\030\004 \001(\005\022\023"
  "\n\013setup_nanos\030\005 \001(\003\022\025\n\rprocess_nanos\030\006 \001"
  "(\003\022#\n\033peak_local_memory_allocated\030\007 \001(\003\022"
  "(\n\006metric\030\010 \003(\0132\030.exec.shared.MetricValu"
  "e\022\022\n\nwait_nanos\030\t \001(\003\"B\n\rStreamProfile\022\017"
  "\n\007records\030\001 \001(\003\022\017\n\007batches\030\002 \001(\003\022\017\n\007sche"
  "mas\030\003 \001(\003\"J\n\013MetricValue\022\021\n\tmetric_id\030\001 "
  "\001(\005\022\022\n\nlong_value\030\002 \001(\003\022\024\n\014double_value\030"
  "\003 \001(\001\")\n\010Registry\022\035\n\003jar\030\001 \003(\0132\020.exec.sh"
  "ared.Jar\"/\n\003Jar\022\014\n\004name\030\001 \001(\t\022\032\n\022functio"
  "n_signature\030\002 \003(\t\"W\n\013SaslMessage\022\021\n\tmech"
  "anism\030\001 \001(\t\022\014\n\004data\030\002 \001(\014\022\'\n\006status\030\003 \001("
  "\0162\027.exec.shared.SaslStatus*5\n\nRpcChannel"
  "\022\017\n\013BIT_CONTROL\020\000\022\014\n\010BIT_DATA\020\001\022\010\n\004USER\020"
  "\002*V\n\tQueryType\022\007\n\003SQL\020\001\022\013\n\007LOGICAL\020\002\022\014\n\010"
  "PHYSICAL\020\003\022\r\n\tEXECUTION\020\004\022\026\n\022PREPARED_ST"
  "ATEMENT\020\005*\207\001\n\rFragmentState\022\013\n\007SENDING\020\000"
  "\022\027\n\023AWAITING_ALLOCATION\020\001\022\013\n\007RUNNING\020\002\022\014"
  "\n\010FINISHED\020\003\022\r\n\tCANCELLED\020\004\022\n\n\006FAILED\020\005\022"
  "\032\n\026CANCELLATION_REQUESTED\020\006*\212\013\n\020CoreOper"
  "atorType\022\021\n\rSINGLE_SENDER\020\000\022\024\n\020BROADCAST"
  "_SENDER\020\001\022\n\n\006FILTER\020\002\022\022\n\016HASH_AGGREGATE\020"
  "\003\022\r\n\tHASH_JOIN\020\004\022\016\n\nMERGE_JOIN\020\005\022\031\n\025HASH"
  "_PARTITION_SENDER\020\006\022\t\n\005LIMIT\020\007\022\024\n\020MERGIN"
  "G_RECEIVER\020\010\022\034\n\030ORDERED_PARTITION_SENDER"
  "\020\t\022\013\n\007PROJECT\020\n\022\026\n\022UNORDERED_RECEIVER\020\013\022"
  "\032\n\026RANGE_PARTITION_SENDER\020\014\022\n\n\006SCREEN\020\r\022"
  "\034\n\030SELECTION_VECTOR_REMOVER\020\016\022\027\n\023STREAMI"
  "NG_AGGREGATE\020\017\022\016\n\nTOP_N_SORT\020\020\022\021\n\rEXTERN"
  "AL_SORT\020\021\022\t\n\005TRACE\020\022\022\t\n\005UNION\020\023\022\014\n\010OLD_S"
  "ORT\020\024\022\032\n\026PARQUET_ROW_GROUP_SCAN\020\025\022\021\n\rHIV"
  "E_SUB_SCAN\020\026\022\025\n\021SYSTEM_TABLE_SCAN\020\027\022\021\n\rM"
  "OCK_SUB_SCAN\020\030\022\022\n\016PARQUET_WRITER\020\031\022\023\n\017DI"
  "RECT_SUB_SCAN\020\032\022\017\n\013TEXT_WRITER\020\033\022\021\n\rTEXT"
  "_SUB_SCAN\020\034\022\021\n\rJSON_SUB_SCAN\020\035\022\030\n\024INFO_S"
  "CHEMA_SUB_SCAN\020\036\022\023\n\017COMPLEX_TO_JSON\020\037\022\025\n"
  "\021PRODUCER_CONSUMER\020 \022\022\n\016HBASE_SUB_SCAN\020!"
  "\022\n\n\006WINDOW\020\"\022\024\n\020NESTED_LOOP_JOIN\020#\022\021\n\rAV"
  "RO_SUB_SCAN\020$\022\021\n\rPCAP_SUB_SCAN\020%\022\022\n\016KAFK"
  "A_SUB_SCAN\020&\022\021\n\rKUDU_SUB_SCAN\020\'\022\013\n\007FLATT"
  "EN\020(\022\020\n\014LATERAL_JOIN\020)\022\n\n\006UNNEST\020*\022,\n(HI"
  "VE_DRILL_NATIVE_PARQUET_ROW_GROUP_SCAN\020+"
  "\022\r\n\tJDBC_SCAN\020,\022\022\n\016REGEX_SUB_SCAN\020-\022\023\n\017M"
  "APRDB_SUB_SCAN\020.\022\022\n\016MONGO_SUB_SCAN\020/\022\017\n\013"
  "KUDU_WRITER\0200\022\026\n\022OPEN_TSDB_SUB_SCAN\0201\022\017\n"
  "\013JSON_WRITER\0202\022\026\n\022HTPPD_LOG_SUB_SCAN\0203\022\022"
  "\n\016IMAGE_SUB_SCAN\0204\022\025\n\021SEQUENCE_SUB_SCAN\020"
  "5\022\023\n\017PARTITION_LIMIT\0206\022\023\n\017PCAPNG_SUB_SCA"
  "N\0207\022\022\n\016RUNTIME_FILTER\0208\022\017\n\013ROWKEY_JOIN\0209"
  "\022\023\n\017SYSLOG_SUB_SCAN\020:\022\030\n\024STATISTICS_AGGR"
  "EGATE\020;\022\020\n\014UNPIVOT_MAPS\020<\022\024\n\020STATISTICS_"
  "MERGE\020=\022\021\n\rLTSV_SUB_SCAN\020>\022\021\n\rHDF5_SUB_S"
  "CAN\020\?\022\022\n\016EXCEL_SUB_SCAN\020@\022\020\n\014SHP_SUB_SCA"
  "N\020A\022\024\n\020METADATA_HANDLER\020B\022\027\n\023METADATA_CO"
  "NTROLLER\020C\022\021\n\rSPSS_SUB_SCAN\020E\022\021\n\rHTTP_SU"
  "B_SCAN\020F*g\n\nSaslStatus\022\020\n\014SASL_UNKNOWN\020\000"
  "\022\016\n\nSASL_START\020\001\022\024\n\020SASL_IN_PROGRESS\020\002\022\020"
  "\n\014SASL_SUCCESS\020\003\022\017\n\013SASL_FAILED\020\004B.\n\033org"
  ".apache.drill.exec.protoB\rUserBitSharedH"
  "\001"
  ;
static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_UserBitShared_2eproto_deps[3] = {
  &::descriptor_table_Coordination_2eproto,
  &::descriptor_table_SchemaDef_2eproto,
  &::descriptor_table_Types_2eproto,
};
static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_UserBitShared_2eproto_sccs[22] = {
  &scc_info_DrillPBError_UserBitShared_2eproto.base,
  &scc_info_ExceptionWrapper_UserBitShared_2eproto.base,
  &scc_info_Jar_UserBitShared_2eproto.base,
  &scc_info_MajorFragmentProfile_UserBitShared_2eproto.base,
  &scc_info_MetricValue_UserBitShared_2eproto.base,
  &scc_info_MinorFragmentProfile_UserBitShared_2eproto.base,
  &scc_info_NamePart_UserBitShared_2eproto.base,
  &scc_info_NodeStatus_UserBitShared_2eproto.base,
  &scc_info_OperatorProfile_UserBitShared_2eproto.base,
  &scc_info_ParsingError_UserBitShared_2eproto.base,
  &scc_info_QueryData_UserBitShared_2eproto.base,
  &scc_info_QueryId_UserBitShared_2eproto.base,
  &scc_info_QueryInfo_UserBitShared_2eproto.base,
  &scc_info_QueryProfile_UserBitShared_2eproto.base,
  &scc_info_QueryResult_UserBitShared_2eproto.base,
  &scc_info_RecordBatchDef_UserBitShared_2eproto.base,
  &scc_info_Registry_UserBitShared_2eproto.base,
  &scc_info_SaslMessage_UserBitShared_2eproto.base,
  &scc_info_SerializedField_UserBitShared_2eproto.base,
  &scc_info_StackTraceElementWrapper_UserBitShared_2eproto.base,
  &scc_info_StreamProfile_UserBitShared_2eproto.base,
  &scc_info_UserCredentials_UserBitShared_2eproto.base,
};
static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_UserBitShared_2eproto_once;
static bool descriptor_table_UserBitShared_2eproto_initialized = false;
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_UserBitShared_2eproto = {
  &descriptor_table_UserBitShared_2eproto_initialized, descriptor_table_protodef_UserBitShared_2eproto, "UserBitShared.proto", 5801,
  &descriptor_table_UserBitShared_2eproto_once, descriptor_table_UserBitShared_2eproto_sccs, descriptor_table_UserBitShared_2eproto_deps, 22, 3,
  schemas, file_default_instances, TableStruct_UserBitShared_2eproto::offsets,
  file_level_metadata_UserBitShared_2eproto, 22, file_level_enum_descriptors_UserBitShared_2eproto, file_level_service_descriptors_UserBitShared_2eproto,
};

// Force running AddDescriptors() at dynamic initialization time.
static bool dynamic_init_dummy_UserBitShared_2eproto = (  ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_UserBitShared_2eproto), true);
namespace exec {
namespace shared {
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DrillPBError_ErrorType_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_UserBitShared_2eproto);
  return file_level_enum_descriptors_UserBitShared_2eproto[0];
}
bool DrillPBError_ErrorType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
    case 11:
    case 12:
    case 13:
      return true;
    default:
      return false;
  }
}

#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr DrillPBError_ErrorType DrillPBError::CONNECTION;
constexpr DrillPBError_ErrorType DrillPBError::DATA_READ;
constexpr DrillPBError_ErrorType DrillPBError::DATA_WRITE;
constexpr DrillPBError_ErrorType DrillPBError::FUNCTION;
constexpr DrillPBError_ErrorType DrillPBError::PARSE;
constexpr DrillPBError_ErrorType DrillPBError::PERMISSION;
constexpr DrillPBError_ErrorType DrillPBError::PLAN;
constexpr DrillPBError_ErrorType DrillPBError::RESOURCE;
constexpr DrillPBError_ErrorType DrillPBError::SYSTEM;
constexpr DrillPBError_ErrorType DrillPBError::UNSUPPORTED_OPERATION;
constexpr DrillPBError_ErrorType DrillPBError::VALIDATION;
constexpr DrillPBError_ErrorType DrillPBError::EXECUTION_ERROR;
constexpr DrillPBError_ErrorType DrillPBError::INTERNAL_ERROR;
constexpr DrillPBError_ErrorType DrillPBError::UNSPECIFIED_ERROR;
constexpr DrillPBError_ErrorType DrillPBError::ErrorType_MIN;
constexpr DrillPBError_ErrorType DrillPBError::ErrorType_MAX;
constexpr int DrillPBError::ErrorType_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* NamePart_Type_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_UserBitShared_2eproto);
  return file_level_enum_descriptors_UserBitShared_2eproto[1];
}
bool NamePart_Type_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
      return true;
    default:
      return false;
  }
}

#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr NamePart_Type NamePart::NAME;
constexpr NamePart_Type NamePart::ARRAY;
constexpr NamePart_Type NamePart::Type_MIN;
constexpr NamePart_Type NamePart::Type_MAX;
constexpr int NamePart::Type_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* QueryResult_QueryState_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_UserBitShared_2eproto);
  return file_level_enum_descriptors_UserBitShared_2eproto[2];
}
bool QueryResult_QueryState_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
      return true;
    default:
      return false;
  }
}

#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr QueryResult_QueryState QueryResult::STARTING;
constexpr QueryResult_QueryState QueryResult::RUNNING;
constexpr QueryResult_QueryState QueryResult::COMPLETED;
constexpr QueryResult_QueryState QueryResult::CANCELED;
constexpr QueryResult_QueryState QueryResult::FAILED;
constexpr QueryResult_QueryState QueryResult::CANCELLATION_REQUESTED;
constexpr QueryResult_QueryState QueryResult::ENQUEUED;
constexpr QueryResult_QueryState QueryResult::PREPARING;
constexpr QueryResult_QueryState QueryResult::PLANNING;
constexpr QueryResult_QueryState QueryResult::QueryState_MIN;
constexpr QueryResult_QueryState QueryResult::QueryState_MAX;
constexpr int QueryResult::QueryState_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* RpcChannel_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_UserBitShared_2eproto);
  return file_level_enum_descriptors_UserBitShared_2eproto[3];
}
bool RpcChannel_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* QueryType_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_UserBitShared_2eproto);
  return file_level_enum_descriptors_UserBitShared_2eproto[4];
}
bool QueryType_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FragmentState_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_UserBitShared_2eproto);
  return file_level_enum_descriptors_UserBitShared_2eproto[5];
}
bool FragmentState_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CoreOperatorType_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_UserBitShared_2eproto);
  return file_level_enum_descriptors_UserBitShared_2eproto[6];
}
bool CoreOperatorType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
    case 11:
    case 12:
    case 13:
    case 14:
    case 15:
    case 16:
    case 17:
    case 18:
    case 19:
    case 20:
    case 21:
    case 22:
    case 23:
    case 24:
    case 25:
    case 26:
    case 27:
    case 28:
    case 29:
    case 30:
    case 31:
    case 32:
    case 33:
    case 34:
    case 35:
    case 36:
    case 37:
    case 38:
    case 39:
    case 40:
    case 41:
    case 42:
    case 43:
    case 44:
    case 45:
    case 46:
    case 47:
    case 48:
    case 49:
    case 50:
    case 51:
    case 52:
    case 53:
    case 54:
    case 55:
    case 56:
    case 57:
    case 58:
    case 59:
    case 60:
    case 61:
    case 62:
    case 63:
    case 64:
    case 65:
    case 66:
    case 67:
    case 69:
    case 70:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SaslStatus_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_UserBitShared_2eproto);
  return file_level_enum_descriptors_UserBitShared_2eproto[7];
}
bool SaslStatus_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
      return true;
    default:
      return false;
  }
}


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

void UserCredentials::InitAsDefaultInstance() {
}
class UserCredentials::_Internal {
 public:
  using HasBits = decltype(std::declval<UserCredentials>()._has_bits_);
  static void set_has_user_name(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

UserCredentials::UserCredentials()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:exec.shared.UserCredentials)
}
UserCredentials::UserCredentials(const UserCredentials& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  user_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_user_name()) {
    user_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.user_name_);
  }
  // @@protoc_insertion_point(copy_constructor:exec.shared.UserCredentials)
}

void UserCredentials::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_UserCredentials_UserBitShared_2eproto.base);
  user_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

UserCredentials::~UserCredentials() {
  // @@protoc_insertion_point(destructor:exec.shared.UserCredentials)
  SharedDtor();
}

void UserCredentials::SharedDtor() {
  user_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void UserCredentials::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const UserCredentials& UserCredentials::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_UserCredentials_UserBitShared_2eproto.base);
  return *internal_default_instance();
}


void UserCredentials::Clear() {
// @@protoc_insertion_point(message_clear_start:exec.shared.UserCredentials)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    user_name_.ClearNonDefaultToEmptyNoArena();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* UserCredentials::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional string user_name = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_user_name();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "exec.shared.UserCredentials.user_name");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* UserCredentials::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:exec.shared.UserCredentials)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string user_name = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_user_name().data(), static_cast<int>(this->_internal_user_name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "exec.shared.UserCredentials.user_name");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_user_name(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:exec.shared.UserCredentials)
  return target;
}

size_t UserCredentials::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:exec.shared.UserCredentials)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional string user_name = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_user_name());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void UserCredentials::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:exec.shared.UserCredentials)
  GOOGLE_DCHECK_NE(&from, this);
  const UserCredentials* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<UserCredentials>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:exec.shared.UserCredentials)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:exec.shared.UserCredentials)
    MergeFrom(*source);
  }
}

void UserCredentials::MergeFrom(const UserCredentials& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:exec.shared.UserCredentials)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_user_name()) {
    _has_bits_[0] |= 0x00000001u;
    user_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.user_name_);
  }
}

void UserCredentials::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:exec.shared.UserCredentials)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void UserCredentials::CopyFrom(const UserCredentials& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:exec.shared.UserCredentials)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool UserCredentials::IsInitialized() const {
  return true;
}

void UserCredentials::InternalSwap(UserCredentials* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  user_name_.Swap(&other->user_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
}

::PROTOBUF_NAMESPACE_ID::Metadata UserCredentials::GetMetadata() const {
  return GetMetadataStatic();
}


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

void QueryId::InitAsDefaultInstance() {
}
class QueryId::_Internal {
 public:
  using HasBits = decltype(std::declval<QueryId>()._has_bits_);
  static void set_has_part1(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_part2(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

QueryId::QueryId()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:exec.shared.QueryId)
}
QueryId::QueryId(const QueryId& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&part1_, &from.part1_,
    static_cast<size_t>(reinterpret_cast<char*>(&part2_) -
    reinterpret_cast<char*>(&part1_)) + sizeof(part2_));
  // @@protoc_insertion_point(copy_constructor:exec.shared.QueryId)
}

void QueryId::SharedCtor() {
  ::memset(&part1_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&part2_) -
      reinterpret_cast<char*>(&part1_)) + sizeof(part2_));
}

QueryId::~QueryId() {
  // @@protoc_insertion_point(destructor:exec.shared.QueryId)
  SharedDtor();
}

void QueryId::SharedDtor() {
}

void QueryId::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const QueryId& QueryId::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_QueryId_UserBitShared_2eproto.base);
  return *internal_default_instance();
}


void QueryId::Clear() {
// @@protoc_insertion_point(message_clear_start:exec.shared.QueryId)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    ::memset(&part1_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&part2_) -
        reinterpret_cast<char*>(&part1_)) + sizeof(part2_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* QueryId::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional sfixed64 part1 = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 9)) {
          _Internal::set_has_part1(&has_bits);
          part1_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::int64>(ptr);
          ptr += sizeof(::PROTOBUF_NAMESPACE_ID::int64);
        } else goto handle_unusual;
        continue;
      // optional sfixed64 part2 = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 17)) {
          _Internal::set_has_part2(&has_bits);
          part2_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::int64>(ptr);
          ptr += sizeof(::PROTOBUF_NAMESPACE_ID::int64);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* QueryId::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:exec.shared.QueryId)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional sfixed64 part1 = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteSFixed64ToArray(1, this->_internal_part1(), target);
  }

  // optional sfixed64 part2 = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteSFixed64ToArray(2, this->_internal_part2(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:exec.shared.QueryId)
  return target;
}

size_t QueryId::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:exec.shared.QueryId)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional sfixed64 part1 = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 + 8;
    }

    // optional sfixed64 part2 = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 + 8;
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void QueryId::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:exec.shared.QueryId)
  GOOGLE_DCHECK_NE(&from, this);
  const QueryId* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<QueryId>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:exec.shared.QueryId)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:exec.shared.QueryId)
    MergeFrom(*source);
  }
}

void QueryId::MergeFrom(const QueryId& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:exec.shared.QueryId)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      part1_ = from.part1_;
    }
    if (cached_has_bits & 0x00000002u) {
      part2_ = from.part2_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void QueryId::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:exec.shared.QueryId)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void QueryId::CopyFrom(const QueryId& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:exec.shared.QueryId)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool QueryId::IsInitialized() const {
  return true;
}

void QueryId::InternalSwap(QueryId* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(part1_, other->part1_);
  swap(part2_, other->part2_);
}

::PROTOBUF_NAMESPACE_ID::Metadata QueryId::GetMetadata() const {
  return GetMetadataStatic();
}


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

void DrillPBError::InitAsDefaultInstance() {
  ::exec::shared::_DrillPBError_default_instance_._instance.get_mutable()->endpoint_ = const_cast< ::exec::DrillbitEndpoint*>(
      ::exec::DrillbitEndpoint::internal_default_instance());
  ::exec::shared::_DrillPBError_default_instance_._instance.get_mutable()->exception_ = const_cast< ::exec::shared::ExceptionWrapper*>(
      ::exec::shared::ExceptionWrapper::internal_default_instance());
}
class DrillPBError::_Internal {
 public:
  using HasBits = decltype(std::declval<DrillPBError>()._has_bits_);
  static void set_has_error_id(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::exec::DrillbitEndpoint& endpoint(const DrillPBError* msg);
  static void set_has_endpoint(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_error_type(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_message(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static const ::exec::shared::ExceptionWrapper& exception(const DrillPBError* msg);
  static void set_has_exception(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
};

const ::exec::DrillbitEndpoint&
DrillPBError::_Internal::endpoint(const DrillPBError* msg) {
  return *msg->endpoint_;
}
const ::exec::shared::ExceptionWrapper&
DrillPBError::_Internal::exception(const DrillPBError* msg) {
  return *msg->exception_;
}
void DrillPBError::clear_endpoint() {
  if (endpoint_ != nullptr) endpoint_->Clear();
  _has_bits_[0] &= ~0x00000004u;
}
DrillPBError::DrillPBError()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:exec.shared.DrillPBError)
}
DrillPBError::DrillPBError(const DrillPBError& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      parsing_error_(from.parsing_error_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  error_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_error_id()) {
    error_id_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.error_id_);
  }
  message_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_message()) {
    message_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.message_);
  }
  if (from._internal_has_endpoint()) {
    endpoint_ = new ::exec::DrillbitEndpoint(*from.endpoint_);
  } else {
    endpoint_ = nullptr;
  }
  if (from._internal_has_exception()) {
    exception_ = new ::exec::shared::ExceptionWrapper(*from.exception_);
  } else {
    exception_ = nullptr;
  }
  error_type_ = from.error_type_;
  // @@protoc_insertion_point(copy_constructor:exec.shared.DrillPBError)
}

void DrillPBError::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_DrillPBError_UserBitShared_2eproto.base);
  error_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  message_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&endpoint_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&error_type_) -
      reinterpret_cast<char*>(&endpoint_)) + sizeof(error_type_));
}

DrillPBError::~DrillPBError() {
  // @@protoc_insertion_point(destructor:exec.shared.DrillPBError)
  SharedDtor();
}

void DrillPBError::SharedDtor() {
  error_id_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  message_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete endpoint_;
  if (this != internal_default_instance()) delete exception_;
}

void DrillPBError::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const DrillPBError& DrillPBError::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_DrillPBError_UserBitShared_2eproto.base);
  return *internal_default_instance();
}


void DrillPBError::Clear() {
// @@protoc_insertion_point(message_clear_start:exec.shared.DrillPBError)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  parsing_error_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      error_id_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000002u) {
      message_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000004u) {
      GOOGLE_DCHECK(endpoint_ != nullptr);
      endpoint_->Clear();
    }
    if (cached_has_bits & 0x00000008u) {
      GOOGLE_DCHECK(exception_ != nullptr);
      exception_->Clear();
    }
  }
  error_type_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* DrillPBError::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional string error_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_error_id();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "exec.shared.DrillPBError.error_id");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .exec.DrillbitEndpoint endpoint = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_endpoint(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .exec.shared.DrillPBError.ErrorType error_type = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::exec::shared::DrillPBError_ErrorType_IsValid(val))) {
            _internal_set_error_type(static_cast<::exec::shared::DrillPBError_ErrorType>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional string message = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          auto str = _internal_mutable_message();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "exec.shared.DrillPBError.message");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .exec.shared.ExceptionWrapper exception = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_exception(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .exec.shared.ParsingError parsing_error = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_parsing_error(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* DrillPBError::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:exec.shared.DrillPBError)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string error_id = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_error_id().data(), static_cast<int>(this->_internal_error_id().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "exec.shared.DrillPBError.error_id");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_error_id(), target);
  }

  // optional .exec.DrillbitEndpoint endpoint = 2;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::endpoint(this), target, stream);
  }

  // optional .exec.shared.DrillPBError.ErrorType error_type = 3;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      3, this->_internal_error_type(), target);
  }

  // optional string message = 4;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_message().data(), static_cast<int>(this->_internal_message().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "exec.shared.DrillPBError.message");
    target = stream->WriteStringMaybeAliased(
        4, this->_internal_message(), target);
  }

  // optional .exec.shared.ExceptionWrapper exception = 5;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        5, _Internal::exception(this), target, stream);
  }

  // repeated .exec.shared.ParsingError parsing_error = 6;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_parsing_error_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(6, this->_internal_parsing_error(i), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:exec.shared.DrillPBError)
  return target;
}

size_t DrillPBError::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:exec.shared.DrillPBError)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .exec.shared.ParsingError parsing_error = 6;
  total_size += 1UL * this->_internal_parsing_error_size();
  for (const auto& msg : this->parsing_error_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    // optional string error_id = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_error_id());
    }

    // optional string message = 4;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_message());
    }

    // optional .exec.DrillbitEndpoint endpoint = 2;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *endpoint_);
    }

    // optional .exec.shared.ExceptionWrapper exception = 5;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *exception_);
    }

    // optional .exec.shared.DrillPBError.ErrorType error_type = 3;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_error_type());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void DrillPBError::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:exec.shared.DrillPBError)
  GOOGLE_DCHECK_NE(&from, this);
  const DrillPBError* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<DrillPBError>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:exec.shared.DrillPBError)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:exec.shared.DrillPBError)
    MergeFrom(*source);
  }
}

void DrillPBError::MergeFrom(const DrillPBError& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:exec.shared.DrillPBError)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  parsing_error_.MergeFrom(from.parsing_error_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      error_id_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.error_id_);
    }
    if (cached_has_bits & 0x00000002u) {
      _has_bits_[0] |= 0x00000002u;
      message_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.message_);
    }
    if (cached_has_bits & 0x00000004u) {
      _internal_mutable_endpoint()->::exec::DrillbitEndpoint::MergeFrom(from._internal_endpoint());
    }
    if (cached_has_bits & 0x00000008u) {
      _internal_mutable_exception()->::exec::shared::ExceptionWrapper::MergeFrom(from._internal_exception());
    }
    if (cached_has_bits & 0x00000010u) {
      error_type_ = from.error_type_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void DrillPBError::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:exec.shared.DrillPBError)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void DrillPBError::CopyFrom(const DrillPBError& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:exec.shared.DrillPBError)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DrillPBError::IsInitialized() const {
  return true;
}

void DrillPBError::InternalSwap(DrillPBError* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  parsing_error_.InternalSwap(&other->parsing_error_);
  error_id_.Swap(&other->error_id_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  message_.Swap(&other->message_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(endpoint_, other->endpoint_);
  swap(exception_, other->exception_);
  swap(error_type_, other->error_type_);
}

::PROTOBUF_NAMESPACE_ID::Metadata DrillPBError::GetMetadata() const {
  return GetMetadataStatic();
}


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

void ExceptionWrapper::InitAsDefaultInstance() {
  ::exec::shared::_ExceptionWrapper_default_instance_._instance.get_mutable()->cause_ = const_cast< ::exec::shared::ExceptionWrapper*>(
      ::exec::shared::ExceptionWrapper::internal_default_instance());
}
class ExceptionWrapper::_Internal {
 public:
  using HasBits = decltype(std::declval<ExceptionWrapper>()._has_bits_);
  static void set_has_exception_class(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_message(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static const ::exec::shared::ExceptionWrapper& cause(const ExceptionWrapper* msg);
  static void set_has_cause(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
};

const ::exec::shared::ExceptionWrapper&
ExceptionWrapper::_Internal::cause(const ExceptionWrapper* msg) {
  return *msg->cause_;
}
ExceptionWrapper::ExceptionWrapper()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:exec.shared.ExceptionWrapper)
}
ExceptionWrapper::ExceptionWrapper(const ExceptionWrapper& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      stack_trace_(from.stack_trace_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  exception_class_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_exception_class()) {
    exception_class_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.exception_class_);
  }
  message_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_message()) {
    message_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.message_);
  }
  if (from._internal_has_cause()) {
    cause_ = new ::exec::shared::ExceptionWrapper(*from.cause_);
  } else {
    cause_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:exec.shared.ExceptionWrapper)
}

void ExceptionWrapper::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ExceptionWrapper_UserBitShared_2eproto.base);
  exception_class_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  message_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  cause_ = nullptr;
}

ExceptionWrapper::~ExceptionWrapper() {
  // @@protoc_insertion_point(destructor:exec.shared.ExceptionWrapper)
  SharedDtor();
}

void ExceptionWrapper::SharedDtor() {
  exception_class_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  message_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete cause_;
}

void ExceptionWrapper::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const ExceptionWrapper& ExceptionWrapper::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ExceptionWrapper_UserBitShared_2eproto.base);
  return *internal_default_instance();
}


void ExceptionWrapper::Clear() {
// @@protoc_insertion_point(message_clear_start:exec.shared.ExceptionWrapper)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  stack_trace_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      exception_class_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000002u) {
      message_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000004u) {
      GOOGLE_DCHECK(cause_ != nullptr);
      cause_->Clear();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* ExceptionWrapper::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional string exception_class = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_exception_class();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "exec.shared.ExceptionWrapper.exception_class");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string message = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_message();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "exec.shared.ExceptionWrapper.message");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .exec.shared.StackTraceElementWrapper stack_trace = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_stack_trace(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
        } else goto handle_unusual;
        continue;
      // optional .exec.shared.ExceptionWrapper cause = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_cause(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* ExceptionWrapper::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:exec.shared.ExceptionWrapper)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string exception_class = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_exception_class().data(), static_cast<int>(this->_internal_exception_class().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "exec.shared.ExceptionWrapper.exception_class");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_exception_class(), target);
  }

  // optional string message = 2;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_message().data(), static_cast<int>(this->_internal_message().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "exec.shared.ExceptionWrapper.message");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_message(), target);
  }

  // repeated .exec.shared.StackTraceElementWrapper stack_trace = 3;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_stack_trace_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(3, this->_internal_stack_trace(i), target, stream);
  }

  // optional .exec.shared.ExceptionWrapper cause = 4;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        4, _Internal::cause(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:exec.shared.ExceptionWrapper)
  return target;
}

size_t ExceptionWrapper::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:exec.shared.ExceptionWrapper)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .exec.shared.StackTraceElementWrapper stack_trace = 3;
  total_size += 1UL * this->_internal_stack_trace_size();
  for (const auto& msg : this->stack_trace_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    // optional string exception_class = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_exception_class());
    }

    // optional string message = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_message());
    }

    // optional .exec.shared.ExceptionWrapper cause = 4;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *cause_);
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void ExceptionWrapper::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:exec.shared.ExceptionWrapper)
  GOOGLE_DCHECK_NE(&from, this);
  const ExceptionWrapper* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ExceptionWrapper>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:exec.shared.ExceptionWrapper)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:exec.shared.ExceptionWrapper)
    MergeFrom(*source);
  }
}

void ExceptionWrapper::MergeFrom(const ExceptionWrapper& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:exec.shared.ExceptionWrapper)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  stack_trace_.MergeFrom(from.stack_trace_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      exception_class_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.exception_class_);
    }
    if (cached_has_bits & 0x00000002u) {
      _has_bits_[0] |= 0x00000002u;
      message_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.message_);
    }
    if (cached_has_bits & 0x00000004u) {
      _internal_mutable_cause()->::exec::shared::ExceptionWrapper::MergeFrom(from._internal_cause());
    }
  }
}

void ExceptionWrapper::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:exec.shared.ExceptionWrapper)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ExceptionWrapper::CopyFrom(const ExceptionWrapper& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:exec.shared.ExceptionWrapper)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ExceptionWrapper::IsInitialized() const {
  return true;
}

void ExceptionWrapper::InternalSwap(ExceptionWrapper* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  stack_trace_.InternalSwap(&other->stack_trace_);
  exception_class_.Swap(&other->exception_class_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  message_.Swap(&other->message_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(cause_, other->cause_);
}

::PROTOBUF_NAMESPACE_ID::Metadata ExceptionWrapper::GetMetadata() const {
  return GetMetadataStatic();
}


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

void StackTraceElementWrapper::InitAsDefaultInstance() {
}
class StackTraceElementWrapper::_Internal {
 public:
  using HasBits = decltype(std::declval<StackTraceElementWrapper>()._has_bits_);
  static void set_has_class_name(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_file_name(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_line_number(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_method_name(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_is_native_method(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
};

StackTraceElementWrapper::StackTraceElementWrapper()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:exec.shared.StackTraceElementWrapper)
}
StackTraceElementWrapper::StackTraceElementWrapper(const StackTraceElementWrapper& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  class_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_class_name()) {
    class_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.class_name_);
  }
  file_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_file_name()) {
    file_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.file_name_);
  }
  method_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_method_name()) {
    method_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.method_name_);
  }
  ::memcpy(&line_number_, &from.line_number_,
    static_cast<size_t>(reinterpret_cast<char*>(&is_native_method_) -
    reinterpret_cast<char*>(&line_number_)) + sizeof(is_native_method_));
  // @@protoc_insertion_point(copy_constructor:exec.shared.StackTraceElementWrapper)
}

void StackTraceElementWrapper::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_StackTraceElementWrapper_UserBitShared_2eproto.base);
  class_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  file_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  method_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&line_number_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&is_native_method_) -
      reinterpret_cast<char*>(&line_number_)) + sizeof(is_native_method_));
}

StackTraceElementWrapper::~StackTraceElementWrapper() {
  // @@protoc_insertion_point(destructor:exec.shared.StackTraceElementWrapper)
  SharedDtor();
}

void StackTraceElementWrapper::SharedDtor() {
  class_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  file_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  method_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void StackTraceElementWrapper::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const StackTraceElementWrapper& StackTraceElementWrapper::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_StackTraceElementWrapper_UserBitShared_2eproto.base);
  return *internal_default_instance();
}


void StackTraceElementWrapper::Clear() {
// @@protoc_insertion_point(message_clear_start:exec.shared.StackTraceElementWrapper)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      class_name_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000002u) {
      file_name_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000004u) {
      method_name_.ClearNonDefaultToEmptyNoArena();
    }
  }
  if (cached_has_bits & 0x00000018u) {
    ::memset(&line_number_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&is_native_method_) -
        reinterpret_cast<char*>(&line_number_)) + sizeof(is_native_method_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* StackTraceElementWrapper::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional string class_name = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_class_name();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "exec.shared.StackTraceElementWrapper.class_name");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string file_name = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_file_name();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "exec.shared.StackTraceElementWrapper.file_name");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 line_number = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_line_number(&has_bits);
          line_number_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string method_name = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          auto str = _internal_mutable_method_name();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "exec.shared.StackTraceElementWrapper.method_name");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool is_native_method = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          _Internal::set_has_is_native_method(&has_bits);
          is_native_method_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* StackTraceElementWrapper::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:exec.shared.StackTraceElementWrapper)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string class_name = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_class_name().data(), static_cast<int>(this->_internal_class_name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "exec.shared.StackTraceElementWrapper.class_name");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_class_name(), target);
  }

  // optional string file_name = 2;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_file_name().data(), static_cast<int>(this->_internal_file_name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "exec.shared.StackTraceElementWrapper.file_name");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_file_name(), target);
  }

  // optional int32 line_number = 3;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_line_number(), target);
  }

  // optional string method_name = 4;
  if (cached_has_bits & 0x00000004u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_method_name().data(), static_cast<int>(this->_internal_method_name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "exec.shared.StackTraceElementWrapper.method_name");
    target = stream->WriteStringMaybeAliased(
        4, this->_internal_method_name(), target);
  }

  // optional bool is_native_method = 5;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(5, this->_internal_is_native_method(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:exec.shared.StackTraceElementWrapper)
  return target;
}

size_t StackTraceElementWrapper::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:exec.shared.StackTraceElementWrapper)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    // optional string class_name = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_class_name());
    }

    // optional string file_name = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_file_name());
    }

    // optional string method_name = 4;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_method_name());
    }

    // optional int32 line_number = 3;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_line_number());
    }

    // optional bool is_native_method = 5;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 + 1;
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void StackTraceElementWrapper::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:exec.shared.StackTraceElementWrapper)
  GOOGLE_DCHECK_NE(&from, this);
  const StackTraceElementWrapper* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<StackTraceElementWrapper>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:exec.shared.StackTraceElementWrapper)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:exec.shared.StackTraceElementWrapper)
    MergeFrom(*source);
  }
}

void StackTraceElementWrapper::MergeFrom(const StackTraceElementWrapper& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:exec.shared.StackTraceElementWrapper)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      class_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.class_name_);
    }
    if (cached_has_bits & 0x00000002u) {
      _has_bits_[0] |= 0x00000002u;
      file_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.file_name_);
    }
    if (cached_has_bits & 0x00000004u) {
      _has_bits_[0] |= 0x00000004u;
      method_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.method_name_);
    }
    if (cached_has_bits & 0x00000008u) {
      line_number_ = from.line_number_;
    }
    if (cached_has_bits & 0x00000010u) {
      is_native_method_ = from.is_native_method_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void StackTraceElementWrapper::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:exec.shared.StackTraceElementWrapper)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void StackTraceElementWrapper::CopyFrom(const StackTraceElementWrapper& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:exec.shared.StackTraceElementWrapper)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool StackTraceElementWrapper::IsInitialized() const {
  return true;
}

void StackTraceElementWrapper::InternalSwap(StackTraceElementWrapper* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  class_name_.Swap(&other->class_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  file_name_.Swap(&other->file_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  method_name_.Swap(&other->method_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(line_number_, other->line_number_);
  swap(is_native_method_, other->is_native_method_);
}

::PROTOBUF_NAMESPACE_ID::Metadata StackTraceElementWrapper::GetMetadata() const {
  return GetMetadataStatic();
}


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

void ParsingError::InitAsDefaultInstance() {
}
class ParsingError::_Internal {
 public:
  using HasBits = decltype(std::declval<ParsingError>()._has_bits_);
  static void set_has_start_column(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_start_row(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_end_column(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_end_row(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
};

ParsingError::ParsingError()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:exec.shared.ParsingError)
}
ParsingError::ParsingError(const ParsingError& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&start_column_, &from.start_column_,
    static_cast<size_t>(reinterpret_cast<char*>(&end_row_) -
    reinterpret_cast<char*>(&start_column_)) + sizeof(end_row_));
  // @@protoc_insertion_point(copy_constructor:exec.shared.ParsingError)
}

void ParsingError::SharedCtor() {
  ::memset(&start_column_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&end_row_) -
      reinterpret_cast<char*>(&start_column_)) + sizeof(end_row_));
}

ParsingError::~ParsingError() {
  // @@protoc_insertion_point(destructor:exec.shared.ParsingError)
  SharedDtor();
}

void ParsingError::SharedDtor() {
}

void ParsingError::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const ParsingError& ParsingError::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ParsingError_UserBitShared_2eproto.base);
  return *internal_default_instance();
}


void ParsingError::Clear() {
// @@protoc_insertion_point(message_clear_start:exec.shared.ParsingError)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    ::memset(&start_column_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&end_row_) -
        reinterpret_cast<char*>(&start_column_)) + sizeof(end_row_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* ParsingError::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional int32 start_column = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_start_column(&has_bits);
          start_column_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 start_row = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_start_row(&has_bits);
          start_row_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 end_column = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_end_column(&has_bits);
          end_column_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 end_row = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          _Internal::set_has_end_row(&has_bits);
          end_row_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* ParsingError::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:exec.shared.ParsingError)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 start_column = 2;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_start_column(), target);
  }

  // optional int32 start_row = 3;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_start_row(), target);
  }

  // optional int32 end_column = 4;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_end_column(), target);
  }

  // optional int32 end_row = 5;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(5, this->_internal_end_row(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:exec.shared.ParsingError)
  return target;
}

size_t ParsingError::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:exec.shared.ParsingError)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    // optional int32 start_column = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_start_column());
    }

    // optional int32 start_row = 3;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_start_row());
    }

    // optional int32 end_column = 4;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_end_column());
    }

    // optional int32 end_row = 5;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_end_row());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void ParsingError::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:exec.shared.ParsingError)
  GOOGLE_DCHECK_NE(&from, this);
  const ParsingError* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ParsingError>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:exec.shared.ParsingError)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:exec.shared.ParsingError)
    MergeFrom(*source);
  }
}

void ParsingError::MergeFrom(const ParsingError& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:exec.shared.ParsingError)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      start_column_ = from.start_column_;
    }
    if (cached_has_bits & 0x00000002u) {
      start_row_ = from.start_row_;
    }
    if (cached_has_bits & 0x00000004u) {
      end_column_ = from.end_column_;
    }
    if (cached_has_bits & 0x00000008u) {
      end_row_ = from.end_row_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void ParsingError::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:exec.shared.ParsingError)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ParsingError::CopyFrom(const ParsingError& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:exec.shared.ParsingError)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ParsingError::IsInitialized() const {
  return true;
}

void ParsingError::InternalSwap(ParsingError* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(start_column_, other->start_column_);
  swap(start_row_, other->start_row_);
  swap(end_column_, other->end_column_);
  swap(end_row_, other->end_row_);
}

::PROTOBUF_NAMESPACE_ID::Metadata ParsingError::GetMetadata() const {
  return GetMetadataStatic();
}


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

void RecordBatchDef::InitAsDefaultInstance() {
}
class RecordBatchDef::_Internal {
 public:
  using HasBits = decltype(std::declval<RecordBatchDef>()._has_bits_);
  static void set_has_record_count(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_carries_two_byte_selection_vector(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_affected_rows_count(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
};

RecordBatchDef::RecordBatchDef()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:exec.shared.RecordBatchDef)
}
RecordBatchDef::RecordBatchDef(const RecordBatchDef& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      field_(from.field_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&record_count_, &from.record_count_,
    static_cast<size_t>(reinterpret_cast<char*>(&affected_rows_count_) -
    reinterpret_cast<char*>(&record_count_)) + sizeof(affected_rows_count_));
  // @@protoc_insertion_point(copy_constructor:exec.shared.RecordBatchDef)
}

void RecordBatchDef::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_RecordBatchDef_UserBitShared_2eproto.base);
  ::memset(&record_count_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&affected_rows_count_) -
      reinterpret_cast<char*>(&record_count_)) + sizeof(affected_rows_count_));
}

RecordBatchDef::~RecordBatchDef() {
  // @@protoc_insertion_point(destructor:exec.shared.RecordBatchDef)
  SharedDtor();
}

void RecordBatchDef::SharedDtor() {
}

void RecordBatchDef::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const RecordBatchDef& RecordBatchDef::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_RecordBatchDef_UserBitShared_2eproto.base);
  return *internal_default_instance();
}


void RecordBatchDef::Clear() {
// @@protoc_insertion_point(message_clear_start:exec.shared.RecordBatchDef)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  field_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    ::memset(&record_count_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&affected_rows_count_) -
        reinterpret_cast<char*>(&record_count_)) + sizeof(affected_rows_count_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* RecordBatchDef::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional int32 record_count = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_record_count(&has_bits);
          record_count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .exec.shared.SerializedField field = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_field(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
        } else goto handle_unusual;
        continue;
      // optional bool carries_two_byte_selection_vector = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_carries_two_byte_selection_vector(&has_bits);
          carries_two_byte_selection_vector_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 affected_rows_count = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_affected_rows_count(&has_bits);
          affected_rows_count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* RecordBatchDef::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:exec.shared.RecordBatchDef)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 record_count = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_record_count(), target);
  }

  // repeated .exec.shared.SerializedField field = 2;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_field_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, this->_internal_field(i), target, stream);
  }

  // optional bool carries_two_byte_selection_vector = 3;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->_internal_carries_two_byte_selection_vector(), target);
  }

  // optional int32 affected_rows_count = 4;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_affected_rows_count(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:exec.shared.RecordBatchDef)
  return target;
}

size_t RecordBatchDef::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:exec.shared.RecordBatchDef)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .exec.shared.SerializedField field = 2;
  total_size += 1UL * this->_internal_field_size();
  for (const auto& msg : this->field_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    // optional int32 record_count = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_record_count());
    }

    // optional bool carries_two_byte_selection_vector = 3;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 + 1;
    }

    // optional int32 affected_rows_count = 4;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_affected_rows_count());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void RecordBatchDef::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:exec.shared.RecordBatchDef)
  GOOGLE_DCHECK_NE(&from, this);
  const RecordBatchDef* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RecordBatchDef>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:exec.shared.RecordBatchDef)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:exec.shared.RecordBatchDef)
    MergeFrom(*source);
  }
}

void RecordBatchDef::MergeFrom(const RecordBatchDef& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:exec.shared.RecordBatchDef)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  field_.MergeFrom(from.field_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      record_count_ = from.record_count_;
    }
    if (cached_has_bits & 0x00000002u) {
      carries_two_byte_selection_vector_ = from.carries_two_byte_selection_vector_;
    }
    if (cached_has_bits & 0x00000004u) {
      affected_rows_count_ = from.affected_rows_count_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void RecordBatchDef::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:exec.shared.RecordBatchDef)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RecordBatchDef::CopyFrom(const RecordBatchDef& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:exec.shared.RecordBatchDef)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RecordBatchDef::IsInitialized() const {
  return true;
}

void RecordBatchDef::InternalSwap(RecordBatchDef* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  field_.InternalSwap(&other->field_);
  swap(record_count_, other->record_count_);
  swap(carries_two_byte_selection_vector_, other->carries_two_byte_selection_vector_);
  swap(affected_rows_count_, other->affected_rows_count_);
}

::PROTOBUF_NAMESPACE_ID::Metadata RecordBatchDef::GetMetadata() const {
  return GetMetadataStatic();
}


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

void NamePart::InitAsDefaultInstance() {
  ::exec::shared::_NamePart_default_instance_._instance.get_mutable()->child_ = const_cast< ::exec::shared::NamePart*>(
      ::exec::shared::NamePart::internal_default_instance());
}
class NamePart::_Internal {
 public:
  using HasBits = decltype(std::declval<NamePart>()._has_bits_);
  static void set_has_type(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_name(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::exec::shared::NamePart& child(const NamePart* msg);
  static void set_has_child(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

const ::exec::shared::NamePart&
NamePart::_Internal::child(const NamePart* msg) {
  return *msg->child_;
}
NamePart::NamePart()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:exec.shared.NamePart)
}
NamePart::NamePart(const NamePart& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_name()) {
    name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_);
  }
  if (from._internal_has_child()) {
    child_ = new ::exec::shared::NamePart(*from.child_);
  } else {
    child_ = nullptr;
  }
  type_ = from.type_;
  // @@protoc_insertion_point(copy_constructor:exec.shared.NamePart)
}

void NamePart::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_NamePart_UserBitShared_2eproto.base);
  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&child_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&type_) -
      reinterpret_cast<char*>(&child_)) + sizeof(type_));
}

NamePart::~NamePart() {
  // @@protoc_insertion_point(destructor:exec.shared.NamePart)
  SharedDtor();
}

void NamePart::SharedDtor() {
  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete child_;
}

void NamePart::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const NamePart& NamePart::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_NamePart_UserBitShared_2eproto.base);
  return *internal_default_instance();
}


void NamePart::Clear() {
// @@protoc_insertion_point(message_clear_start:exec.shared.NamePart)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      name_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(child_ != nullptr);
      child_->Clear();
    }
  }
  type_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* NamePart::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional .exec.shared.NamePart.Type type = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::exec::shared::NamePart_Type_IsValid(val))) {
            _internal_set_type(static_cast<::exec::shared::NamePart_Type>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional string name = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_name();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "exec.shared.NamePart.name");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .exec.shared.NamePart child = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_child(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* NamePart::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:exec.shared.NamePart)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .exec.shared.NamePart.Type type = 1;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_type(), target);
  }

  // optional string name = 2;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "exec.shared.NamePart.name");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_name(), target);
  }

  // optional .exec.shared.NamePart child = 3;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::child(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:exec.shared.NamePart)
  return target;
}

size_t NamePart::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:exec.shared.NamePart)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    // optional string name = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_name());
    }

    // optional .exec.shared.NamePart child = 3;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *child_);
    }

    // optional .exec.shared.NamePart.Type type = 1;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void NamePart::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:exec.shared.NamePart)
  GOOGLE_DCHECK_NE(&from, this);
  const NamePart* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<NamePart>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:exec.shared.NamePart)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:exec.shared.NamePart)
    MergeFrom(*source);
  }
}

void NamePart::MergeFrom(const NamePart& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:exec.shared.NamePart)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_);
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_child()->::exec::shared::NamePart::MergeFrom(from._internal_child());
    }
    if (cached_has_bits & 0x00000004u) {
      type_ = from.type_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void NamePart::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:exec.shared.NamePart)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void NamePart::CopyFrom(const NamePart& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:exec.shared.NamePart)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool NamePart::IsInitialized() const {
  return true;
}

void NamePart::InternalSwap(NamePart* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(child_, other->child_);
  swap(type_, other->type_);
}

::PROTOBUF_NAMESPACE_ID::Metadata NamePart::GetMetadata() const {
  return GetMetadataStatic();
}


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

void SerializedField::InitAsDefaultInstance() {
  ::exec::shared::_SerializedField_default_instance_._instance.get_mutable()->major_type_ = const_cast< ::common::MajorType*>(
      ::common::MajorType::internal_default_instance());
  ::exec::shared::_SerializedField_default_instance_._instance.get_mutable()->name_part_ = const_cast< ::exec::shared::NamePart*>(
      ::exec::shared::NamePart::internal_default_instance());
}
class SerializedField::_Internal {
 public:
  using HasBits = decltype(std::declval<SerializedField>()._has_bits_);
  static const ::common::MajorType& major_type(const SerializedField* msg);
  static void set_has_major_type(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::exec::shared::NamePart& name_part(const SerializedField* msg);
  static void set_has_name_part(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_value_count(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_var_byte_length(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_buffer_length(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
};

const ::common::MajorType&
SerializedField::_Internal::major_type(const SerializedField* msg) {
  return *msg->major_type_;
}
const ::exec::shared::NamePart&
SerializedField::_Internal::name_part(const SerializedField* msg) {
  return *msg->name_part_;
}
void SerializedField::clear_major_type() {
  if (major_type_ != nullptr) major_type_->Clear();
  _has_bits_[0] &= ~0x00000001u;
}
SerializedField::SerializedField()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:exec.shared.SerializedField)
}
SerializedField::SerializedField(const SerializedField& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      child_(from.child_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from._internal_has_major_type()) {
    major_type_ = new ::common::MajorType(*from.major_type_);
  } else {
    major_type_ = nullptr;
  }
  if (from._internal_has_name_part()) {
    name_part_ = new ::exec::shared::NamePart(*from.name_part_);
  } else {
    name_part_ = nullptr;
  }
  ::memcpy(&value_count_, &from.value_count_,
    static_cast<size_t>(reinterpret_cast<char*>(&buffer_length_) -
    reinterpret_cast<char*>(&value_count_)) + sizeof(buffer_length_));
  // @@protoc_insertion_point(copy_constructor:exec.shared.SerializedField)
}

void SerializedField::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_SerializedField_UserBitShared_2eproto.base);
  ::memset(&major_type_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&buffer_length_) -
      reinterpret_cast<char*>(&major_type_)) + sizeof(buffer_length_));
}

SerializedField::~SerializedField() {
  // @@protoc_insertion_point(destructor:exec.shared.SerializedField)
  SharedDtor();
}

void SerializedField::SharedDtor() {
  if (this != internal_default_instance()) delete major_type_;
  if (this != internal_default_instance()) delete name_part_;
}

void SerializedField::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const SerializedField& SerializedField::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_SerializedField_UserBitShared_2eproto.base);
  return *internal_default_instance();
}


void SerializedField::Clear() {
// @@protoc_insertion_point(message_clear_start:exec.shared.SerializedField)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  child_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(major_type_ != nullptr);
      major_type_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(name_part_ != nullptr);
      name_part_->Clear();
    }
  }
  if (cached_has_bits & 0x0000001cu) {
    ::memset(&value_count_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&buffer_length_) -
        reinterpret_cast<char*>(&value_count_)) + sizeof(buffer_length_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* SerializedField::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional .common.MajorType major_type = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_major_type(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .exec.shared.NamePart name_part = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_name_part(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .exec.shared.SerializedField child = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_child(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
        } else goto handle_unusual;
        continue;
      // optional int32 value_count = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_value_count(&has_bits);
          value_count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 var_byte_length = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          _Internal::set_has_var_byte_length(&has_bits);
          var_byte_length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 buffer_length = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) {
          _Internal::set_has_buffer_length(&has_bits);
          buffer_length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* SerializedField::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:exec.shared.SerializedField)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .common.MajorType major_type = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::major_type(this), target, stream);
  }

  // optional .exec.shared.NamePart name_part = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::name_part(this), target, stream);
  }

  // repeated .exec.shared.SerializedField child = 3;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_child_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(3, this->_internal_child(i), target, stream);
  }

  // optional int32 value_count = 4;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_value_count(), target);
  }

  // optional int32 var_byte_length = 5;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(5, this->_internal_var_byte_length(), target);
  }

  // optional int32 buffer_length = 7;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(7, this->_internal_buffer_length(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:exec.shared.SerializedField)
  return target;
}

size_t SerializedField::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:exec.shared.SerializedField)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .exec.shared.SerializedField child = 3;
  total_size += 1UL * this->_internal_child_size();
  for (const auto& msg : this->child_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    // optional .common.MajorType major_type = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *major_type_);
    }

    // optional .exec.shared.NamePart name_part = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *name_part_);
    }

    // optional int32 value_count = 4;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_value_count());
    }

    // optional int32 var_byte_length = 5;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_var_byte_length());
    }

    // optional int32 buffer_length = 7;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_buffer_length());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void SerializedField::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:exec.shared.SerializedField)
  GOOGLE_DCHECK_NE(&from, this);
  const SerializedField* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<SerializedField>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:exec.shared.SerializedField)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:exec.shared.SerializedField)
    MergeFrom(*source);
  }
}

void SerializedField::MergeFrom(const SerializedField& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:exec.shared.SerializedField)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  child_.MergeFrom(from.child_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_major_type()->::common::MajorType::MergeFrom(from._internal_major_type());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_name_part()->::exec::shared::NamePart::MergeFrom(from._internal_name_part());
    }
    if (cached_has_bits & 0x00000004u) {
      value_count_ = from.value_count_;
    }
    if (cached_has_bits & 0x00000008u) {
      var_byte_length_ = from.var_byte_length_;
    }
    if (cached_has_bits & 0x00000010u) {
      buffer_length_ = from.buffer_length_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void SerializedField::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:exec.shared.SerializedField)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void SerializedField::CopyFrom(const SerializedField& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:exec.shared.SerializedField)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SerializedField::IsInitialized() const {
  return true;
}

void SerializedField::InternalSwap(SerializedField* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  child_.InternalSwap(&other->child_);
  swap(major_type_, other->major_type_);
  swap(name_part_, other->name_part_);
  swap(value_count_, other->value_count_);
  swap(var_byte_length_, other->var_byte_length_);
  swap(buffer_length_, other->buffer_length_);
}

::PROTOBUF_NAMESPACE_ID::Metadata SerializedField::GetMetadata() const {
  return GetMetadataStatic();
}


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

void NodeStatus::InitAsDefaultInstance() {
}
class NodeStatus::_Internal {
 public:
  using HasBits = decltype(std::declval<NodeStatus>()._has_bits_);
  static void set_has_node_id(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_memory_footprint(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

NodeStatus::NodeStatus()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:exec.shared.NodeStatus)
}
NodeStatus::NodeStatus(const NodeStatus& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&memory_footprint_, &from.memory_footprint_,
    static_cast<size_t>(reinterpret_cast<char*>(&node_id_) -
    reinterpret_cast<char*>(&memory_footprint_)) + sizeof(node_id_));
  // @@protoc_insertion_point(copy_constructor:exec.shared.NodeStatus)
}

void NodeStatus::SharedCtor() {
  ::memset(&memory_footprint_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&node_id_) -
      reinterpret_cast<char*>(&memory_footprint_)) + sizeof(node_id_));
}

NodeStatus::~NodeStatus() {
  // @@protoc_insertion_point(destructor:exec.shared.NodeStatus)
  SharedDtor();
}

void NodeStatus::SharedDtor() {
}

void NodeStatus::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const NodeStatus& NodeStatus::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_NodeStatus_UserBitShared_2eproto.base);
  return *internal_default_instance();
}


void NodeStatus::Clear() {
// @@protoc_insertion_point(message_clear_start:exec.shared.NodeStatus)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    ::memset(&memory_footprint_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&node_id_) -
        reinterpret_cast<char*>(&memory_footprint_)) + sizeof(node_id_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* NodeStatus::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional int32 node_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_node_id(&has_bits);
          node_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int64 memory_footprint = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_memory_footprint(&has_bits);
          memory_footprint_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* NodeStatus::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:exec.shared.NodeStatus)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 node_id = 1;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_node_id(), target);
  }

  // optional int64 memory_footprint = 2;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->_internal_memory_footprint(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:exec.shared.NodeStatus)
  return target;
}

size_t NodeStatus::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:exec.shared.NodeStatus)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional int64 memory_footprint = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
          this->_internal_memory_footprint());
    }

    // optional int32 node_id = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_node_id());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void NodeStatus::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:exec.shared.NodeStatus)
  GOOGLE_DCHECK_NE(&from, this);
  const NodeStatus* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<NodeStatus>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:exec.shared.NodeStatus)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:exec.shared.NodeStatus)
    MergeFrom(*source);
  }
}

void NodeStatus::MergeFrom(const NodeStatus& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:exec.shared.NodeStatus)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      memory_footprint_ = from.memory_footprint_;
    }
    if (cached_has_bits & 0x00000002u) {
      node_id_ = from.node_id_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void NodeStatus::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:exec.shared.NodeStatus)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void NodeStatus::CopyFrom(const NodeStatus& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:exec.shared.NodeStatus)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool NodeStatus::IsInitialized() const {
  return true;
}

void NodeStatus::InternalSwap(NodeStatus* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(memory_footprint_, other->memory_footprint_);
  swap(node_id_, other->node_id_);
}

::PROTOBUF_NAMESPACE_ID::Metadata NodeStatus::GetMetadata() const {
  return GetMetadataStatic();
}


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

void QueryResult::InitAsDefaultInstance() {
  ::exec::shared::_QueryResult_default_instance_._instance.get_mutable()->query_id_ = const_cast< ::exec::shared::QueryId*>(
      ::exec::shared::QueryId::internal_default_instance());
}
class QueryResult::_Internal {
 public:
  using HasBits = decltype(std::declval<QueryResult>()._has_bits_);
  static void set_has_query_state(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static const ::exec::shared::QueryId& query_id(const QueryResult* msg);
  static void set_has_query_id(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::exec::shared::QueryId&
QueryResult::_Internal::query_id(const QueryResult* msg) {
  return *msg->query_id_;
}
QueryResult::QueryResult()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:exec.shared.QueryResult)
}
QueryResult::QueryResult(const QueryResult& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      error_(from.error_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from._internal_has_query_id()) {
    query_id_ = new ::exec::shared::QueryId(*from.query_id_);
  } else {
    query_id_ = nullptr;
  }
  query_state_ = from.query_state_;
  // @@protoc_insertion_point(copy_constructor:exec.shared.QueryResult)
}

void QueryResult::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_QueryResult_UserBitShared_2eproto.base);
  ::memset(&query_id_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&query_state_) -
      reinterpret_cast<char*>(&query_id_)) + sizeof(query_state_));
}

QueryResult::~QueryResult() {
  // @@protoc_insertion_point(destructor:exec.shared.QueryResult)
  SharedDtor();
}

void QueryResult::SharedDtor() {
  if (this != internal_default_instance()) delete query_id_;
}

void QueryResult::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const QueryResult& QueryResult::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_QueryResult_UserBitShared_2eproto.base);
  return *internal_default_instance();
}


void QueryResult::Clear() {
// @@protoc_insertion_point(message_clear_start:exec.shared.QueryResult)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  error_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(query_id_ != nullptr);
    query_id_->Clear();
  }
  query_state_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* QueryResult::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional .exec.shared.QueryResult.QueryState query_state = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::exec::shared::QueryResult_QueryState_IsValid(val))) {
            _internal_set_query_state(static_cast<::exec::shared::QueryResult_QueryState>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional .exec.shared.QueryId query_id = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_query_id(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .exec.shared.DrillPBError error = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_error(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* QueryResult::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:exec.shared.QueryResult)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .exec.shared.QueryResult.QueryState query_state = 1;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_query_state(), target);
  }

  // optional .exec.shared.QueryId query_id = 2;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::query_id(this), target, stream);
  }

  // repeated .exec.shared.DrillPBError error = 3;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_error_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(3, this->_internal_error(i), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:exec.shared.QueryResult)
  return target;
}

size_t QueryResult::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:exec.shared.QueryResult)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .exec.shared.DrillPBError error = 3;
  total_size += 1UL * this->_internal_error_size();
  for (const auto& msg : this->error_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional .exec.shared.QueryId query_id = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *query_id_);
    }

    // optional .exec.shared.QueryResult.QueryState query_state = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_query_state());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void QueryResult::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:exec.shared.QueryResult)
  GOOGLE_DCHECK_NE(&from, this);
  const QueryResult* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<QueryResult>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:exec.shared.QueryResult)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:exec.shared.QueryResult)
    MergeFrom(*source);
  }
}

void QueryResult::MergeFrom(const QueryResult& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:exec.shared.QueryResult)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  error_.MergeFrom(from.error_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_query_id()->::exec::shared::QueryId::MergeFrom(from._internal_query_id());
    }
    if (cached_has_bits & 0x00000002u) {
      query_state_ = from.query_state_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void QueryResult::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:exec.shared.QueryResult)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void QueryResult::CopyFrom(const QueryResult& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:exec.shared.QueryResult)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool QueryResult::IsInitialized() const {
  return true;
}

void QueryResult::InternalSwap(QueryResult* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  error_.InternalSwap(&other->error_);
  swap(query_id_, other->query_id_);
  swap(query_state_, other->query_state_);
}

::PROTOBUF_NAMESPACE_ID::Metadata QueryResult::GetMetadata() const {
  return GetMetadataStatic();
}


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

void QueryData::InitAsDefaultInstance() {
  ::exec::shared::_QueryData_default_instance_._instance.get_mutable()->query_id_ = const_cast< ::exec::shared::QueryId*>(
      ::exec::shared::QueryId::internal_default_instance());
  ::exec::shared::_QueryData_default_instance_._instance.get_mutable()->def_ = const_cast< ::exec::shared::RecordBatchDef*>(
      ::exec::shared::RecordBatchDef::internal_default_instance());
}
class QueryData::_Internal {
 public:
  using HasBits = decltype(std::declval<QueryData>()._has_bits_);
  static const ::exec::shared::QueryId& query_id(const QueryData* msg);
  static void set_has_query_id(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_row_count(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static const ::exec::shared::RecordBatchDef& def(const QueryData* msg);
  static void set_has_def(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_affected_rows_count(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
};

const ::exec::shared::QueryId&
QueryData::_Internal::query_id(const QueryData* msg) {
  return *msg->query_id_;
}
const ::exec::shared::RecordBatchDef&
QueryData::_Internal::def(const QueryData* msg) {
  return *msg->def_;
}
QueryData::QueryData()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:exec.shared.QueryData)
}
QueryData::QueryData(const QueryData& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from._internal_has_query_id()) {
    query_id_ = new ::exec::shared::QueryId(*from.query_id_);
  } else {
    query_id_ = nullptr;
  }
  if (from._internal_has_def()) {
    def_ = new ::exec::shared::RecordBatchDef(*from.def_);
  } else {
    def_ = nullptr;
  }
  ::memcpy(&row_count_, &from.row_count_,
    static_cast<size_t>(reinterpret_cast<char*>(&affected_rows_count_) -
    reinterpret_cast<char*>(&row_count_)) + sizeof(affected_rows_count_));
  // @@protoc_insertion_point(copy_constructor:exec.shared.QueryData)
}

void QueryData::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_QueryData_UserBitShared_2eproto.base);
  ::memset(&query_id_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&affected_rows_count_) -
      reinterpret_cast<char*>(&query_id_)) + sizeof(affected_rows_count_));
}

QueryData::~QueryData() {
  // @@protoc_insertion_point(destructor:exec.shared.QueryData)
  SharedDtor();
}

void QueryData::SharedDtor() {
  if (this != internal_default_instance()) delete query_id_;
  if (this != internal_default_instance()) delete def_;
}

void QueryData::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const QueryData& QueryData::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_QueryData_UserBitShared_2eproto.base);
  return *internal_default_instance();
}


void QueryData::Clear() {
// @@protoc_insertion_point(message_clear_start:exec.shared.QueryData)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(query_id_ != nullptr);
      query_id_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(def_ != nullptr);
      def_->Clear();
    }
  }
  if (cached_has_bits & 0x0000000cu) {
    ::memset(&row_count_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&affected_rows_count_) -
        reinterpret_cast<char*>(&row_count_)) + sizeof(affected_rows_count_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* QueryData::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional .exec.shared.QueryId query_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_query_id(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 row_count = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_row_count(&has_bits);
          row_count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .exec.shared.RecordBatchDef def = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_def(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 affected_rows_count = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_affected_rows_count(&has_bits);
          affected_rows_count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* QueryData::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:exec.shared.QueryData)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .exec.shared.QueryId query_id = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::query_id(this), target, stream);
  }

  // optional int32 row_count = 2;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_row_count(), target);
  }

  // optional .exec.shared.RecordBatchDef def = 3;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::def(this), target, stream);
  }

  // optional int32 affected_rows_count = 4;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_affected_rows_count(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:exec.shared.QueryData)
  return target;
}

size_t QueryData::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:exec.shared.QueryData)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    // optional .exec.shared.QueryId query_id = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *query_id_);
    }

    // optional .exec.shared.RecordBatchDef def = 3;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *def_);
    }

    // optional int32 row_count = 2;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_row_count());
    }

    // optional int32 affected_rows_count = 4;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_affected_rows_count());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void QueryData::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:exec.shared.QueryData)
  GOOGLE_DCHECK_NE(&from, this);
  const QueryData* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<QueryData>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:exec.shared.QueryData)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:exec.shared.QueryData)
    MergeFrom(*source);
  }
}

void QueryData::MergeFrom(const QueryData& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:exec.shared.QueryData)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_query_id()->::exec::shared::QueryId::MergeFrom(from._internal_query_id());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_def()->::exec::shared::RecordBatchDef::MergeFrom(from._internal_def());
    }
    if (cached_has_bits & 0x00000004u) {
      row_count_ = from.row_count_;
    }
    if (cached_has_bits & 0x00000008u) {
      affected_rows_count_ = from.affected_rows_count_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void QueryData::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:exec.shared.QueryData)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void QueryData::CopyFrom(const QueryData& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:exec.shared.QueryData)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool QueryData::IsInitialized() const {
  return true;
}

void QueryData::InternalSwap(QueryData* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(query_id_, other->query_id_);
  swap(def_, other->def_);
  swap(row_count_, other->row_count_);
  swap(affected_rows_count_, other->affected_rows_count_);
}

::PROTOBUF_NAMESPACE_ID::Metadata QueryData::GetMetadata() const {
  return GetMetadataStatic();
}


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

void QueryInfo::InitAsDefaultInstance() {
  ::exec::shared::_QueryInfo_default_instance_._instance.get_mutable()->foreman_ = const_cast< ::exec::DrillbitEndpoint*>(
      ::exec::DrillbitEndpoint::internal_default_instance());
}
class QueryInfo::_Internal {
 public:
  using HasBits = decltype(std::declval<QueryInfo>()._has_bits_);
  static void set_has_query(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_start(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
  static void set_has_state(HasBits* has_bits) {
    (*has_bits)[0] |= 128u;
  }
  static void set_has_user(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static const ::exec::DrillbitEndpoint& foreman(const QueryInfo* msg);
  static void set_has_foreman(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_options_json(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_total_cost(HasBits* has_bits) {
    (*has_bits)[0] |= 64u;
  }
  static void set_has_queue_name(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
};

const ::exec::DrillbitEndpoint&
QueryInfo::_Internal::foreman(const QueryInfo* msg) {
  return *msg->foreman_;
}
::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> QueryInfo::_i_give_permission_to_break_this_code_default_user_;
void QueryInfo::clear_foreman() {
  if (foreman_ != nullptr) foreman_->Clear();
  _has_bits_[0] &= ~0x00000010u;
}
::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> QueryInfo::_i_give_permission_to_break_this_code_default_queue_name_;
QueryInfo::QueryInfo()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:exec.shared.QueryInfo)
}
QueryInfo::QueryInfo(const QueryInfo& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  query_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_query()) {
    query_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.query_);
  }
  user_.UnsafeSetDefault(&::exec::shared::QueryInfo::_i_give_permission_to_break_this_code_default_user_.get());
  if (from._internal_has_user()) {
    user_.AssignWithDefault(&::exec::shared::QueryInfo::_i_give_permission_to_break_this_code_default_user_.get(), from.user_);
  }
  options_json_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_options_json()) {
    options_json_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.options_json_);
  }
  queue_name_.UnsafeSetDefault(&::exec::shared::QueryInfo::_i_give_permission_to_break_this_code_default_queue_name_.get());
  if (from._internal_has_queue_name()) {
    queue_name_.AssignWithDefault(&::exec::shared::QueryInfo::_i_give_permission_to_break_this_code_default_queue_name_.get(), from.queue_name_);
  }
  if (from._internal_has_foreman()) {
    foreman_ = new ::exec::DrillbitEndpoint(*from.foreman_);
  } else {
    foreman_ = nullptr;
  }
  ::memcpy(&start_, &from.start_,
    static_cast<size_t>(reinterpret_cast<char*>(&state_) -
    reinterpret_cast<char*>(&start_)) + sizeof(state_));
  // @@protoc_insertion_point(copy_constructor:exec.shared.QueryInfo)
}

void QueryInfo::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_QueryInfo_UserBitShared_2eproto.base);
  query_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  user_.UnsafeSetDefault(&::exec::shared::QueryInfo::_i_give_permission_to_break_this_code_default_user_.get());
  options_json_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  queue_name_.UnsafeSetDefault(&::exec::shared::QueryInfo::_i_give_permission_to_break_this_code_default_queue_name_.get());
  ::memset(&foreman_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&state_) -
      reinterpret_cast<char*>(&foreman_)) + sizeof(state_));
}

QueryInfo::~QueryInfo() {
  // @@protoc_insertion_point(destructor:exec.shared.QueryInfo)
  SharedDtor();
}

void QueryInfo::SharedDtor() {
  query_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  user_.DestroyNoArena(&::exec::shared::QueryInfo::_i_give_permission_to_break_this_code_default_user_.get());
  options_json_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  queue_name_.DestroyNoArena(&::exec::shared::QueryInfo::_i_give_permission_to_break_this_code_default_queue_name_.get());
  if (this != internal_default_instance()) delete foreman_;
}

void QueryInfo::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const QueryInfo& QueryInfo::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_QueryInfo_UserBitShared_2eproto.base);
  return *internal_default_instance();
}


void QueryInfo::Clear() {
// @@protoc_insertion_point(message_clear_start:exec.shared.QueryInfo)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    if (cached_has_bits & 0x00000001u) {
      query_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000002u) {
      user_.UnsafeMutablePointer()->assign(*&::exec::shared::QueryInfo::_i_give_permission_to_break_this_code_default_user_.get());
    }
    if (cached_has_bits & 0x00000004u) {
      options_json_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000008u) {
      queue_name_.UnsafeMutablePointer()->assign(*&::exec::shared::QueryInfo::_i_give_permission_to_break_this_code_default_queue_name_.get());
    }
    if (cached_has_bits & 0x00000010u) {
      GOOGLE_DCHECK(foreman_ != nullptr);
      foreman_->Clear();
    }
  }
  if (cached_has_bits & 0x000000e0u) {
    ::memset(&start_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&state_) -
        reinterpret_cast<char*>(&start_)) + sizeof(state_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* QueryInfo::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional string query = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_query();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "exec.shared.QueryInfo.query");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int64 start = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_start(&has_bits);
          start_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .exec.shared.QueryResult.QueryState state = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::exec::shared::QueryResult_QueryState_IsValid(val))) {
            _internal_set_state(static_cast<::exec::shared::QueryResult_QueryState>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional string user = 4 [default = "-"];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          auto str = _internal_mutable_user();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "exec.shared.QueryInfo.user");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .exec.DrillbitEndpoint foreman = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_foreman(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string options_json = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          auto str = _internal_mutable_options_json();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "exec.shared.QueryInfo.options_json");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional double total_cost = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 57)) {
          _Internal::set_has_total_cost(&has_bits);
          total_cost_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      // optional string queue_name = 8 [default = "-"];
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
          auto str = _internal_mutable_queue_name();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "exec.shared.QueryInfo.queue_name");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* QueryInfo::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:exec.shared.QueryInfo)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string query = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_query().data(), static_cast<int>(this->_internal_query().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "exec.shared.QueryInfo.query");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_query(), target);
  }

  // optional int64 start = 2;
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->_internal_start(), target);
  }

  // optional .exec.shared.QueryResult.QueryState state = 3;
  if (cached_has_bits & 0x00000080u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      3, this->_internal_state(), target);
  }

  // optional string user = 4 [default = "-"];
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_user().data(), static_cast<int>(this->_internal_user().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "exec.shared.QueryInfo.user");
    target = stream->WriteStringMaybeAliased(
        4, this->_internal_user(), target);
  }

  // optional .exec.DrillbitEndpoint foreman = 5;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        5, _Internal::foreman(this), target, stream);
  }

  // optional string options_json = 6;
  if (cached_has_bits & 0x00000004u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_options_json().data(), static_cast<int>(this->_internal_options_json().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "exec.shared.QueryInfo.options_json");
    target = stream->WriteStringMaybeAliased(
        6, this->_internal_options_json(), target);
  }

  // optional double total_cost = 7;
  if (cached_has_bits & 0x00000040u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(7, this->_internal_total_cost(), target);
  }

  // optional string queue_name = 8 [default = "-"];
  if (cached_has_bits & 0x00000008u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_queue_name().data(), static_cast<int>(this->_internal_queue_name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "exec.shared.QueryInfo.queue_name");
    target = stream->WriteStringMaybeAliased(
        8, this->_internal_queue_name(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:exec.shared.QueryInfo)
  return target;
}

size_t QueryInfo::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:exec.shared.QueryInfo)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    // optional string query = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_query());
    }

    // optional string user = 4 [default = "-"];
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_user());
    }

    // optional string options_json = 6;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_options_json());
    }

    // optional string queue_name = 8 [default = "-"];
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_queue_name());
    }

    // optional .exec.DrillbitEndpoint foreman = 5;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *foreman_);
    }

    // optional int64 start = 2;
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
          this->_internal_start());
    }

    // optional double total_cost = 7;
    if (cached_has_bits & 0x00000040u) {
      total_size += 1 + 8;
    }

    // optional .exec.shared.QueryResult.QueryState state = 3;
    if (cached_has_bits & 0x00000080u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_state());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void QueryInfo::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:exec.shared.QueryInfo)
  GOOGLE_DCHECK_NE(&from, this);
  const QueryInfo* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<QueryInfo>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:exec.shared.QueryInfo)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:exec.shared.QueryInfo)
    MergeFrom(*source);
  }
}

void QueryInfo::MergeFrom(const QueryInfo& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:exec.shared.QueryInfo)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      query_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.query_);
    }
    if (cached_has_bits & 0x00000002u) {
      _has_bits_[0] |= 0x00000002u;
      user_.AssignWithDefault(&::exec::shared::QueryInfo::_i_give_permission_to_break_this_code_default_user_.get(), from.user_);
    }
    if (cached_has_bits & 0x00000004u) {
      _has_bits_[0] |= 0x00000004u;
      options_json_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.options_json_);
    }
    if (cached_has_bits & 0x00000008u) {
      _has_bits_[0] |= 0x00000008u;
      queue_name_.AssignWithDefault(&::exec::shared::QueryInfo::_i_give_permission_to_break_this_code_default_queue_name_.get(), from.queue_name_);
    }
    if (cached_has_bits & 0x00000010u) {
      _internal_mutable_foreman()->::exec::DrillbitEndpoint::MergeFrom(from._internal_foreman());
    }
    if (cached_has_bits & 0x00000020u) {
      start_ = from.start_;
    }
    if (cached_has_bits & 0x00000040u) {
      total_cost_ = from.total_cost_;
    }
    if (cached_has_bits & 0x00000080u) {
      state_ = from.state_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void QueryInfo::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:exec.shared.QueryInfo)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void QueryInfo::CopyFrom(const QueryInfo& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:exec.shared.QueryInfo)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool QueryInfo::IsInitialized() const {
  return true;
}

void QueryInfo::InternalSwap(QueryInfo* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  query_.Swap(&other->query_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  user_.Swap(&other->user_, &::exec::shared::QueryInfo::_i_give_permission_to_break_this_code_default_user_.get(),
    GetArenaNoVirtual());
  options_json_.Swap(&other->options_json_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  queue_name_.Swap(&other->queue_name_, &::exec::shared::QueryInfo::_i_give_permission_to_break_this_code_default_queue_name_.get(),
    GetArenaNoVirtual());
  swap(foreman_, other->foreman_);
  swap(start_, other->start_);
  swap(total_cost_, other->total_cost_);
  swap(state_, other->state_);
}

::PROTOBUF_NAMESPACE_ID::Metadata QueryInfo::GetMetadata() const {
  return GetMetadataStatic();
}


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

void QueryProfile::InitAsDefaultInstance() {
  ::exec::shared::_QueryProfile_default_instance_._instance.get_mutable()->id_ = const_cast< ::exec::shared::QueryId*>(
      ::exec::shared::QueryId::internal_default_instance());
  ::exec::shared::_QueryProfile_default_instance_._instance.get_mutable()->foreman_ = const_cast< ::exec::DrillbitEndpoint*>(
      ::exec::DrillbitEndpoint::internal_default_instance());
}
class QueryProfile::_Internal {
 public:
  using HasBits = decltype(std::declval<QueryProfile>()._has_bits_);
  static const ::exec::shared::QueryId& id(const QueryProfile* msg);
  static void set_has_id(HasBits* has_bits) {
    (*has_bits)[0] |= 1024u;
  }
  static void set_has_type(HasBits* has_bits) {
    (*has_bits)[0] |= 2097152u;
  }
  static void set_has_start(HasBits* has_bits) {
    (*has_bits)[0] |= 4096u;
  }
  static void set_has_end(HasBits* has_bits) {
    (*has_bits)[0] |= 8192u;
  }
  static void set_has_query(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_plan(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static const ::exec::DrillbitEndpoint& foreman(const QueryProfile* msg);
  static void set_has_foreman(HasBits* has_bits) {
    (*has_bits)[0] |= 2048u;
  }
  static void set_has_state(HasBits* has_bits) {
    (*has_bits)[0] |= 16384u;
  }
  static void set_has_total_fragments(HasBits* has_bits) {
    (*has_bits)[0] |= 32768u;
  }
  static void set_has_finished_fragments(HasBits* has_bits) {
    (*has_bits)[0] |= 65536u;
  }
  static void set_has_user(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_error(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_verboseerror(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_error_id(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
  static void set_has_error_node(HasBits* has_bits) {
    (*has_bits)[0] |= 64u;
  }
  static void set_has_options_json(HasBits* has_bits) {
    (*has_bits)[0] |= 128u;
  }
  static void set_has_planend(HasBits* has_bits) {
    (*has_bits)[0] |= 262144u;
  }
  static void set_has_queuewaitend(HasBits* has_bits) {
    (*has_bits)[0] |= 524288u;
  }
  static void set_has_total_cost(HasBits* has_bits) {
    (*has_bits)[0] |= 1048576u;
  }
  static void set_has_queue_name(HasBits* has_bits) {
    (*has_bits)[0] |= 256u;
  }
  static void set_has_queryid(HasBits* has_bits) {
    (*has_bits)[0] |= 512u;
  }
  static void set_has_autolimit(HasBits* has_bits) {
    (*has_bits)[0] |= 131072u;
  }
};

const ::exec::shared::QueryId&
QueryProfile::_Internal::id(const QueryProfile* msg) {
  return *msg->id_;
}
const ::exec::DrillbitEndpoint&
QueryProfile::_Internal::foreman(const QueryProfile* msg) {
  return *msg->foreman_;
}
void QueryProfile::clear_foreman() {
  if (foreman_ != nullptr) foreman_->Clear();
  _has_bits_[0] &= ~0x00000800u;
}
::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> QueryProfile::_i_give_permission_to_break_this_code_default_user_;
::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> QueryProfile::_i_give_permission_to_break_this_code_default_queue_name_;
QueryProfile::QueryProfile()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:exec.shared.QueryProfile)
}
QueryProfile::QueryProfile(const QueryProfile& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      fragment_profile_(from.fragment_profile_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  query_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_query()) {
    query_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.query_);
  }
  plan_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_plan()) {
    plan_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.plan_);
  }
  user_.UnsafeSetDefault(&::exec::shared::QueryProfile::_i_give_permission_to_break_this_code_default_user_.get());
  if (from._internal_has_user()) {
    user_.AssignWithDefault(&::exec::shared::QueryProfile::_i_give_permission_to_break_this_code_default_user_.get(), from.user_);
  }
  error_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_error()) {
    error_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.error_);
  }
  verboseerror_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_verboseerror()) {
    verboseerror_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.verboseerror_);
  }
  error_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_error_id()) {
    error_id_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.error_id_);
  }
  error_node_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_error_node()) {
    error_node_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.error_node_);
  }
  options_json_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_options_json()) {
    options_json_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.options_json_);
  }
  queue_name_.UnsafeSetDefault(&::exec::shared::QueryProfile::_i_give_permission_to_break_this_code_default_queue_name_.get());
  if (from._internal_has_queue_name()) {
    queue_name_.AssignWithDefault(&::exec::shared::QueryProfile::_i_give_permission_to_break_this_code_default_queue_name_.get(), from.queue_name_);
  }
  queryid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_queryid()) {
    queryid_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.queryid_);
  }
  if (from._internal_has_id()) {
    id_ = new ::exec::shared::QueryId(*from.id_);
  } else {
    id_ = nullptr;
  }
  if (from._internal_has_foreman()) {
    foreman_ = new ::exec::DrillbitEndpoint(*from.foreman_);
  } else {
    foreman_ = nullptr;
  }
  ::memcpy(&start_, &from.start_,
    static_cast<size_t>(reinterpret_cast<char*>(&type_) -
    reinterpret_cast<char*>(&start_)) + sizeof(type_));
  // @@protoc_insertion_point(copy_constructor:exec.shared.QueryProfile)
}

void QueryProfile::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_QueryProfile_UserBitShared_2eproto.base);
  query_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  plan_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  user_.UnsafeSetDefault(&::exec::shared::QueryProfile::_i_give_permission_to_break_this_code_default_user_.get());
  error_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  verboseerror_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  error_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  error_node_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  options_json_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  queue_name_.UnsafeSetDefault(&::exec::shared::QueryProfile::_i_give_permission_to_break_this_code_default_queue_name_.get());
  queryid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&id_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&total_cost_) -
      reinterpret_cast<char*>(&id_)) + sizeof(total_cost_));
  type_ = 1;
}

QueryProfile::~QueryProfile() {
  // @@protoc_insertion_point(destructor:exec.shared.QueryProfile)
  SharedDtor();
}

void QueryProfile::SharedDtor() {
  query_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  plan_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  user_.DestroyNoArena(&::exec::shared::QueryProfile::_i_give_permission_to_break_this_code_default_user_.get());
  error_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  verboseerror_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  error_id_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  error_node_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  options_json_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  queue_name_.DestroyNoArena(&::exec::shared::QueryProfile::_i_give_permission_to_break_this_code_default_queue_name_.get());
  queryid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete id_;
  if (this != internal_default_instance()) delete foreman_;
}

void QueryProfile::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const QueryProfile& QueryProfile::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_QueryProfile_UserBitShared_2eproto.base);
  return *internal_default_instance();
}


void QueryProfile::Clear() {
// @@protoc_insertion_point(message_clear_start:exec.shared.QueryProfile)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  fragment_profile_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      query_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000002u) {
      plan_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000004u) {
      user_.UnsafeMutablePointer()->assign(*&::exec::shared::QueryProfile::_i_give_permission_to_break_this_code_default_user_.get());
    }
    if (cached_has_bits & 0x00000008u) {
      error_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000010u) {
      verboseerror_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000020u) {
      error_id_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000040u) {
      error_node_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000080u) {
      options_json_.ClearNonDefaultToEmptyNoArena();
    }
  }
  if (cached_has_bits & 0x00000f00u) {
    if (cached_has_bits & 0x00000100u) {
      queue_name_.UnsafeMutablePointer()->assign(*&::exec::shared::QueryProfile::_i_give_permission_to_break_this_code_default_queue_name_.get());
    }
    if (cached_has_bits & 0x00000200u) {
      queryid_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000400u) {
      GOOGLE_DCHECK(id_ != nullptr);
      id_->Clear();
    }
    if (cached_has_bits & 0x00000800u) {
      GOOGLE_DCHECK(foreman_ != nullptr);
      foreman_->Clear();
    }
  }
  if (cached_has_bits & 0x0000f000u) {
    ::memset(&start_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&total_fragments_) -
        reinterpret_cast<char*>(&start_)) + sizeof(total_fragments_));
  }
  if (cached_has_bits & 0x003f0000u) {
    ::memset(&finished_fragments_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&total_cost_) -
        reinterpret_cast<char*>(&finished_fragments_)) + sizeof(total_cost_));
    type_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* QueryProfile::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional .exec.shared.QueryId id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_id(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .exec.shared.QueryType type = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::exec::shared::QueryType_IsValid(val))) {
            _internal_set_type(static_cast<::exec::shared::QueryType>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional int64 start = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_start(&has_bits);
          start_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int64 end = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_end(&has_bits);
          end_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string query = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          auto str = _internal_mutable_query();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "exec.shared.QueryProfile.query");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string plan = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          auto str = _internal_mutable_plan();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "exec.shared.QueryProfile.plan");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .exec.DrillbitEndpoint foreman = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
          ptr = ctx->ParseMessage(_internal_mutable_foreman(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .exec.shared.QueryResult.QueryState state = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::exec::shared::QueryResult_QueryState_IsValid(val))) {
            _internal_set_state(static_cast<::exec::shared::QueryResult_QueryState>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(8, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional int32 total_fragments = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 72)) {
          _Internal::set_has_total_fragments(&has_bits);
          total_fragments_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 finished_fragments = 10;
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 80)) {
          _Internal::set_has_finished_fragments(&has_bits);
          finished_fragments_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .exec.shared.MajorFragmentProfile fragment_profile = 11;
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_fragment_profile(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<90>(ptr));
        } else goto handle_unusual;
        continue;
      // optional string user = 12 [default = "-"];
      case 12:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 98)) {
          auto str = _internal_mutable_user();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "exec.shared.QueryProfile.user");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string error = 13;
      case 13:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) {
          auto str = _internal_mutable_error();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "exec.shared.QueryProfile.error");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string verboseError = 14;
      case 14:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 114)) {
          auto str = _internal_mutable_verboseerror();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "exec.shared.QueryProfile.verboseError");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string error_id = 15;
      case 15:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 122)) {
          auto str = _internal_mutable_error_id();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "exec.shared.QueryProfile.error_id");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string error_node = 16;
      case 16:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 130)) {
          auto str = _internal_mutable_error_node();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "exec.shared.QueryProfile.error_node");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string options_json = 17;
      case 17:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 138)) {
          auto str = _internal_mutable_options_json();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "exec.shared.QueryProfile.options_json");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int64 planEnd = 18;
      case 18:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 144)) {
          _Internal::set_has_planend(&has_bits);
          planend_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int64 queueWaitEnd = 19;
      case 19:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 152)) {
          _Internal::set_has_queuewaitend(&has_bits);
          queuewaitend_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional double total_cost = 20;
      case 20:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 161)) {
          _Internal::set_has_total_cost(&has_bits);
          total_cost_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      // optional string queue_name = 21 [default = "-"];
      case 21:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 170)) {
          auto str = _internal_mutable_queue_name();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "exec.shared.QueryProfile.queue_name");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string queryId = 22;
      case 22:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 178)) {
          auto str = _internal_mutable_queryid();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "exec.shared.QueryProfile.queryId");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 autoLimit = 23;
      case 23:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 184)) {
          _Internal::set_has_autolimit(&has_bits);
          autolimit_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* QueryProfile::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:exec.shared.QueryProfile)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .exec.shared.QueryId id = 1;
  if (cached_has_bits & 0x00000400u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::id(this), target, stream);
  }

  // optional .exec.shared.QueryType type = 2;
  if (cached_has_bits & 0x00200000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      2, this->_internal_type(), target);
  }

  // optional int64 start = 3;
  if (cached_has_bits & 0x00001000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(3, this->_internal_start(), target);
  }

  // optional int64 end = 4;
  if (cached_has_bits & 0x00002000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(4, this->_internal_end(), target);
  }

  // optional string query = 5;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_query().data(), static_cast<int>(this->_internal_query().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "exec.shared.QueryProfile.query");
    target = stream->WriteStringMaybeAliased(
        5, this->_internal_query(), target);
  }

  // optional string plan = 6;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_plan().data(), static_cast<int>(this->_internal_plan().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "exec.shared.QueryProfile.plan");
    target = stream->WriteStringMaybeAliased(
        6, this->_internal_plan(), target);
  }

  // optional .exec.DrillbitEndpoint foreman = 7;
  if (cached_has_bits & 0x00000800u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        7, _Internal::foreman(this), target, stream);
  }

  // optional .exec.shared.QueryResult.QueryState state = 8;
  if (cached_has_bits & 0x00004000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      8, this->_internal_state(), target);
  }

  // optional int32 total_fragments = 9;
  if (cached_has_bits & 0x00008000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(9, this->_internal_total_fragments(), target);
  }

  // optional int32 finished_fragments = 10;
  if (cached_has_bits & 0x00010000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(10, this->_internal_finished_fragments(), target);
  }

  // repeated .exec.shared.MajorFragmentProfile fragment_profile = 11;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_fragment_profile_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(11, this->_internal_fragment_profile(i), target, stream);
  }

  // optional string user = 12 [default = "-"];
  if (cached_has_bits & 0x00000004u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_user().data(), static_cast<int>(this->_internal_user().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "exec.shared.QueryProfile.user");
    target = stream->WriteStringMaybeAliased(
        12, this->_internal_user(), target);
  }

  // optional string error = 13;
  if (cached_has_bits & 0x00000008u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_error().data(), static_cast<int>(this->_internal_error().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "exec.shared.QueryProfile.error");
    target = stream->WriteStringMaybeAliased(
        13, this->_internal_error(), target);
  }

  // optional string verboseError = 14;
  if (cached_has_bits & 0x00000010u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_verboseerror().data(), static_cast<int>(this->_internal_verboseerror().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "exec.shared.QueryProfile.verboseError");
    target = stream->WriteStringMaybeAliased(
        14, this->_internal_verboseerror(), target);
  }

  // optional string error_id = 15;
  if (cached_has_bits & 0x00000020u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_error_id().data(), static_cast<int>(this->_internal_error_id().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "exec.shared.QueryProfile.error_id");
    target = stream->WriteStringMaybeAliased(
        15, this->_internal_error_id(), target);
  }

  // optional string error_node = 16;
  if (cached_has_bits & 0x00000040u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_error_node().data(), static_cast<int>(this->_internal_error_node().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "exec.shared.QueryProfile.error_node");
    target = stream->WriteStringMaybeAliased(
        16, this->_internal_error_node(), target);
  }

  // optional string options_json = 17;
  if (cached_has_bits & 0x00000080u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_options_json().data(), static_cast<int>(this->_internal_options_json().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "exec.shared.QueryProfile.options_json");
    target = stream->WriteStringMaybeAliased(
        17, this->_internal_options_json(), target);
  }

  // optional int64 planEnd = 18;
  if (cached_has_bits & 0x00040000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(18, this->_internal_planend(), target);
  }

  // optional int64 queueWaitEnd = 19;
  if (cached_has_bits & 0x00080000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(19, this->_internal_queuewaitend(), target);
  }

  // optional double total_cost = 20;
  if (cached_has_bits & 0x00100000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(20, this->_internal_total_cost(), target);
  }

  // optional string queue_name = 21 [default = "-"];
  if (cached_has_bits & 0x00000100u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_queue_name().data(), static_cast<int>(this->_internal_queue_name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "exec.shared.QueryProfile.queue_name");
    target = stream->WriteStringMaybeAliased(
        21, this->_internal_queue_name(), target);
  }

  // optional string queryId = 22;
  if (cached_has_bits & 0x00000200u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_queryid().data(), static_cast<int>(this->_internal_queryid().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "exec.shared.QueryProfile.queryId");
    target = stream->WriteStringMaybeAliased(
        22, this->_internal_queryid(), target);
  }

  // optional int32 autoLimit = 23;
  if (cached_has_bits & 0x00020000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(23, this->_internal_autolimit(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:exec.shared.QueryProfile)
  return target;
}

size_t QueryProfile::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:exec.shared.QueryProfile)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .exec.shared.MajorFragmentProfile fragment_profile = 11;
  total_size += 1UL * this->_internal_fragment_profile_size();
  for (const auto& msg : this->fragment_profile_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    // optional string query = 5;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_query());
    }

    // optional string plan = 6;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_plan());
    }

    // optional string user = 12 [default = "-"];
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_user());
    }

    // optional string error = 13;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_error());
    }

    // optional string verboseError = 14;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_verboseerror());
    }

    // optional string error_id = 15;
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_error_id());
    }

    // optional string error_node = 16;
    if (cached_has_bits & 0x00000040u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_error_node());
    }

    // optional string options_json = 17;
    if (cached_has_bits & 0x00000080u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_options_json());
    }

  }
  if (cached_has_bits & 0x0000ff00u) {
    // optional string queue_name = 21 [default = "-"];
    if (cached_has_bits & 0x00000100u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_queue_name());
    }

    // optional string queryId = 22;
    if (cached_has_bits & 0x00000200u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_queryid());
    }

    // optional .exec.shared.QueryId id = 1;
    if (cached_has_bits & 0x00000400u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *id_);
    }

    // optional .exec.DrillbitEndpoint foreman = 7;
    if (cached_has_bits & 0x00000800u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *foreman_);
    }

    // optional int64 start = 3;
    if (cached_has_bits & 0x00001000u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
          this->_internal_start());
    }

    // optional int64 end = 4;
    if (cached_has_bits & 0x00002000u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
          this->_internal_end());
    }

    // optional .exec.shared.QueryResult.QueryState state = 8;
    if (cached_has_bits & 0x00004000u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_state());
    }

    // optional int32 total_fragments = 9;
    if (cached_has_bits & 0x00008000u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_total_fragments());
    }

  }
  if (cached_has_bits & 0x003f0000u) {
    // optional int32 finished_fragments = 10;
    if (cached_has_bits & 0x00010000u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_finished_fragments());
    }

    // optional int32 autoLimit = 23;
    if (cached_has_bits & 0x00020000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_autolimit());
    }

    // optional int64 planEnd = 18;
    if (cached_has_bits & 0x00040000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
          this->_internal_planend());
    }

    // optional int64 queueWaitEnd = 19;
    if (cached_has_bits & 0x00080000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
          this->_internal_queuewaitend());
    }

    // optional double total_cost = 20;
    if (cached_has_bits & 0x00100000u) {
      total_size += 2 + 8;
    }

    // optional .exec.shared.QueryType type = 2;
    if (cached_has_bits & 0x00200000u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void QueryProfile::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:exec.shared.QueryProfile)
  GOOGLE_DCHECK_NE(&from, this);
  const QueryProfile* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<QueryProfile>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:exec.shared.QueryProfile)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:exec.shared.QueryProfile)
    MergeFrom(*source);
  }
}

void QueryProfile::MergeFrom(const QueryProfile& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:exec.shared.QueryProfile)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  fragment_profile_.MergeFrom(from.fragment_profile_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      query_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.query_);
    }
    if (cached_has_bits & 0x00000002u) {
      _has_bits_[0] |= 0x00000002u;
      plan_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.plan_);
    }
    if (cached_has_bits & 0x00000004u) {
      _has_bits_[0] |= 0x00000004u;
      user_.AssignWithDefault(&::exec::shared::QueryProfile::_i_give_permission_to_break_this_code_default_user_.get(), from.user_);
    }
    if (cached_has_bits & 0x00000008u) {
      _has_bits_[0] |= 0x00000008u;
      error_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.error_);
    }
    if (cached_has_bits & 0x00000010u) {
      _has_bits_[0] |= 0x00000010u;
      verboseerror_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.verboseerror_);
    }
    if (cached_has_bits & 0x00000020u) {
      _has_bits_[0] |= 0x00000020u;
      error_id_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.error_id_);
    }
    if (cached_has_bits & 0x00000040u) {
      _has_bits_[0] |= 0x00000040u;
      error_node_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.error_node_);
    }
    if (cached_has_bits & 0x00000080u) {
      _has_bits_[0] |= 0x00000080u;
      options_json_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.options_json_);
    }
  }
  if (cached_has_bits & 0x0000ff00u) {
    if (cached_has_bits & 0x00000100u) {
      _has_bits_[0] |= 0x00000100u;
      queue_name_.AssignWithDefault(&::exec::shared::QueryProfile::_i_give_permission_to_break_this_code_default_queue_name_.get(), from.queue_name_);
    }
    if (cached_has_bits & 0x00000200u) {
      _has_bits_[0] |= 0x00000200u;
      queryid_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.queryid_);
    }
    if (cached_has_bits & 0x00000400u) {
      _internal_mutable_id()->::exec::shared::QueryId::MergeFrom(from._internal_id());
    }
    if (cached_has_bits & 0x00000800u) {
      _internal_mutable_foreman()->::exec::DrillbitEndpoint::MergeFrom(from._internal_foreman());
    }
    if (cached_has_bits & 0x00001000u) {
      start_ = from.start_;
    }
    if (cached_has_bits & 0x00002000u) {
      end_ = from.end_;
    }
    if (cached_has_bits & 0x00004000u) {
      state_ = from.state_;
    }
    if (cached_has_bits & 0x00008000u) {
      total_fragments_ = from.total_fragments_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 0x003f0000u) {
    if (cached_has_bits & 0x00010000u) {
      finished_fragments_ = from.finished_fragments_;
    }
    if (cached_has_bits & 0x00020000u) {
      autolimit_ = from.autolimit_;
    }
    if (cached_has_bits & 0x00040000u) {
      planend_ = from.planend_;
    }
    if (cached_has_bits & 0x00080000u) {
      queuewaitend_ = from.queuewaitend_;
    }
    if (cached_has_bits & 0x00100000u) {
      total_cost_ = from.total_cost_;
    }
    if (cached_has_bits & 0x00200000u) {
      type_ = from.type_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void QueryProfile::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:exec.shared.QueryProfile)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void QueryProfile::CopyFrom(const QueryProfile& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:exec.shared.QueryProfile)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool QueryProfile::IsInitialized() const {
  return true;
}

void QueryProfile::InternalSwap(QueryProfile* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  fragment_profile_.InternalSwap(&other->fragment_profile_);
  query_.Swap(&other->query_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  plan_.Swap(&other->plan_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  user_.Swap(&other->user_, &::exec::shared::QueryProfile::_i_give_permission_to_break_this_code_default_user_.get(),
    GetArenaNoVirtual());
  error_.Swap(&other->error_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  verboseerror_.Swap(&other->verboseerror_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  error_id_.Swap(&other->error_id_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  error_node_.Swap(&other->error_node_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  options_json_.Swap(&other->options_json_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  queue_name_.Swap(&other->queue_name_, &::exec::shared::QueryProfile::_i_give_permission_to_break_this_code_default_queue_name_.get(),
    GetArenaNoVirtual());
  queryid_.Swap(&other->queryid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(id_, other->id_);
  swap(foreman_, other->foreman_);
  swap(start_, other->start_);
  swap(end_, other->end_);
  swap(state_, other->state_);
  swap(total_fragments_, other->total_fragments_);
  swap(finished_fragments_, other->finished_fragments_);
  swap(autolimit_, other->autolimit_);
  swap(planend_, other->planend_);
  swap(queuewaitend_, other->queuewaitend_);
  swap(total_cost_, other->total_cost_);
  swap(type_, other->type_);
}

::PROTOBUF_NAMESPACE_ID::Metadata QueryProfile::GetMetadata() const {
  return GetMetadataStatic();
}


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

void MajorFragmentProfile::InitAsDefaultInstance() {
}
class MajorFragmentProfile::_Internal {
 public:
  using HasBits = decltype(std::declval<MajorFragmentProfile>()._has_bits_);
  static void set_has_major_fragment_id(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

MajorFragmentProfile::MajorFragmentProfile()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:exec.shared.MajorFragmentProfile)
}
MajorFragmentProfile::MajorFragmentProfile(const MajorFragmentProfile& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      minor_fragment_profile_(from.minor_fragment_profile_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  major_fragment_id_ = from.major_fragment_id_;
  // @@protoc_insertion_point(copy_constructor:exec.shared.MajorFragmentProfile)
}

void MajorFragmentProfile::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_MajorFragmentProfile_UserBitShared_2eproto.base);
  major_fragment_id_ = 0;
}

MajorFragmentProfile::~MajorFragmentProfile() {
  // @@protoc_insertion_point(destructor:exec.shared.MajorFragmentProfile)
  SharedDtor();
}

void MajorFragmentProfile::SharedDtor() {
}

void MajorFragmentProfile::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const MajorFragmentProfile& MajorFragmentProfile::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_MajorFragmentProfile_UserBitShared_2eproto.base);
  return *internal_default_instance();
}


void MajorFragmentProfile::Clear() {
// @@protoc_insertion_point(message_clear_start:exec.shared.MajorFragmentProfile)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  minor_fragment_profile_.Clear();
  major_fragment_id_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* MajorFragmentProfile::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional int32 major_fragment_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_major_fragment_id(&has_bits);
          major_fragment_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .exec.shared.MinorFragmentProfile minor_fragment_profile = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_minor_fragment_profile(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* MajorFragmentProfile::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:exec.shared.MajorFragmentProfile)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 major_fragment_id = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_major_fragment_id(), target);
  }

  // repeated .exec.shared.MinorFragmentProfile minor_fragment_profile = 2;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_minor_fragment_profile_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, this->_internal_minor_fragment_profile(i), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:exec.shared.MajorFragmentProfile)
  return target;
}

size_t MajorFragmentProfile::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:exec.shared.MajorFragmentProfile)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .exec.shared.MinorFragmentProfile minor_fragment_profile = 2;
  total_size += 1UL * this->_internal_minor_fragment_profile_size();
  for (const auto& msg : this->minor_fragment_profile_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // optional int32 major_fragment_id = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_major_fragment_id());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void MajorFragmentProfile::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:exec.shared.MajorFragmentProfile)
  GOOGLE_DCHECK_NE(&from, this);
  const MajorFragmentProfile* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<MajorFragmentProfile>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:exec.shared.MajorFragmentProfile)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:exec.shared.MajorFragmentProfile)
    MergeFrom(*source);
  }
}

void MajorFragmentProfile::MergeFrom(const MajorFragmentProfile& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:exec.shared.MajorFragmentProfile)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  minor_fragment_profile_.MergeFrom(from.minor_fragment_profile_);
  if (from._internal_has_major_fragment_id()) {
    _internal_set_major_fragment_id(from._internal_major_fragment_id());
  }
}

void MajorFragmentProfile::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:exec.shared.MajorFragmentProfile)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void MajorFragmentProfile::CopyFrom(const MajorFragmentProfile& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:exec.shared.MajorFragmentProfile)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MajorFragmentProfile::IsInitialized() const {
  return true;
}

void MajorFragmentProfile::InternalSwap(MajorFragmentProfile* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  minor_fragment_profile_.InternalSwap(&other->minor_fragment_profile_);
  swap(major_fragment_id_, other->major_fragment_id_);
}

::PROTOBUF_NAMESPACE_ID::Metadata MajorFragmentProfile::GetMetadata() const {
  return GetMetadataStatic();
}


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

void MinorFragmentProfile::InitAsDefaultInstance() {
  ::exec::shared::_MinorFragmentProfile_default_instance_._instance.get_mutable()->error_ = const_cast< ::exec::shared::DrillPBError*>(
      ::exec::shared::DrillPBError::internal_default_instance());
  ::exec::shared::_MinorFragmentProfile_default_instance_._instance.get_mutable()->endpoint_ = const_cast< ::exec::DrillbitEndpoint*>(
      ::exec::DrillbitEndpoint::internal_default_instance());
}
class MinorFragmentProfile::_Internal {
 public:
  using HasBits = decltype(std::declval<MinorFragmentProfile>()._has_bits_);
  static void set_has_state(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static const ::exec::shared::DrillPBError& error(const MinorFragmentProfile* msg);
  static void set_has_error(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_minor_fragment_id(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_start_time(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_end_time(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
  static void set_has_memory_used(HasBits* has_bits) {
    (*has_bits)[0] |= 64u;
  }
  static void set_has_max_memory_used(HasBits* has_bits) {
    (*has_bits)[0] |= 128u;
  }
  static const ::exec::DrillbitEndpoint& endpoint(const MinorFragmentProfile* msg);
  static void set_has_endpoint(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_last_update(HasBits* has_bits) {
    (*has_bits)[0] |= 256u;
  }
  static void set_has_last_progress(HasBits* has_bits) {
    (*has_bits)[0] |= 512u;
  }
};

const ::exec::shared::DrillPBError&
MinorFragmentProfile::_Internal::error(const MinorFragmentProfile* msg) {
  return *msg->error_;
}
const ::exec::DrillbitEndpoint&
MinorFragmentProfile::_Internal::endpoint(const MinorFragmentProfile* msg) {
  return *msg->endpoint_;
}
void MinorFragmentProfile::clear_endpoint() {
  if (endpoint_ != nullptr) endpoint_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
MinorFragmentProfile::MinorFragmentProfile()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:exec.shared.MinorFragmentProfile)
}
MinorFragmentProfile::MinorFragmentProfile(const MinorFragmentProfile& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      operator_profile_(from.operator_profile_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from._internal_has_error()) {
    error_ = new ::exec::shared::DrillPBError(*from.error_);
  } else {
    error_ = nullptr;
  }
  if (from._internal_has_endpoint()) {
    endpoint_ = new ::exec::DrillbitEndpoint(*from.endpoint_);
  } else {
    endpoint_ = nullptr;
  }
  ::memcpy(&state_, &from.state_,
    static_cast<size_t>(reinterpret_cast<char*>(&last_progress_) -
    reinterpret_cast<char*>(&state_)) + sizeof(last_progress_));
  // @@protoc_insertion_point(copy_constructor:exec.shared.MinorFragmentProfile)
}

void MinorFragmentProfile::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_MinorFragmentProfile_UserBitShared_2eproto.base);
  ::memset(&error_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&last_progress_) -
      reinterpret_cast<char*>(&error_)) + sizeof(last_progress_));
}

MinorFragmentProfile::~MinorFragmentProfile() {
  // @@protoc_insertion_point(destructor:exec.shared.MinorFragmentProfile)
  SharedDtor();
}

void MinorFragmentProfile::SharedDtor() {
  if (this != internal_default_instance()) delete error_;
  if (this != internal_default_instance()) delete endpoint_;
}

void MinorFragmentProfile::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const MinorFragmentProfile& MinorFragmentProfile::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_MinorFragmentProfile_UserBitShared_2eproto.base);
  return *internal_default_instance();
}


void MinorFragmentProfile::Clear() {
// @@protoc_insertion_point(message_clear_start:exec.shared.MinorFragmentProfile)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  operator_profile_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(error_ != nullptr);
      error_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(endpoint_ != nullptr);
      endpoint_->Clear();
    }
  }
  if (cached_has_bits & 0x000000fcu) {
    ::memset(&state_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&max_memory_used_) -
        reinterpret_cast<char*>(&state_)) + sizeof(max_memory_used_));
  }
  if (cached_has_bits & 0x00000300u) {
    ::memset(&last_update_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&last_progress_) -
        reinterpret_cast<char*>(&last_update_)) + sizeof(last_progress_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* MinorFragmentProfile::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional .exec.shared.FragmentState state = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::exec::shared::FragmentState_IsValid(val))) {
            _internal_set_state(static_cast<::exec::shared::FragmentState>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional .exec.shared.DrillPBError error = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_error(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 minor_fragment_id = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_minor_fragment_id(&has_bits);
          minor_fragment_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .exec.shared.OperatorProfile operator_profile = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_operator_profile(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
        } else goto handle_unusual;
        continue;
      // optional int64 start_time = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          _Internal::set_has_start_time(&has_bits);
          start_time_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int64 end_time = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) {
          _Internal::set_has_end_time(&has_bits);
          end_time_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int64 memory_used = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) {
          _Internal::set_has_memory_used(&has_bits);
          memory_used_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int64 max_memory_used = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) {
          _Internal::set_has_max_memory_used(&has_bits);
          max_memory_used_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .exec.DrillbitEndpoint endpoint = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) {
          ptr = ctx->ParseMessage(_internal_mutable_endpoint(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int64 last_update = 10;
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 80)) {
          _Internal::set_has_last_update(&has_bits);
          last_update_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int64 last_progress = 11;
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 88)) {
          _Internal::set_has_last_progress(&has_bits);
          last_progress_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* MinorFragmentProfile::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:exec.shared.MinorFragmentProfile)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .exec.shared.FragmentState state = 1;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_state(), target);
  }

  // optional .exec.shared.DrillPBError error = 2;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::error(this), target, stream);
  }

  // optional int32 minor_fragment_id = 3;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_minor_fragment_id(), target);
  }

  // repeated .exec.shared.OperatorProfile operator_profile = 4;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_operator_profile_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(4, this->_internal_operator_profile(i), target, stream);
  }

  // optional int64 start_time = 5;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(5, this->_internal_start_time(), target);
  }

  // optional int64 end_time = 6;
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(6, this->_internal_end_time(), target);
  }

  // optional int64 memory_used = 7;
  if (cached_has_bits & 0x00000040u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(7, this->_internal_memory_used(), target);
  }

  // optional int64 max_memory_used = 8;
  if (cached_has_bits & 0x00000080u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(8, this->_internal_max_memory_used(), target);
  }

  // optional .exec.DrillbitEndpoint endpoint = 9;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        9, _Internal::endpoint(this), target, stream);
  }

  // optional int64 last_update = 10;
  if (cached_has_bits & 0x00000100u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(10, this->_internal_last_update(), target);
  }

  // optional int64 last_progress = 11;
  if (cached_has_bits & 0x00000200u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(11, this->_internal_last_progress(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:exec.shared.MinorFragmentProfile)
  return target;
}

size_t MinorFragmentProfile::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:exec.shared.MinorFragmentProfile)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .exec.shared.OperatorProfile operator_profile = 4;
  total_size += 1UL * this->_internal_operator_profile_size();
  for (const auto& msg : this->operator_profile_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    // optional .exec.shared.DrillPBError error = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *error_);
    }

    // optional .exec.DrillbitEndpoint endpoint = 9;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *endpoint_);
    }

    // optional .exec.shared.FragmentState state = 1;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_state());
    }

    // optional int32 minor_fragment_id = 3;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_minor_fragment_id());
    }

    // optional int64 start_time = 5;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
          this->_internal_start_time());
    }

    // optional int64 end_time = 6;
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
          this->_internal_end_time());
    }

    // optional int64 memory_used = 7;
    if (cached_has_bits & 0x00000040u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
          this->_internal_memory_used());
    }

    // optional int64 max_memory_used = 8;
    if (cached_has_bits & 0x00000080u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
          this->_internal_max_memory_used());
    }

  }
  if (cached_has_bits & 0x00000300u) {
    // optional int64 last_update = 10;
    if (cached_has_bits & 0x00000100u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
          this->_internal_last_update());
    }

    // optional int64 last_progress = 11;
    if (cached_has_bits & 0x00000200u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
          this->_internal_last_progress());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void MinorFragmentProfile::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:exec.shared.MinorFragmentProfile)
  GOOGLE_DCHECK_NE(&from, this);
  const MinorFragmentProfile* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<MinorFragmentProfile>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:exec.shared.MinorFragmentProfile)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:exec.shared.MinorFragmentProfile)
    MergeFrom(*source);
  }
}

void MinorFragmentProfile::MergeFrom(const MinorFragmentProfile& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:exec.shared.MinorFragmentProfile)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  operator_profile_.MergeFrom(from.operator_profile_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_error()->::exec::shared::DrillPBError::MergeFrom(from._internal_error());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_endpoint()->::exec::DrillbitEndpoint::MergeFrom(from._internal_endpoint());
    }
    if (cached_has_bits & 0x00000004u) {
      state_ = from.state_;
    }
    if (cached_has_bits & 0x00000008u) {
      minor_fragment_id_ = from.minor_fragment_id_;
    }
    if (cached_has_bits & 0x00000010u) {
      start_time_ = from.start_time_;
    }
    if (cached_has_bits & 0x00000020u) {
      end_time_ = from.end_time_;
    }
    if (cached_has_bits & 0x00000040u) {
      memory_used_ = from.memory_used_;
    }
    if (cached_has_bits & 0x00000080u) {
      max_memory_used_ = from.max_memory_used_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 0x00000300u) {
    if (cached_has_bits & 0x00000100u) {
      last_update_ = from.last_update_;
    }
    if (cached_has_bits & 0x00000200u) {
      last_progress_ = from.last_progress_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void MinorFragmentProfile::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:exec.shared.MinorFragmentProfile)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void MinorFragmentProfile::CopyFrom(const MinorFragmentProfile& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:exec.shared.MinorFragmentProfile)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MinorFragmentProfile::IsInitialized() const {
  return true;
}

void MinorFragmentProfile::InternalSwap(MinorFragmentProfile* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  operator_profile_.InternalSwap(&other->operator_profile_);
  swap(error_, other->error_);
  swap(endpoint_, other->endpoint_);
  swap(state_, other->state_);
  swap(minor_fragment_id_, other->minor_fragment_id_);
  swap(start_time_, other->start_time_);
  swap(end_time_, other->end_time_);
  swap(memory_used_, other->memory_used_);
  swap(max_memory_used_, other->max_memory_used_);
  swap(last_update_, other->last_update_);
  swap(last_progress_, other->last_progress_);
}

::PROTOBUF_NAMESPACE_ID::Metadata MinorFragmentProfile::GetMetadata() const {
  return GetMetadataStatic();
}


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

void OperatorProfile::InitAsDefaultInstance() {
}
class OperatorProfile::_Internal {
 public:
  using HasBits = decltype(std::declval<OperatorProfile>()._has_bits_);
  static void set_has_operator_id(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_operator_type(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_setup_nanos(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_process_nanos(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_peak_local_memory_allocated(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_wait_nanos(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
};

OperatorProfile::OperatorProfile()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:exec.shared.OperatorProfile)
}
OperatorProfile::OperatorProfile(const OperatorProfile& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      input_profile_(from.input_profile_),
      metric_(from.metric_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&operator_id_, &from.operator_id_,
    static_cast<size_t>(reinterpret_cast<char*>(&wait_nanos_) -
    reinterpret_cast<char*>(&operator_id_)) + sizeof(wait_nanos_));
  // @@protoc_insertion_point(copy_constructor:exec.shared.OperatorProfile)
}

void OperatorProfile::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_OperatorProfile_UserBitShared_2eproto.base);
  ::memset(&operator_id_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&wait_nanos_) -
      reinterpret_cast<char*>(&operator_id_)) + sizeof(wait_nanos_));
}

OperatorProfile::~OperatorProfile() {
  // @@protoc_insertion_point(destructor:exec.shared.OperatorProfile)
  SharedDtor();
}

void OperatorProfile::SharedDtor() {
}

void OperatorProfile::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const OperatorProfile& OperatorProfile::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_OperatorProfile_UserBitShared_2eproto.base);
  return *internal_default_instance();
}


void OperatorProfile::Clear() {
// @@protoc_insertion_point(message_clear_start:exec.shared.OperatorProfile)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  input_profile_.Clear();
  metric_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000003fu) {
    ::memset(&operator_id_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&wait_nanos_) -
        reinterpret_cast<char*>(&operator_id_)) + sizeof(wait_nanos_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* OperatorProfile::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // repeated .exec.shared.StreamProfile input_profile = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_input_profile(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else goto handle_unusual;
        continue;
      // optional int32 operator_id = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_operator_id(&has_bits);
          operator_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 operator_type = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_operator_type(&has_bits);
          operator_type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int64 setup_nanos = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          _Internal::set_has_setup_nanos(&has_bits);
          setup_nanos_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int64 process_nanos = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) {
          _Internal::set_has_process_nanos(&has_bits);
          process_nanos_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int64 peak_local_memory_allocated = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) {
          _Internal::set_has_peak_local_memory_allocated(&has_bits);
          peak_local_memory_allocated_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .exec.shared.MetricValue metric = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_metric(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<66>(ptr));
        } else goto handle_unusual;
        continue;
      // optional int64 wait_nanos = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 72)) {
          _Internal::set_has_wait_nanos(&has_bits);
          wait_nanos_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* OperatorProfile::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:exec.shared.OperatorProfile)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .exec.shared.StreamProfile input_profile = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_input_profile_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_input_profile(i), target, stream);
  }

  cached_has_bits = _has_bits_[0];
  // optional int32 operator_id = 3;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_operator_id(), target);
  }

  // optional int32 operator_type = 4;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_operator_type(), target);
  }

  // optional int64 setup_nanos = 5;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(5, this->_internal_setup_nanos(), target);
  }

  // optional int64 process_nanos = 6;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(6, this->_internal_process_nanos(), target);
  }

  // optional int64 peak_local_memory_allocated = 7;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(7, this->_internal_peak_local_memory_allocated(), target);
  }

  // repeated .exec.shared.MetricValue metric = 8;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_metric_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(8, this->_internal_metric(i), target, stream);
  }

  // optional int64 wait_nanos = 9;
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(9, this->_internal_wait_nanos(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:exec.shared.OperatorProfile)
  return target;
}

size_t OperatorProfile::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:exec.shared.OperatorProfile)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .exec.shared.StreamProfile input_profile = 1;
  total_size += 1UL * this->_internal_input_profile_size();
  for (const auto& msg : this->input_profile_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated .exec.shared.MetricValue metric = 8;
  total_size += 1UL * this->_internal_metric_size();
  for (const auto& msg : this->metric_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000003fu) {
    // optional int32 operator_id = 3;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_operator_id());
    }

    // optional int32 operator_type = 4;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_operator_type());
    }

    // optional int64 setup_nanos = 5;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
          this->_internal_setup_nanos());
    }

    // optional int64 process_nanos = 6;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
          this->_internal_process_nanos());
    }

    // optional int64 peak_local_memory_allocated = 7;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
          this->_internal_peak_local_memory_allocated());
    }

    // optional int64 wait_nanos = 9;
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
          this->_internal_wait_nanos());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void OperatorProfile::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:exec.shared.OperatorProfile)
  GOOGLE_DCHECK_NE(&from, this);
  const OperatorProfile* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<OperatorProfile>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:exec.shared.OperatorProfile)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:exec.shared.OperatorProfile)
    MergeFrom(*source);
  }
}

void OperatorProfile::MergeFrom(const OperatorProfile& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:exec.shared.OperatorProfile)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  input_profile_.MergeFrom(from.input_profile_);
  metric_.MergeFrom(from.metric_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000003fu) {
    if (cached_has_bits & 0x00000001u) {
      operator_id_ = from.operator_id_;
    }
    if (cached_has_bits & 0x00000002u) {
      operator_type_ = from.operator_type_;
    }
    if (cached_has_bits & 0x00000004u) {
      setup_nanos_ = from.setup_nanos_;
    }
    if (cached_has_bits & 0x00000008u) {
      process_nanos_ = from.process_nanos_;
    }
    if (cached_has_bits & 0x00000010u) {
      peak_local_memory_allocated_ = from.peak_local_memory_allocated_;
    }
    if (cached_has_bits & 0x00000020u) {
      wait_nanos_ = from.wait_nanos_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void OperatorProfile::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:exec.shared.OperatorProfile)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void OperatorProfile::CopyFrom(const OperatorProfile& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:exec.shared.OperatorProfile)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool OperatorProfile::IsInitialized() const {
  return true;
}

void OperatorProfile::InternalSwap(OperatorProfile* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  input_profile_.InternalSwap(&other->input_profile_);
  metric_.InternalSwap(&other->metric_);
  swap(operator_id_, other->operator_id_);
  swap(operator_type_, other->operator_type_);
  swap(setup_nanos_, other->setup_nanos_);
  swap(process_nanos_, other->process_nanos_);
  swap(peak_local_memory_allocated_, other->peak_local_memory_allocated_);
  swap(wait_nanos_, other->wait_nanos_);
}

::PROTOBUF_NAMESPACE_ID::Metadata OperatorProfile::GetMetadata() const {
  return GetMetadataStatic();
}


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

void StreamProfile::InitAsDefaultInstance() {
}
class StreamProfile::_Internal {
 public:
  using HasBits = decltype(std::declval<StreamProfile>()._has_bits_);
  static void set_has_records(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_batches(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_schemas(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
};

StreamProfile::StreamProfile()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:exec.shared.StreamProfile)
}
StreamProfile::StreamProfile(const StreamProfile& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&records_, &from.records_,
    static_cast<size_t>(reinterpret_cast<char*>(&schemas_) -
    reinterpret_cast<char*>(&records_)) + sizeof(schemas_));
  // @@protoc_insertion_point(copy_constructor:exec.shared.StreamProfile)
}

void StreamProfile::SharedCtor() {
  ::memset(&records_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&schemas_) -
      reinterpret_cast<char*>(&records_)) + sizeof(schemas_));
}

StreamProfile::~StreamProfile() {
  // @@protoc_insertion_point(destructor:exec.shared.StreamProfile)
  SharedDtor();
}

void StreamProfile::SharedDtor() {
}

void StreamProfile::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const StreamProfile& StreamProfile::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_StreamProfile_UserBitShared_2eproto.base);
  return *internal_default_instance();
}


void StreamProfile::Clear() {
// @@protoc_insertion_point(message_clear_start:exec.shared.StreamProfile)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    ::memset(&records_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&schemas_) -
        reinterpret_cast<char*>(&records_)) + sizeof(schemas_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* StreamProfile::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional int64 records = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_records(&has_bits);
          records_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int64 batches = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_batches(&has_bits);
          batches_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int64 schemas = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_schemas(&has_bits);
          schemas_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* StreamProfile::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:exec.shared.StreamProfile)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int64 records = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_records(), target);
  }

  // optional int64 batches = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->_internal_batches(), target);
  }

  // optional int64 schemas = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(3, this->_internal_schemas(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:exec.shared.StreamProfile)
  return target;
}

size_t StreamProfile::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:exec.shared.StreamProfile)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    // optional int64 records = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
          this->_internal_records());
    }

    // optional int64 batches = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
          this->_internal_batches());
    }

    // optional int64 schemas = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
          this->_internal_schemas());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void StreamProfile::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:exec.shared.StreamProfile)
  GOOGLE_DCHECK_NE(&from, this);
  const StreamProfile* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<StreamProfile>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:exec.shared.StreamProfile)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:exec.shared.StreamProfile)
    MergeFrom(*source);
  }
}

void StreamProfile::MergeFrom(const StreamProfile& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:exec.shared.StreamProfile)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      records_ = from.records_;
    }
    if (cached_has_bits & 0x00000002u) {
      batches_ = from.batches_;
    }
    if (cached_has_bits & 0x00000004u) {
      schemas_ = from.schemas_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void StreamProfile::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:exec.shared.StreamProfile)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void StreamProfile::CopyFrom(const StreamProfile& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:exec.shared.StreamProfile)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool StreamProfile::IsInitialized() const {
  return true;
}

void StreamProfile::InternalSwap(StreamProfile* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(records_, other->records_);
  swap(batches_, other->batches_);
  swap(schemas_, other->schemas_);
}

::PROTOBUF_NAMESPACE_ID::Metadata StreamProfile::GetMetadata() const {
  return GetMetadataStatic();
}


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

void MetricValue::InitAsDefaultInstance() {
}
class MetricValue::_Internal {
 public:
  using HasBits = decltype(std::declval<MetricValue>()._has_bits_);
  static void set_has_metric_id(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_long_value(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_double_value(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

MetricValue::MetricValue()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:exec.shared.MetricValue)
}
MetricValue::MetricValue(const MetricValue& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&long_value_, &from.long_value_,
    static_cast<size_t>(reinterpret_cast<char*>(&metric_id_) -
    reinterpret_cast<char*>(&long_value_)) + sizeof(metric_id_));
  // @@protoc_insertion_point(copy_constructor:exec.shared.MetricValue)
}

void MetricValue::SharedCtor() {
  ::memset(&long_value_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&metric_id_) -
      reinterpret_cast<char*>(&long_value_)) + sizeof(metric_id_));
}

MetricValue::~MetricValue() {
  // @@protoc_insertion_point(destructor:exec.shared.MetricValue)
  SharedDtor();
}

void MetricValue::SharedDtor() {
}

void MetricValue::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const MetricValue& MetricValue::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_MetricValue_UserBitShared_2eproto.base);
  return *internal_default_instance();
}


void MetricValue::Clear() {
// @@protoc_insertion_point(message_clear_start:exec.shared.MetricValue)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    ::memset(&long_value_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&metric_id_) -
        reinterpret_cast<char*>(&long_value_)) + sizeof(metric_id_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* MetricValue::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional int32 metric_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_metric_id(&has_bits);
          metric_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int64 long_value = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_long_value(&has_bits);
          long_value_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional double double_value = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 25)) {
          _Internal::set_has_double_value(&has_bits);
          double_value_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* MetricValue::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:exec.shared.MetricValue)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 metric_id = 1;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_metric_id(), target);
  }

  // optional int64 long_value = 2;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->_internal_long_value(), target);
  }

  // optional double double_value = 3;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(3, this->_internal_double_value(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:exec.shared.MetricValue)
  return target;
}

size_t MetricValue::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:exec.shared.MetricValue)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    // optional int64 long_value = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
          this->_internal_long_value());
    }

    // optional double double_value = 3;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 + 8;
    }

    // optional int32 metric_id = 1;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_metric_id());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void MetricValue::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:exec.shared.MetricValue)
  GOOGLE_DCHECK_NE(&from, this);
  const MetricValue* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<MetricValue>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:exec.shared.MetricValue)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:exec.shared.MetricValue)
    MergeFrom(*source);
  }
}

void MetricValue::MergeFrom(const MetricValue& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:exec.shared.MetricValue)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      long_value_ = from.long_value_;
    }
    if (cached_has_bits & 0x00000002u) {
      double_value_ = from.double_value_;
    }
    if (cached_has_bits & 0x00000004u) {
      metric_id_ = from.metric_id_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void MetricValue::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:exec.shared.MetricValue)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void MetricValue::CopyFrom(const MetricValue& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:exec.shared.MetricValue)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MetricValue::IsInitialized() const {
  return true;
}

void MetricValue::InternalSwap(MetricValue* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(long_value_, other->long_value_);
  swap(double_value_, other->double_value_);
  swap(metric_id_, other->metric_id_);
}

::PROTOBUF_NAMESPACE_ID::Metadata MetricValue::GetMetadata() const {
  return GetMetadataStatic();
}


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

void Registry::InitAsDefaultInstance() {
}
class Registry::_Internal {
 public:
  using HasBits = decltype(std::declval<Registry>()._has_bits_);
};

Registry::Registry()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:exec.shared.Registry)
}
Registry::Registry(const Registry& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      jar_(from.jar_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:exec.shared.Registry)
}

void Registry::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Registry_UserBitShared_2eproto.base);
}

Registry::~Registry() {
  // @@protoc_insertion_point(destructor:exec.shared.Registry)
  SharedDtor();
}

void Registry::SharedDtor() {
}

void Registry::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const Registry& Registry::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Registry_UserBitShared_2eproto.base);
  return *internal_default_instance();
}


void Registry::Clear() {
// @@protoc_insertion_point(message_clear_start:exec.shared.Registry)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  jar_.Clear();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* Registry::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // repeated .exec.shared.Jar jar = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_jar(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Registry::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:exec.shared.Registry)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .exec.shared.Jar jar = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_jar_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_jar(i), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:exec.shared.Registry)
  return target;
}

size_t Registry::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:exec.shared.Registry)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .exec.shared.Jar jar = 1;
  total_size += 1UL * this->_internal_jar_size();
  for (const auto& msg : this->jar_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Registry::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:exec.shared.Registry)
  GOOGLE_DCHECK_NE(&from, this);
  const Registry* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<Registry>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:exec.shared.Registry)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:exec.shared.Registry)
    MergeFrom(*source);
  }
}

void Registry::MergeFrom(const Registry& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:exec.shared.Registry)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  jar_.MergeFrom(from.jar_);
}

void Registry::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:exec.shared.Registry)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Registry::CopyFrom(const Registry& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:exec.shared.Registry)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Registry::IsInitialized() const {
  return true;
}

void Registry::InternalSwap(Registry* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  jar_.InternalSwap(&other->jar_);
}

::PROTOBUF_NAMESPACE_ID::Metadata Registry::GetMetadata() const {
  return GetMetadataStatic();
}


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

void Jar::InitAsDefaultInstance() {
}
class Jar::_Internal {
 public:
  using HasBits = decltype(std::declval<Jar>()._has_bits_);
  static void set_has_name(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

Jar::Jar()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:exec.shared.Jar)
}
Jar::Jar(const Jar& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      function_signature_(from.function_signature_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_name()) {
    name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_);
  }
  // @@protoc_insertion_point(copy_constructor:exec.shared.Jar)
}

void Jar::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Jar_UserBitShared_2eproto.base);
  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

Jar::~Jar() {
  // @@protoc_insertion_point(destructor:exec.shared.Jar)
  SharedDtor();
}

void Jar::SharedDtor() {
  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void Jar::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const Jar& Jar::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Jar_UserBitShared_2eproto.base);
  return *internal_default_instance();
}


void Jar::Clear() {
// @@protoc_insertion_point(message_clear_start:exec.shared.Jar)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  function_signature_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    name_.ClearNonDefaultToEmptyNoArena();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* Jar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional string name = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_name();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "exec.shared.Jar.name");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated string function_signature = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            auto str = _internal_add_function_signature();
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
            #ifndef NDEBUG
            ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "exec.shared.Jar.function_signature");
            #endif  // !NDEBUG
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Jar::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:exec.shared.Jar)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string name = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "exec.shared.Jar.name");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_name(), target);
  }

  // repeated string function_signature = 2;
  for (int i = 0, n = this->_internal_function_signature_size(); i < n; i++) {
    const auto& s = this->_internal_function_signature(i);
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      s.data(), static_cast<int>(s.length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "exec.shared.Jar.function_signature");
    target = stream->WriteString(2, s, target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:exec.shared.Jar)
  return target;
}

size_t Jar::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:exec.shared.Jar)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated string function_signature = 2;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(function_signature_.size());
  for (int i = 0, n = function_signature_.size(); i < n; i++) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
      function_signature_.Get(i));
  }

  // optional string name = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_name());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Jar::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:exec.shared.Jar)
  GOOGLE_DCHECK_NE(&from, this);
  const Jar* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<Jar>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:exec.shared.Jar)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:exec.shared.Jar)
    MergeFrom(*source);
  }
}

void Jar::MergeFrom(const Jar& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:exec.shared.Jar)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  function_signature_.MergeFrom(from.function_signature_);
  if (from._internal_has_name()) {
    _has_bits_[0] |= 0x00000001u;
    name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_);
  }
}

void Jar::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:exec.shared.Jar)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Jar::CopyFrom(const Jar& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:exec.shared.Jar)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Jar::IsInitialized() const {
  return true;
}

void Jar::InternalSwap(Jar* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  function_signature_.InternalSwap(&other->function_signature_);
  name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
}

::PROTOBUF_NAMESPACE_ID::Metadata Jar::GetMetadata() const {
  return GetMetadataStatic();
}


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

void SaslMessage::InitAsDefaultInstance() {
}
class SaslMessage::_Internal {
 public:
  using HasBits = decltype(std::declval<SaslMessage>()._has_bits_);
  static void set_has_mechanism(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_data(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_status(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
};

SaslMessage::SaslMessage()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:exec.shared.SaslMessage)
}
SaslMessage::SaslMessage(const SaslMessage& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  mechanism_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_mechanism()) {
    mechanism_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.mechanism_);
  }
  data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_data()) {
    data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.data_);
  }
  status_ = from.status_;
  // @@protoc_insertion_point(copy_constructor:exec.shared.SaslMessage)
}

void SaslMessage::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_SaslMessage_UserBitShared_2eproto.base);
  mechanism_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  status_ = 0;
}

SaslMessage::~SaslMessage() {
  // @@protoc_insertion_point(destructor:exec.shared.SaslMessage)
  SharedDtor();
}

void SaslMessage::SharedDtor() {
  mechanism_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void SaslMessage::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const SaslMessage& SaslMessage::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_SaslMessage_UserBitShared_2eproto.base);
  return *internal_default_instance();
}


void SaslMessage::Clear() {
// @@protoc_insertion_point(message_clear_start:exec.shared.SaslMessage)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      mechanism_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000002u) {
      data_.ClearNonDefaultToEmptyNoArena();
    }
  }
  status_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* SaslMessage::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional string mechanism = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_mechanism();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "exec.shared.SaslMessage.mechanism");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bytes data = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_data();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .exec.shared.SaslStatus status = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::exec::shared::SaslStatus_IsValid(val))) {
            _internal_set_status(static_cast<::exec::shared::SaslStatus>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* SaslMessage::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:exec.shared.SaslMessage)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string mechanism = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_mechanism().data(), static_cast<int>(this->_internal_mechanism().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "exec.shared.SaslMessage.mechanism");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_mechanism(), target);
  }

  // optional bytes data = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->WriteBytesMaybeAliased(
        2, this->_internal_data(), target);
  }

  // optional .exec.shared.SaslStatus status = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      3, this->_internal_status(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:exec.shared.SaslMessage)
  return target;
}

size_t SaslMessage::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:exec.shared.SaslMessage)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    // optional string mechanism = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_mechanism());
    }

    // optional bytes data = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_data());
    }

    // optional .exec.shared.SaslStatus status = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_status());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void SaslMessage::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:exec.shared.SaslMessage)
  GOOGLE_DCHECK_NE(&from, this);
  const SaslMessage* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<SaslMessage>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:exec.shared.SaslMessage)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:exec.shared.SaslMessage)
    MergeFrom(*source);
  }
}

void SaslMessage::MergeFrom(const SaslMessage& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:exec.shared.SaslMessage)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      mechanism_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.mechanism_);
    }
    if (cached_has_bits & 0x00000002u) {
      _has_bits_[0] |= 0x00000002u;
      data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.data_);
    }
    if (cached_has_bits & 0x00000004u) {
      status_ = from.status_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void SaslMessage::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:exec.shared.SaslMessage)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void SaslMessage::CopyFrom(const SaslMessage& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:exec.shared.SaslMessage)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SaslMessage::IsInitialized() const {
  return true;
}

void SaslMessage::InternalSwap(SaslMessage* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  mechanism_.Swap(&other->mechanism_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  data_.Swap(&other->data_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(status_, other->status_);
}

::PROTOBUF_NAMESPACE_ID::Metadata SaslMessage::GetMetadata() const {
  return GetMetadataStatic();
}


// @@protoc_insertion_point(namespace_scope)
}  // namespace shared
}  // namespace exec
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::exec::shared::UserCredentials* Arena::CreateMaybeMessage< ::exec::shared::UserCredentials >(Arena* arena) {
  return Arena::CreateInternal< ::exec::shared::UserCredentials >(arena);
}
template<> PROTOBUF_NOINLINE ::exec::shared::QueryId* Arena::CreateMaybeMessage< ::exec::shared::QueryId >(Arena* arena) {
  return Arena::CreateInternal< ::exec::shared::QueryId >(arena);
}
template<> PROTOBUF_NOINLINE ::exec::shared::DrillPBError* Arena::CreateMaybeMessage< ::exec::shared::DrillPBError >(Arena* arena) {
  return Arena::CreateInternal< ::exec::shared::DrillPBError >(arena);
}
template<> PROTOBUF_NOINLINE ::exec::shared::ExceptionWrapper* Arena::CreateMaybeMessage< ::exec::shared::ExceptionWrapper >(Arena* arena) {
  return Arena::CreateInternal< ::exec::shared::ExceptionWrapper >(arena);
}
template<> PROTOBUF_NOINLINE ::exec::shared::StackTraceElementWrapper* Arena::CreateMaybeMessage< ::exec::shared::StackTraceElementWrapper >(Arena* arena) {
  return Arena::CreateInternal< ::exec::shared::StackTraceElementWrapper >(arena);
}
template<> PROTOBUF_NOINLINE ::exec::shared::ParsingError* Arena::CreateMaybeMessage< ::exec::shared::ParsingError >(Arena* arena) {
  return Arena::CreateInternal< ::exec::shared::ParsingError >(arena);
}
template<> PROTOBUF_NOINLINE ::exec::shared::RecordBatchDef* Arena::CreateMaybeMessage< ::exec::shared::RecordBatchDef >(Arena* arena) {
  return Arena::CreateInternal< ::exec::shared::RecordBatchDef >(arena);
}
template<> PROTOBUF_NOINLINE ::exec::shared::NamePart* Arena::CreateMaybeMessage< ::exec::shared::NamePart >(Arena* arena) {
  return Arena::CreateInternal< ::exec::shared::NamePart >(arena);
}
template<> PROTOBUF_NOINLINE ::exec::shared::SerializedField* Arena::CreateMaybeMessage< ::exec::shared::SerializedField >(Arena* arena) {
  return Arena::CreateInternal< ::exec::shared::SerializedField >(arena);
}
template<> PROTOBUF_NOINLINE ::exec::shared::NodeStatus* Arena::CreateMaybeMessage< ::exec::shared::NodeStatus >(Arena* arena) {
  return Arena::CreateInternal< ::exec::shared::NodeStatus >(arena);
}
template<> PROTOBUF_NOINLINE ::exec::shared::QueryResult* Arena::CreateMaybeMessage< ::exec::shared::QueryResult >(Arena* arena) {
  return Arena::CreateInternal< ::exec::shared::QueryResult >(arena);
}
template<> PROTOBUF_NOINLINE ::exec::shared::QueryData* Arena::CreateMaybeMessage< ::exec::shared::QueryData >(Arena* arena) {
  return Arena::CreateInternal< ::exec::shared::QueryData >(arena);
}
template<> PROTOBUF_NOINLINE ::exec::shared::QueryInfo* Arena::CreateMaybeMessage< ::exec::shared::QueryInfo >(Arena* arena) {
  return Arena::CreateInternal< ::exec::shared::QueryInfo >(arena);
}
template<> PROTOBUF_NOINLINE ::exec::shared::QueryProfile* Arena::CreateMaybeMessage< ::exec::shared::QueryProfile >(Arena* arena) {
  return Arena::CreateInternal< ::exec::shared::QueryProfile >(arena);
}
template<> PROTOBUF_NOINLINE ::exec::shared::MajorFragmentProfile* Arena::CreateMaybeMessage< ::exec::shared::MajorFragmentProfile >(Arena* arena) {
  return Arena::CreateInternal< ::exec::shared::MajorFragmentProfile >(arena);
}
template<> PROTOBUF_NOINLINE ::exec::shared::MinorFragmentProfile* Arena::CreateMaybeMessage< ::exec::shared::MinorFragmentProfile >(Arena* arena) {
  return Arena::CreateInternal< ::exec::shared::MinorFragmentProfile >(arena);
}
template<> PROTOBUF_NOINLINE ::exec::shared::OperatorProfile* Arena::CreateMaybeMessage< ::exec::shared::OperatorProfile >(Arena* arena) {
  return Arena::CreateInternal< ::exec::shared::OperatorProfile >(arena);
}
template<> PROTOBUF_NOINLINE ::exec::shared::StreamProfile* Arena::CreateMaybeMessage< ::exec::shared::StreamProfile >(Arena* arena) {
  return Arena::CreateInternal< ::exec::shared::StreamProfile >(arena);
}
template<> PROTOBUF_NOINLINE ::exec::shared::MetricValue* Arena::CreateMaybeMessage< ::exec::shared::MetricValue >(Arena* arena) {
  return Arena::CreateInternal< ::exec::shared::MetricValue >(arena);
}
template<> PROTOBUF_NOINLINE ::exec::shared::Registry* Arena::CreateMaybeMessage< ::exec::shared::Registry >(Arena* arena) {
  return Arena::CreateInternal< ::exec::shared::Registry >(arena);
}
template<> PROTOBUF_NOINLINE ::exec::shared::Jar* Arena::CreateMaybeMessage< ::exec::shared::Jar >(Arena* arena) {
  return Arena::CreateInternal< ::exec::shared::Jar >(arena);
}
template<> PROTOBUF_NOINLINE ::exec::shared::SaslMessage* Arena::CreateMaybeMessage< ::exec::shared::SaslMessage >(Arena* arena) {
  return Arena::CreateInternal< ::exec::shared::SaslMessage >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>