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

#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
#include "UserBitShared.pb.h"

#include <algorithm>

#include <google/protobuf/stubs/common.h>
#include <google/protobuf/stubs/once.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/wire_format_lite_inl.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)

namespace exec {
namespace shared {

namespace {

const ::google::protobuf::Descriptor* UserCredentials_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  UserCredentials_reflection_ = NULL;
const ::google::protobuf::Descriptor* QueryId_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  QueryId_reflection_ = NULL;
const ::google::protobuf::Descriptor* DrillPBError_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  DrillPBError_reflection_ = NULL;
const ::google::protobuf::EnumDescriptor* DrillPBError_ErrorType_descriptor_ = NULL;
const ::google::protobuf::Descriptor* ExceptionWrapper_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  ExceptionWrapper_reflection_ = NULL;
const ::google::protobuf::Descriptor* StackTraceElementWrapper_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  StackTraceElementWrapper_reflection_ = NULL;
const ::google::protobuf::Descriptor* ParsingError_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  ParsingError_reflection_ = NULL;
const ::google::protobuf::Descriptor* RecordBatchDef_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  RecordBatchDef_reflection_ = NULL;
const ::google::protobuf::Descriptor* NamePart_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  NamePart_reflection_ = NULL;
const ::google::protobuf::EnumDescriptor* NamePart_Type_descriptor_ = NULL;
const ::google::protobuf::Descriptor* SerializedField_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  SerializedField_reflection_ = NULL;
const ::google::protobuf::Descriptor* NodeStatus_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  NodeStatus_reflection_ = NULL;
const ::google::protobuf::Descriptor* QueryResult_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  QueryResult_reflection_ = NULL;
const ::google::protobuf::EnumDescriptor* QueryResult_QueryState_descriptor_ = NULL;
const ::google::protobuf::Descriptor* QueryData_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  QueryData_reflection_ = NULL;
const ::google::protobuf::Descriptor* QueryInfo_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  QueryInfo_reflection_ = NULL;
const ::google::protobuf::Descriptor* QueryProfile_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  QueryProfile_reflection_ = NULL;
const ::google::protobuf::Descriptor* MajorFragmentProfile_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  MajorFragmentProfile_reflection_ = NULL;
const ::google::protobuf::Descriptor* MinorFragmentProfile_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  MinorFragmentProfile_reflection_ = NULL;
const ::google::protobuf::Descriptor* OperatorProfile_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  OperatorProfile_reflection_ = NULL;
const ::google::protobuf::Descriptor* StreamProfile_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  StreamProfile_reflection_ = NULL;
const ::google::protobuf::Descriptor* MetricValue_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  MetricValue_reflection_ = NULL;
const ::google::protobuf::Descriptor* Registry_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Registry_reflection_ = NULL;
const ::google::protobuf::Descriptor* Jar_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Jar_reflection_ = NULL;
const ::google::protobuf::Descriptor* SaslMessage_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  SaslMessage_reflection_ = NULL;
const ::google::protobuf::EnumDescriptor* RpcChannel_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* QueryType_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* FragmentState_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* CoreOperatorType_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* SaslStatus_descriptor_ = NULL;

}  // namespace


void protobuf_AssignDesc_UserBitShared_2eproto() {
  protobuf_AddDesc_UserBitShared_2eproto();
  const ::google::protobuf::FileDescriptor* file =
    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
      "UserBitShared.proto");
  GOOGLE_CHECK(file != NULL);
  UserCredentials_descriptor_ = file->message_type(0);
  static const int UserCredentials_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserCredentials, user_name_),
  };
  UserCredentials_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      UserCredentials_descriptor_,
      UserCredentials::default_instance_,
      UserCredentials_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserCredentials, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserCredentials, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(UserCredentials));
  QueryId_descriptor_ = file->message_type(1);
  static const int QueryId_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryId, part1_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryId, part2_),
  };
  QueryId_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      QueryId_descriptor_,
      QueryId::default_instance_,
      QueryId_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryId, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryId, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(QueryId));
  DrillPBError_descriptor_ = file->message_type(2);
  static const int DrillPBError_offsets_[6] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DrillPBError, error_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DrillPBError, endpoint_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DrillPBError, error_type_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DrillPBError, message_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DrillPBError, exception_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DrillPBError, parsing_error_),
  };
  DrillPBError_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      DrillPBError_descriptor_,
      DrillPBError::default_instance_,
      DrillPBError_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DrillPBError, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DrillPBError, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(DrillPBError));
  DrillPBError_ErrorType_descriptor_ = DrillPBError_descriptor_->enum_type(0);
  ExceptionWrapper_descriptor_ = file->message_type(3);
  static const int ExceptionWrapper_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ExceptionWrapper, exception_class_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ExceptionWrapper, message_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ExceptionWrapper, stack_trace_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ExceptionWrapper, cause_),
  };
  ExceptionWrapper_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      ExceptionWrapper_descriptor_,
      ExceptionWrapper::default_instance_,
      ExceptionWrapper_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ExceptionWrapper, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ExceptionWrapper, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(ExceptionWrapper));
  StackTraceElementWrapper_descriptor_ = file->message_type(4);
  static const int StackTraceElementWrapper_offsets_[5] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StackTraceElementWrapper, class_name_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StackTraceElementWrapper, file_name_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StackTraceElementWrapper, line_number_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StackTraceElementWrapper, method_name_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StackTraceElementWrapper, is_native_method_),
  };
  StackTraceElementWrapper_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      StackTraceElementWrapper_descriptor_,
      StackTraceElementWrapper::default_instance_,
      StackTraceElementWrapper_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StackTraceElementWrapper, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StackTraceElementWrapper, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(StackTraceElementWrapper));
  ParsingError_descriptor_ = file->message_type(5);
  static const int ParsingError_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParsingError, start_column_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParsingError, start_row_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParsingError, end_column_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParsingError, end_row_),
  };
  ParsingError_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      ParsingError_descriptor_,
      ParsingError::default_instance_,
      ParsingError_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParsingError, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParsingError, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(ParsingError));
  RecordBatchDef_descriptor_ = file->message_type(6);
  static const int RecordBatchDef_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecordBatchDef, record_count_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecordBatchDef, field_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecordBatchDef, carries_two_byte_selection_vector_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecordBatchDef, affected_rows_count_),
  };
  RecordBatchDef_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      RecordBatchDef_descriptor_,
      RecordBatchDef::default_instance_,
      RecordBatchDef_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecordBatchDef, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecordBatchDef, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(RecordBatchDef));
  NamePart_descriptor_ = file->message_type(7);
  static const int NamePart_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NamePart, type_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NamePart, name_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NamePart, child_),
  };
  NamePart_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      NamePart_descriptor_,
      NamePart::default_instance_,
      NamePart_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NamePart, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NamePart, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(NamePart));
  NamePart_Type_descriptor_ = NamePart_descriptor_->enum_type(0);
  SerializedField_descriptor_ = file->message_type(8);
  static const int SerializedField_offsets_[6] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SerializedField, major_type_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SerializedField, name_part_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SerializedField, child_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SerializedField, value_count_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SerializedField, var_byte_length_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SerializedField, buffer_length_),
  };
  SerializedField_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      SerializedField_descriptor_,
      SerializedField::default_instance_,
      SerializedField_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SerializedField, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SerializedField, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(SerializedField));
  NodeStatus_descriptor_ = file->message_type(9);
  static const int NodeStatus_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NodeStatus, node_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NodeStatus, memory_footprint_),
  };
  NodeStatus_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      NodeStatus_descriptor_,
      NodeStatus::default_instance_,
      NodeStatus_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NodeStatus, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NodeStatus, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(NodeStatus));
  QueryResult_descriptor_ = file->message_type(10);
  static const int QueryResult_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryResult, query_state_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryResult, query_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryResult, error_),
  };
  QueryResult_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      QueryResult_descriptor_,
      QueryResult::default_instance_,
      QueryResult_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryResult, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryResult, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(QueryResult));
  QueryResult_QueryState_descriptor_ = QueryResult_descriptor_->enum_type(0);
  QueryData_descriptor_ = file->message_type(11);
  static const int QueryData_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryData, query_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryData, row_count_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryData, def_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryData, affected_rows_count_),
  };
  QueryData_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      QueryData_descriptor_,
      QueryData::default_instance_,
      QueryData_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryData, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryData, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(QueryData));
  QueryInfo_descriptor_ = file->message_type(12);
  static const int QueryInfo_offsets_[8] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryInfo, query_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryInfo, start_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryInfo, state_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryInfo, user_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryInfo, foreman_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryInfo, options_json_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryInfo, total_cost_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryInfo, queue_name_),
  };
  QueryInfo_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      QueryInfo_descriptor_,
      QueryInfo::default_instance_,
      QueryInfo_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryInfo, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryInfo, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(QueryInfo));
  QueryProfile_descriptor_ = file->message_type(13);
  static const int QueryProfile_offsets_[22] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryProfile, id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryProfile, type_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryProfile, start_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryProfile, end_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryProfile, query_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryProfile, plan_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryProfile, foreman_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryProfile, state_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryProfile, total_fragments_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryProfile, finished_fragments_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryProfile, fragment_profile_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryProfile, user_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryProfile, error_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryProfile, verboseerror_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryProfile, error_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryProfile, error_node_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryProfile, options_json_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryProfile, planend_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryProfile, queuewaitend_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryProfile, total_cost_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryProfile, queue_name_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryProfile, queryid_),
  };
  QueryProfile_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      QueryProfile_descriptor_,
      QueryProfile::default_instance_,
      QueryProfile_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryProfile, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryProfile, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(QueryProfile));
  MajorFragmentProfile_descriptor_ = file->message_type(14);
  static const int MajorFragmentProfile_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MajorFragmentProfile, major_fragment_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MajorFragmentProfile, minor_fragment_profile_),
  };
  MajorFragmentProfile_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      MajorFragmentProfile_descriptor_,
      MajorFragmentProfile::default_instance_,
      MajorFragmentProfile_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MajorFragmentProfile, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MajorFragmentProfile, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(MajorFragmentProfile));
  MinorFragmentProfile_descriptor_ = file->message_type(15);
  static const int MinorFragmentProfile_offsets_[11] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MinorFragmentProfile, state_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MinorFragmentProfile, error_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MinorFragmentProfile, minor_fragment_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MinorFragmentProfile, operator_profile_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MinorFragmentProfile, start_time_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MinorFragmentProfile, end_time_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MinorFragmentProfile, memory_used_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MinorFragmentProfile, max_memory_used_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MinorFragmentProfile, endpoint_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MinorFragmentProfile, last_update_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MinorFragmentProfile, last_progress_),
  };
  MinorFragmentProfile_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      MinorFragmentProfile_descriptor_,
      MinorFragmentProfile::default_instance_,
      MinorFragmentProfile_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MinorFragmentProfile, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MinorFragmentProfile, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(MinorFragmentProfile));
  OperatorProfile_descriptor_ = file->message_type(16);
  static const int OperatorProfile_offsets_[8] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OperatorProfile, input_profile_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OperatorProfile, operator_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OperatorProfile, operator_type_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OperatorProfile, setup_nanos_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OperatorProfile, process_nanos_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OperatorProfile, peak_local_memory_allocated_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OperatorProfile, metric_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OperatorProfile, wait_nanos_),
  };
  OperatorProfile_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      OperatorProfile_descriptor_,
      OperatorProfile::default_instance_,
      OperatorProfile_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OperatorProfile, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OperatorProfile, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(OperatorProfile));
  StreamProfile_descriptor_ = file->message_type(17);
  static const int StreamProfile_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamProfile, records_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamProfile, batches_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamProfile, schemas_),
  };
  StreamProfile_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      StreamProfile_descriptor_,
      StreamProfile::default_instance_,
      StreamProfile_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamProfile, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamProfile, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(StreamProfile));
  MetricValue_descriptor_ = file->message_type(18);
  static const int MetricValue_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MetricValue, metric_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MetricValue, long_value_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MetricValue, double_value_),
  };
  MetricValue_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      MetricValue_descriptor_,
      MetricValue::default_instance_,
      MetricValue_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MetricValue, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MetricValue, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(MetricValue));
  Registry_descriptor_ = file->message_type(19);
  static const int Registry_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Registry, jar_),
  };
  Registry_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      Registry_descriptor_,
      Registry::default_instance_,
      Registry_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Registry, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Registry, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(Registry));
  Jar_descriptor_ = file->message_type(20);
  static const int Jar_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Jar, name_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Jar, function_signature_),
  };
  Jar_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      Jar_descriptor_,
      Jar::default_instance_,
      Jar_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Jar, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Jar, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(Jar));
  SaslMessage_descriptor_ = file->message_type(21);
  static const int SaslMessage_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SaslMessage, mechanism_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SaslMessage, data_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SaslMessage, status_),
  };
  SaslMessage_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      SaslMessage_descriptor_,
      SaslMessage::default_instance_,
      SaslMessage_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SaslMessage, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SaslMessage, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(SaslMessage));
  RpcChannel_descriptor_ = file->enum_type(0);
  QueryType_descriptor_ = file->enum_type(1);
  FragmentState_descriptor_ = file->enum_type(2);
  CoreOperatorType_descriptor_ = file->enum_type(3);
  SaslStatus_descriptor_ = file->enum_type(4);
}

namespace {

GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
inline void protobuf_AssignDescriptorsOnce() {
  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
                 &protobuf_AssignDesc_UserBitShared_2eproto);
}

void protobuf_RegisterTypes(const ::std::string&) {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    UserCredentials_descriptor_, &UserCredentials::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    QueryId_descriptor_, &QueryId::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    DrillPBError_descriptor_, &DrillPBError::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    ExceptionWrapper_descriptor_, &ExceptionWrapper::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    StackTraceElementWrapper_descriptor_, &StackTraceElementWrapper::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    ParsingError_descriptor_, &ParsingError::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    RecordBatchDef_descriptor_, &RecordBatchDef::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    NamePart_descriptor_, &NamePart::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    SerializedField_descriptor_, &SerializedField::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    NodeStatus_descriptor_, &NodeStatus::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    QueryResult_descriptor_, &QueryResult::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    QueryData_descriptor_, &QueryData::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    QueryInfo_descriptor_, &QueryInfo::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    QueryProfile_descriptor_, &QueryProfile::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    MajorFragmentProfile_descriptor_, &MajorFragmentProfile::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    MinorFragmentProfile_descriptor_, &MinorFragmentProfile::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    OperatorProfile_descriptor_, &OperatorProfile::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    StreamProfile_descriptor_, &StreamProfile::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    MetricValue_descriptor_, &MetricValue::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    Registry_descriptor_, &Registry::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    Jar_descriptor_, &Jar::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    SaslMessage_descriptor_, &SaslMessage::default_instance());
}

}  // namespace

void protobuf_ShutdownFile_UserBitShared_2eproto() {
  delete UserCredentials::default_instance_;
  delete UserCredentials_reflection_;
  delete QueryId::default_instance_;
  delete QueryId_reflection_;
  delete DrillPBError::default_instance_;
  delete DrillPBError_reflection_;
  delete ExceptionWrapper::default_instance_;
  delete ExceptionWrapper_reflection_;
  delete StackTraceElementWrapper::default_instance_;
  delete StackTraceElementWrapper_reflection_;
  delete ParsingError::default_instance_;
  delete ParsingError_reflection_;
  delete RecordBatchDef::default_instance_;
  delete RecordBatchDef_reflection_;
  delete NamePart::default_instance_;
  delete NamePart_reflection_;
  delete SerializedField::default_instance_;
  delete SerializedField_reflection_;
  delete NodeStatus::default_instance_;
  delete NodeStatus_reflection_;
  delete QueryResult::default_instance_;
  delete QueryResult_reflection_;
  delete QueryData::default_instance_;
  delete QueryData_reflection_;
  delete QueryInfo::default_instance_;
  delete QueryInfo_reflection_;
  delete QueryInfo::_default_user_;
  delete QueryInfo::_default_queue_name_;
  delete QueryProfile::default_instance_;
  delete QueryProfile_reflection_;
  delete QueryProfile::_default_user_;
  delete QueryProfile::_default_queue_name_;
  delete MajorFragmentProfile::default_instance_;
  delete MajorFragmentProfile_reflection_;
  delete MinorFragmentProfile::default_instance_;
  delete MinorFragmentProfile_reflection_;
  delete OperatorProfile::default_instance_;
  delete OperatorProfile_reflection_;
  delete StreamProfile::default_instance_;
  delete StreamProfile_reflection_;
  delete MetricValue::default_instance_;
  delete MetricValue_reflection_;
  delete Registry::default_instance_;
  delete Registry_reflection_;
  delete Jar::default_instance_;
  delete Jar_reflection_;
  delete SaslMessage::default_instance_;
  delete SaslMessage_reflection_;
}

void protobuf_AddDesc_UserBitShared_2eproto() {
  static bool already_here = false;
  if (already_here) return;
  already_here = true;
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  ::common::protobuf_AddDesc_Types_2eproto();
  ::exec::protobuf_AddDesc_Coordination_2eproto();
  ::exec::protobuf_AddDesc_SchemaDef_2eproto();
  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
    "\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-\"\263\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\"t\n\024MajorFragment"
    "Profile\022\031\n\021major_fragment_id\030\001 \001(\005\022A\n\026mi"
    "nor_fragment_profile\030\002 \003(\0132!.exec.shared"
    ".MinorFragmentProfile\"\350\002\n\024MinorFragmentP"
    "rofile\022)\n\005state\030\001 \001(\0162\032.exec.shared.Frag"
    "mentState\022(\n\005error\030\002 \001(\0132\031.exec.shared.D"
    "rillPBError\022\031\n\021minor_fragment_id\030\003 \001(\005\0226"
    "\n\020operator_profile\030\004 \003(\0132\034.exec.shared.O"
    "peratorProfile\022\022\n\nstart_time\030\005 \001(\003\022\020\n\010en"
    "d_time\030\006 \001(\003\022\023\n\013memory_used\030\007 \001(\003\022\027\n\017max"
    "_memory_used\030\010 \001(\003\022(\n\010endpoint\030\t \001(\0132\026.e"
    "xec.DrillbitEndpoint\022\023\n\013last_update\030\n \001("
    "\003\022\025\n\rlast_progress\030\013 \001(\003\"\377\001\n\017OperatorPro"
    "file\0221\n\rinput_profile\030\001 \003(\0132\032.exec.share"
    "d.StreamProfile\022\023\n\013operator_id\030\003 \001(\005\022\025\n\r"
    "operator_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_me"
    "mory_allocated\030\007 \001(\003\022(\n\006metric\030\010 \003(\0132\030.e"
    "xec.shared.MetricValue\022\022\n\nwait_nanos\030\t \001"
    "(\003\"B\n\rStreamProfile\022\017\n\007records\030\001 \001(\003\022\017\n\007"
    "batches\030\002 \001(\003\022\017\n\007schemas\030\003 \001(\003\"J\n\013Metric"
    "Value\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.shared.Jar\"/\n\003Jar\022\014\n\004"
    "name\030\001 \001(\t\022\032\n\022function_signature\030\002 \003(\t\"W"
    "\n\013SaslMessage\022\021\n\tmechanism\030\001 \001(\t\022\014\n\004data"
    "\030\002 \001(\014\022\'\n\006status\030\003 \001(\0162\027.exec.shared.Sas"
    "lStatus*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\003S"
    "QL\020\001\022\013\n\007LOGICAL\020\002\022\014\n\010PHYSICAL\020\003\022\r\n\tEXECU"
    "TION\020\004\022\026\n\022PREPARED_STATEMENT\020\005*\207\001\n\rFragm"
    "entState\022\013\n\007SENDING\020\000\022\027\n\023AWAITING_ALLOCA"
    "TION\020\001\022\013\n\007RUNNING\020\002\022\014\n\010FINISHED\020\003\022\r\n\tCAN"
    "CELLED\020\004\022\n\n\006FAILED\020\005\022\032\n\026CANCELLATION_REQ"
    "UESTED\020\006*\222\t\n\020CoreOperatorType\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\020MERGING_RECEIVER\020\010\022\034\n\030ORD"
    "ERED_PARTITION_SENDER\020\t\022\013\n\007PROJECT\020\n\022\026\n\022"
    "UNORDERED_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\023STREAMING_AGGREGATE\020\017\022\016\n\nT"
    "OP_N_SORT\020\020\022\021\n\rEXTERNAL_SORT\020\021\022\t\n\005TRACE\020"
    "\022\022\t\n\005UNION\020\023\022\014\n\010OLD_SORT\020\024\022\032\n\026PARQUET_RO"
    "W_GROUP_SCAN\020\025\022\021\n\rHIVE_SUB_SCAN\020\026\022\025\n\021SYS"
    "TEM_TABLE_SCAN\020\027\022\021\n\rMOCK_SUB_SCAN\020\030\022\022\n\016P"
    "ARQUET_WRITER\020\031\022\023\n\017DIRECT_SUB_SCAN\020\032\022\017\n\013"
    "TEXT_WRITER\020\033\022\021\n\rTEXT_SUB_SCAN\020\034\022\021\n\rJSON"
    "_SUB_SCAN\020\035\022\030\n\024INFO_SCHEMA_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\020NES"
    "TED_LOOP_JOIN\020#\022\021\n\rAVRO_SUB_SCAN\020$\022\021\n\rPC"
    "AP_SUB_SCAN\020%\022\022\n\016KAFKA_SUB_SCAN\020&\022\021\n\rKUD"
    "U_SUB_SCAN\020\'\022\013\n\007FLATTEN\020(\022\020\n\014LATERAL_JOI"
    "N\020)\022\n\n\006UNNEST\020*\022,\n(HIVE_DRILL_NATIVE_PAR"
    "QUET_ROW_GROUP_SCAN\020+\022\r\n\tJDBC_SCAN\020,\022\022\n\016"
    "REGEX_SUB_SCAN\020-\022\023\n\017MAPRDB_SUB_SCAN\020.\022\022\n"
    "\016MONGO_SUB_SCAN\020/\022\017\n\013KUDU_WRITER\0200\022\026\n\022OP"
    "EN_TSDB_SUB_SCAN\0201\022\017\n\013JSON_WRITER\0202\022\026\n\022H"
    "TPPD_LOG_SUB_SCAN\0203\022\022\n\016IMAGE_SUB_SCAN\0204\022"
    "\025\n\021SEQUENCE_SUB_SCAN\0205\022\023\n\017PARTITION_LIMI"
    "T\0206\022\023\n\017PCAPNG_SUB_SCAN\0207\022\022\n\016RUNTIME_FILT"
    "ER\0208\022\017\n\013ROWKEY_JOIN\0209*g\n\nSaslStatus\022\020\n\014S"
    "ASL_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_FA"
    "ILED\020\004B.\n\033org.apache.drill.exec.protoB\rU"
    "serBitSharedH\001", 5534);
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
    "UserBitShared.proto", &protobuf_RegisterTypes);
  UserCredentials::default_instance_ = new UserCredentials();
  QueryId::default_instance_ = new QueryId();
  DrillPBError::default_instance_ = new DrillPBError();
  ExceptionWrapper::default_instance_ = new ExceptionWrapper();
  StackTraceElementWrapper::default_instance_ = new StackTraceElementWrapper();
  ParsingError::default_instance_ = new ParsingError();
  RecordBatchDef::default_instance_ = new RecordBatchDef();
  NamePart::default_instance_ = new NamePart();
  SerializedField::default_instance_ = new SerializedField();
  NodeStatus::default_instance_ = new NodeStatus();
  QueryResult::default_instance_ = new QueryResult();
  QueryData::default_instance_ = new QueryData();
  QueryInfo::_default_user_ =
      new ::std::string("-", 1);
  QueryInfo::_default_queue_name_ =
      new ::std::string("-", 1);
  QueryInfo::default_instance_ = new QueryInfo();
  QueryProfile::_default_user_ =
      new ::std::string("-", 1);
  QueryProfile::_default_queue_name_ =
      new ::std::string("-", 1);
  QueryProfile::default_instance_ = new QueryProfile();
  MajorFragmentProfile::default_instance_ = new MajorFragmentProfile();
  MinorFragmentProfile::default_instance_ = new MinorFragmentProfile();
  OperatorProfile::default_instance_ = new OperatorProfile();
  StreamProfile::default_instance_ = new StreamProfile();
  MetricValue::default_instance_ = new MetricValue();
  Registry::default_instance_ = new Registry();
  Jar::default_instance_ = new Jar();
  SaslMessage::default_instance_ = new SaslMessage();
  UserCredentials::default_instance_->InitAsDefaultInstance();
  QueryId::default_instance_->InitAsDefaultInstance();
  DrillPBError::default_instance_->InitAsDefaultInstance();
  ExceptionWrapper::default_instance_->InitAsDefaultInstance();
  StackTraceElementWrapper::default_instance_->InitAsDefaultInstance();
  ParsingError::default_instance_->InitAsDefaultInstance();
  RecordBatchDef::default_instance_->InitAsDefaultInstance();
  NamePart::default_instance_->InitAsDefaultInstance();
  SerializedField::default_instance_->InitAsDefaultInstance();
  NodeStatus::default_instance_->InitAsDefaultInstance();
  QueryResult::default_instance_->InitAsDefaultInstance();
  QueryData::default_instance_->InitAsDefaultInstance();
  QueryInfo::default_instance_->InitAsDefaultInstance();
  QueryProfile::default_instance_->InitAsDefaultInstance();
  MajorFragmentProfile::default_instance_->InitAsDefaultInstance();
  MinorFragmentProfile::default_instance_->InitAsDefaultInstance();
  OperatorProfile::default_instance_->InitAsDefaultInstance();
  StreamProfile::default_instance_->InitAsDefaultInstance();
  MetricValue::default_instance_->InitAsDefaultInstance();
  Registry::default_instance_->InitAsDefaultInstance();
  Jar::default_instance_->InitAsDefaultInstance();
  SaslMessage::default_instance_->InitAsDefaultInstance();
  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_UserBitShared_2eproto);
}

// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_UserBitShared_2eproto {
  StaticDescriptorInitializer_UserBitShared_2eproto() {
    protobuf_AddDesc_UserBitShared_2eproto();
  }
} static_descriptor_initializer_UserBitShared_2eproto_;
const ::google::protobuf::EnumDescriptor* RpcChannel_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return RpcChannel_descriptor_;
}
bool RpcChannel_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* QueryType_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return QueryType_descriptor_;
}
bool QueryType_IsValid(int value) {
  switch(value) {
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* FragmentState_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return FragmentState_descriptor_;
}
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 ::google::protobuf::EnumDescriptor* CoreOperatorType_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CoreOperatorType_descriptor_;
}
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:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* SaslStatus_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return SaslStatus_descriptor_;
}
bool SaslStatus_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
      return true;
    default:
      return false;
  }
}


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

#ifndef _MSC_VER
const int UserCredentials::kUserNameFieldNumber;
#endif  // !_MSC_VER

UserCredentials::UserCredentials()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void UserCredentials::InitAsDefaultInstance() {
}

UserCredentials::UserCredentials(const UserCredentials& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void UserCredentials::SharedCtor() {
  _cached_size_ = 0;
  user_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

UserCredentials::~UserCredentials() {
  SharedDtor();
}

void UserCredentials::SharedDtor() {
  if (user_name_ != &::google::protobuf::internal::kEmptyString) {
    delete user_name_;
  }
  if (this != default_instance_) {
  }
}

void UserCredentials::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* UserCredentials::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return UserCredentials_descriptor_;
}

const UserCredentials& UserCredentials::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_UserBitShared_2eproto();
  return *default_instance_;
}

UserCredentials* UserCredentials::default_instance_ = NULL;

UserCredentials* UserCredentials::New() const {
  return new UserCredentials;
}

void UserCredentials::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_user_name()) {
      if (user_name_ != &::google::protobuf::internal::kEmptyString) {
        user_name_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool UserCredentials::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string user_name = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_user_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->user_name().data(), this->user_name().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void UserCredentials::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional string user_name = 1;
  if (has_user_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->user_name().data(), this->user_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->user_name(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* UserCredentials::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional string user_name = 1;
  if (has_user_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->user_name().data(), this->user_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->user_name(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int UserCredentials::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional string user_name = 1;
    if (has_user_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->user_name());
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void UserCredentials::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const UserCredentials* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const UserCredentials*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void UserCredentials::MergeFrom(const UserCredentials& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_user_name()) {
      set_user_name(from.user_name());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void UserCredentials::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void UserCredentials::CopyFrom(const UserCredentials& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool UserCredentials::IsInitialized() const {

  return true;
}

void UserCredentials::Swap(UserCredentials* other) {
  if (other != this) {
    std::swap(user_name_, other->user_name_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata UserCredentials::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = UserCredentials_descriptor_;
  metadata.reflection = UserCredentials_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int QueryId::kPart1FieldNumber;
const int QueryId::kPart2FieldNumber;
#endif  // !_MSC_VER

QueryId::QueryId()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void QueryId::InitAsDefaultInstance() {
}

QueryId::QueryId(const QueryId& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void QueryId::SharedCtor() {
  _cached_size_ = 0;
  part1_ = GOOGLE_LONGLONG(0);
  part2_ = GOOGLE_LONGLONG(0);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

QueryId::~QueryId() {
  SharedDtor();
}

void QueryId::SharedDtor() {
  if (this != default_instance_) {
  }
}

void QueryId::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* QueryId::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return QueryId_descriptor_;
}

const QueryId& QueryId::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_UserBitShared_2eproto();
  return *default_instance_;
}

QueryId* QueryId::default_instance_ = NULL;

QueryId* QueryId::New() const {
  return new QueryId;
}

void QueryId::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    part1_ = GOOGLE_LONGLONG(0);
    part2_ = GOOGLE_LONGLONG(0);
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool QueryId::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional sfixed64 part1 = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_SFIXED64>(
                 input, &part1_)));
          set_has_part1();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(17)) goto parse_part2;
        break;
      }

      // optional sfixed64 part2 = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_part2:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_SFIXED64>(
                 input, &part2_)));
          set_has_part2();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void QueryId::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional sfixed64 part1 = 1;
  if (has_part1()) {
    ::google::protobuf::internal::WireFormatLite::WriteSFixed64(1, this->part1(), output);
  }

  // optional sfixed64 part2 = 2;
  if (has_part2()) {
    ::google::protobuf::internal::WireFormatLite::WriteSFixed64(2, this->part2(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* QueryId::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional sfixed64 part1 = 1;
  if (has_part1()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteSFixed64ToArray(1, this->part1(), target);
  }

  // optional sfixed64 part2 = 2;
  if (has_part2()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteSFixed64ToArray(2, this->part2(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int QueryId::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional sfixed64 part1 = 1;
    if (has_part1()) {
      total_size += 1 + 8;
    }

    // optional sfixed64 part2 = 2;
    if (has_part2()) {
      total_size += 1 + 8;
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void QueryId::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const QueryId* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const QueryId*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void QueryId::MergeFrom(const QueryId& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_part1()) {
      set_part1(from.part1());
    }
    if (from.has_part2()) {
      set_part2(from.part2());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void QueryId::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void QueryId::CopyFrom(const QueryId& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool QueryId::IsInitialized() const {

  return true;
}

void QueryId::Swap(QueryId* other) {
  if (other != this) {
    std::swap(part1_, other->part1_);
    std::swap(part2_, other->part2_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata QueryId::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = QueryId_descriptor_;
  metadata.reflection = QueryId_reflection_;
  return metadata;
}


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

const ::google::protobuf::EnumDescriptor* DrillPBError_ErrorType_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return DrillPBError_ErrorType_descriptor_;
}
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;
  }
}

#ifndef _MSC_VER
const DrillPBError_ErrorType DrillPBError::CONNECTION;
const DrillPBError_ErrorType DrillPBError::DATA_READ;
const DrillPBError_ErrorType DrillPBError::DATA_WRITE;
const DrillPBError_ErrorType DrillPBError::FUNCTION;
const DrillPBError_ErrorType DrillPBError::PARSE;
const DrillPBError_ErrorType DrillPBError::PERMISSION;
const DrillPBError_ErrorType DrillPBError::PLAN;
const DrillPBError_ErrorType DrillPBError::RESOURCE;
const DrillPBError_ErrorType DrillPBError::SYSTEM;
const DrillPBError_ErrorType DrillPBError::UNSUPPORTED_OPERATION;
const DrillPBError_ErrorType DrillPBError::VALIDATION;
const DrillPBError_ErrorType DrillPBError::EXECUTION_ERROR;
const DrillPBError_ErrorType DrillPBError::INTERNAL_ERROR;
const DrillPBError_ErrorType DrillPBError::UNSPECIFIED_ERROR;
const DrillPBError_ErrorType DrillPBError::ErrorType_MIN;
const DrillPBError_ErrorType DrillPBError::ErrorType_MAX;
const int DrillPBError::ErrorType_ARRAYSIZE;
#endif  // _MSC_VER
#ifndef _MSC_VER
const int DrillPBError::kErrorIdFieldNumber;
const int DrillPBError::kEndpointFieldNumber;
const int DrillPBError::kErrorTypeFieldNumber;
const int DrillPBError::kMessageFieldNumber;
const int DrillPBError::kExceptionFieldNumber;
const int DrillPBError::kParsingErrorFieldNumber;
#endif  // !_MSC_VER

DrillPBError::DrillPBError()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void DrillPBError::InitAsDefaultInstance() {
  endpoint_ = const_cast< ::exec::DrillbitEndpoint*>(&::exec::DrillbitEndpoint::default_instance());
  exception_ = const_cast< ::exec::shared::ExceptionWrapper*>(&::exec::shared::ExceptionWrapper::default_instance());
}

DrillPBError::DrillPBError(const DrillPBError& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void DrillPBError::SharedCtor() {
  _cached_size_ = 0;
  error_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  endpoint_ = NULL;
  error_type_ = 0;
  message_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  exception_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

DrillPBError::~DrillPBError() {
  SharedDtor();
}

void DrillPBError::SharedDtor() {
  if (error_id_ != &::google::protobuf::internal::kEmptyString) {
    delete error_id_;
  }
  if (message_ != &::google::protobuf::internal::kEmptyString) {
    delete message_;
  }
  if (this != default_instance_) {
    delete endpoint_;
    delete exception_;
  }
}

void DrillPBError::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* DrillPBError::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return DrillPBError_descriptor_;
}

const DrillPBError& DrillPBError::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_UserBitShared_2eproto();
  return *default_instance_;
}

DrillPBError* DrillPBError::default_instance_ = NULL;

DrillPBError* DrillPBError::New() const {
  return new DrillPBError;
}

void DrillPBError::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_error_id()) {
      if (error_id_ != &::google::protobuf::internal::kEmptyString) {
        error_id_->clear();
      }
    }
    if (has_endpoint()) {
      if (endpoint_ != NULL) endpoint_->::exec::DrillbitEndpoint::Clear();
    }
    error_type_ = 0;
    if (has_message()) {
      if (message_ != &::google::protobuf::internal::kEmptyString) {
        message_->clear();
      }
    }
    if (has_exception()) {
      if (exception_ != NULL) exception_->::exec::shared::ExceptionWrapper::Clear();
    }
  }
  parsing_error_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool DrillPBError::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string error_id = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_error_id()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->error_id().data(), this->error_id().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_endpoint;
        break;
      }

      // optional .exec.DrillbitEndpoint endpoint = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_endpoint:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_endpoint()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_error_type;
        break;
      }

      // optional .exec.shared.DrillPBError.ErrorType error_type = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_error_type:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::exec::shared::DrillPBError_ErrorType_IsValid(value)) {
            set_error_type(static_cast< ::exec::shared::DrillPBError_ErrorType >(value));
          } else {
            mutable_unknown_fields()->AddVarint(3, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(34)) goto parse_message;
        break;
      }

      // optional string message = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_message:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_message()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->message().data(), this->message().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(42)) goto parse_exception;
        break;
      }

      // optional .exec.shared.ExceptionWrapper exception = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_exception:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_exception()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(50)) goto parse_parsing_error;
        break;
      }

      // repeated .exec.shared.ParsingError parsing_error = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_parsing_error:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_parsing_error()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(50)) goto parse_parsing_error;
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void DrillPBError::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional string error_id = 1;
  if (has_error_id()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->error_id().data(), this->error_id().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->error_id(), output);
  }

  // optional .exec.DrillbitEndpoint endpoint = 2;
  if (has_endpoint()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->endpoint(), output);
  }

  // optional .exec.shared.DrillPBError.ErrorType error_type = 3;
  if (has_error_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      3, this->error_type(), output);
  }

  // optional string message = 4;
  if (has_message()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->message().data(), this->message().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      4, this->message(), output);
  }

  // optional .exec.shared.ExceptionWrapper exception = 5;
  if (has_exception()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      5, this->exception(), output);
  }

  // repeated .exec.shared.ParsingError parsing_error = 6;
  for (int i = 0; i < this->parsing_error_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      6, this->parsing_error(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* DrillPBError::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional string error_id = 1;
  if (has_error_id()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->error_id().data(), this->error_id().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->error_id(), target);
  }

  // optional .exec.DrillbitEndpoint endpoint = 2;
  if (has_endpoint()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->endpoint(), target);
  }

  // optional .exec.shared.DrillPBError.ErrorType error_type = 3;
  if (has_error_type()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      3, this->error_type(), target);
  }

  // optional string message = 4;
  if (has_message()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->message().data(), this->message().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        4, this->message(), target);
  }

  // optional .exec.shared.ExceptionWrapper exception = 5;
  if (has_exception()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        5, this->exception(), target);
  }

  // repeated .exec.shared.ParsingError parsing_error = 6;
  for (int i = 0; i < this->parsing_error_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        6, this->parsing_error(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int DrillPBError::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional string error_id = 1;
    if (has_error_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->error_id());
    }

    // optional .exec.DrillbitEndpoint endpoint = 2;
    if (has_endpoint()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->endpoint());
    }

    // optional .exec.shared.DrillPBError.ErrorType error_type = 3;
    if (has_error_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->error_type());
    }

    // optional string message = 4;
    if (has_message()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->message());
    }

    // optional .exec.shared.ExceptionWrapper exception = 5;
    if (has_exception()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->exception());
    }

  }
  // repeated .exec.shared.ParsingError parsing_error = 6;
  total_size += 1 * this->parsing_error_size();
  for (int i = 0; i < this->parsing_error_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->parsing_error(i));
  }

  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void DrillPBError::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const DrillPBError* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const DrillPBError*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void DrillPBError::MergeFrom(const DrillPBError& from) {
  GOOGLE_CHECK_NE(&from, this);
  parsing_error_.MergeFrom(from.parsing_error_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_error_id()) {
      set_error_id(from.error_id());
    }
    if (from.has_endpoint()) {
      mutable_endpoint()->::exec::DrillbitEndpoint::MergeFrom(from.endpoint());
    }
    if (from.has_error_type()) {
      set_error_type(from.error_type());
    }
    if (from.has_message()) {
      set_message(from.message());
    }
    if (from.has_exception()) {
      mutable_exception()->::exec::shared::ExceptionWrapper::MergeFrom(from.exception());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void DrillPBError::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void DrillPBError::CopyFrom(const DrillPBError& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DrillPBError::IsInitialized() const {

  return true;
}

void DrillPBError::Swap(DrillPBError* other) {
  if (other != this) {
    std::swap(error_id_, other->error_id_);
    std::swap(endpoint_, other->endpoint_);
    std::swap(error_type_, other->error_type_);
    std::swap(message_, other->message_);
    std::swap(exception_, other->exception_);
    parsing_error_.Swap(&other->parsing_error_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata DrillPBError::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = DrillPBError_descriptor_;
  metadata.reflection = DrillPBError_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int ExceptionWrapper::kExceptionClassFieldNumber;
const int ExceptionWrapper::kMessageFieldNumber;
const int ExceptionWrapper::kStackTraceFieldNumber;
const int ExceptionWrapper::kCauseFieldNumber;
#endif  // !_MSC_VER

ExceptionWrapper::ExceptionWrapper()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void ExceptionWrapper::InitAsDefaultInstance() {
  cause_ = const_cast< ::exec::shared::ExceptionWrapper*>(&::exec::shared::ExceptionWrapper::default_instance());
}

ExceptionWrapper::ExceptionWrapper(const ExceptionWrapper& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void ExceptionWrapper::SharedCtor() {
  _cached_size_ = 0;
  exception_class_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  message_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  cause_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ExceptionWrapper::~ExceptionWrapper() {
  SharedDtor();
}

void ExceptionWrapper::SharedDtor() {
  if (exception_class_ != &::google::protobuf::internal::kEmptyString) {
    delete exception_class_;
  }
  if (message_ != &::google::protobuf::internal::kEmptyString) {
    delete message_;
  }
  if (this != default_instance_) {
    delete cause_;
  }
}

void ExceptionWrapper::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ExceptionWrapper::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return ExceptionWrapper_descriptor_;
}

const ExceptionWrapper& ExceptionWrapper::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_UserBitShared_2eproto();
  return *default_instance_;
}

ExceptionWrapper* ExceptionWrapper::default_instance_ = NULL;

ExceptionWrapper* ExceptionWrapper::New() const {
  return new ExceptionWrapper;
}

void ExceptionWrapper::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_exception_class()) {
      if (exception_class_ != &::google::protobuf::internal::kEmptyString) {
        exception_class_->clear();
      }
    }
    if (has_message()) {
      if (message_ != &::google::protobuf::internal::kEmptyString) {
        message_->clear();
      }
    }
    if (has_cause()) {
      if (cause_ != NULL) cause_->::exec::shared::ExceptionWrapper::Clear();
    }
  }
  stack_trace_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool ExceptionWrapper::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string exception_class = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_exception_class()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->exception_class().data(), this->exception_class().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_message;
        break;
      }

      // optional string message = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_message:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_message()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->message().data(), this->message().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(26)) goto parse_stack_trace;
        break;
      }

      // repeated .exec.shared.StackTraceElementWrapper stack_trace = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_stack_trace:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_stack_trace()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(26)) goto parse_stack_trace;
        if (input->ExpectTag(34)) goto parse_cause;
        break;
      }

      // optional .exec.shared.ExceptionWrapper cause = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_cause:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_cause()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void ExceptionWrapper::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional string exception_class = 1;
  if (has_exception_class()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->exception_class().data(), this->exception_class().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->exception_class(), output);
  }

  // optional string message = 2;
  if (has_message()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->message().data(), this->message().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      2, this->message(), output);
  }

  // repeated .exec.shared.StackTraceElementWrapper stack_trace = 3;
  for (int i = 0; i < this->stack_trace_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, this->stack_trace(i), output);
  }

  // optional .exec.shared.ExceptionWrapper cause = 4;
  if (has_cause()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      4, this->cause(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* ExceptionWrapper::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional string exception_class = 1;
  if (has_exception_class()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->exception_class().data(), this->exception_class().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->exception_class(), target);
  }

  // optional string message = 2;
  if (has_message()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->message().data(), this->message().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        2, this->message(), target);
  }

  // repeated .exec.shared.StackTraceElementWrapper stack_trace = 3;
  for (int i = 0; i < this->stack_trace_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        3, this->stack_trace(i), target);
  }

  // optional .exec.shared.ExceptionWrapper cause = 4;
  if (has_cause()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        4, this->cause(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int ExceptionWrapper::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional string exception_class = 1;
    if (has_exception_class()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->exception_class());
    }

    // optional string message = 2;
    if (has_message()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->message());
    }

    // optional .exec.shared.ExceptionWrapper cause = 4;
    if (has_cause()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->cause());
    }

  }
  // repeated .exec.shared.StackTraceElementWrapper stack_trace = 3;
  total_size += 1 * this->stack_trace_size();
  for (int i = 0; i < this->stack_trace_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->stack_trace(i));
  }

  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ExceptionWrapper::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const ExceptionWrapper* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const ExceptionWrapper*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void ExceptionWrapper::MergeFrom(const ExceptionWrapper& from) {
  GOOGLE_CHECK_NE(&from, this);
  stack_trace_.MergeFrom(from.stack_trace_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_exception_class()) {
      set_exception_class(from.exception_class());
    }
    if (from.has_message()) {
      set_message(from.message());
    }
    if (from.has_cause()) {
      mutable_cause()->::exec::shared::ExceptionWrapper::MergeFrom(from.cause());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void ExceptionWrapper::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ExceptionWrapper::CopyFrom(const ExceptionWrapper& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ExceptionWrapper::IsInitialized() const {

  return true;
}

void ExceptionWrapper::Swap(ExceptionWrapper* other) {
  if (other != this) {
    std::swap(exception_class_, other->exception_class_);
    std::swap(message_, other->message_);
    stack_trace_.Swap(&other->stack_trace_);
    std::swap(cause_, other->cause_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata ExceptionWrapper::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = ExceptionWrapper_descriptor_;
  metadata.reflection = ExceptionWrapper_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int StackTraceElementWrapper::kClassNameFieldNumber;
const int StackTraceElementWrapper::kFileNameFieldNumber;
const int StackTraceElementWrapper::kLineNumberFieldNumber;
const int StackTraceElementWrapper::kMethodNameFieldNumber;
const int StackTraceElementWrapper::kIsNativeMethodFieldNumber;
#endif  // !_MSC_VER

StackTraceElementWrapper::StackTraceElementWrapper()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void StackTraceElementWrapper::InitAsDefaultInstance() {
}

StackTraceElementWrapper::StackTraceElementWrapper(const StackTraceElementWrapper& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void StackTraceElementWrapper::SharedCtor() {
  _cached_size_ = 0;
  class_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  file_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  line_number_ = 0;
  method_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  is_native_method_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

StackTraceElementWrapper::~StackTraceElementWrapper() {
  SharedDtor();
}

void StackTraceElementWrapper::SharedDtor() {
  if (class_name_ != &::google::protobuf::internal::kEmptyString) {
    delete class_name_;
  }
  if (file_name_ != &::google::protobuf::internal::kEmptyString) {
    delete file_name_;
  }
  if (method_name_ != &::google::protobuf::internal::kEmptyString) {
    delete method_name_;
  }
  if (this != default_instance_) {
  }
}

void StackTraceElementWrapper::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* StackTraceElementWrapper::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return StackTraceElementWrapper_descriptor_;
}

const StackTraceElementWrapper& StackTraceElementWrapper::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_UserBitShared_2eproto();
  return *default_instance_;
}

StackTraceElementWrapper* StackTraceElementWrapper::default_instance_ = NULL;

StackTraceElementWrapper* StackTraceElementWrapper::New() const {
  return new StackTraceElementWrapper;
}

void StackTraceElementWrapper::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_class_name()) {
      if (class_name_ != &::google::protobuf::internal::kEmptyString) {
        class_name_->clear();
      }
    }
    if (has_file_name()) {
      if (file_name_ != &::google::protobuf::internal::kEmptyString) {
        file_name_->clear();
      }
    }
    line_number_ = 0;
    if (has_method_name()) {
      if (method_name_ != &::google::protobuf::internal::kEmptyString) {
        method_name_->clear();
      }
    }
    is_native_method_ = false;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool StackTraceElementWrapper::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string class_name = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_class_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->class_name().data(), this->class_name().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_file_name;
        break;
      }

      // optional string file_name = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_file_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_file_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->file_name().data(), this->file_name().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_line_number;
        break;
      }

      // optional int32 line_number = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_line_number:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &line_number_)));
          set_has_line_number();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(34)) goto parse_method_name;
        break;
      }

      // optional string method_name = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_method_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_method_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->method_name().data(), this->method_name().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(40)) goto parse_is_native_method;
        break;
      }

      // optional bool is_native_method = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_is_native_method:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &is_native_method_)));
          set_has_is_native_method();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void StackTraceElementWrapper::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional string class_name = 1;
  if (has_class_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->class_name().data(), this->class_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->class_name(), output);
  }

  // optional string file_name = 2;
  if (has_file_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->file_name().data(), this->file_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      2, this->file_name(), output);
  }

  // optional int32 line_number = 3;
  if (has_line_number()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->line_number(), output);
  }

  // optional string method_name = 4;
  if (has_method_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->method_name().data(), this->method_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      4, this->method_name(), output);
  }

  // optional bool is_native_method = 5;
  if (has_is_native_method()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->is_native_method(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* StackTraceElementWrapper::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional string class_name = 1;
  if (has_class_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->class_name().data(), this->class_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->class_name(), target);
  }

  // optional string file_name = 2;
  if (has_file_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->file_name().data(), this->file_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        2, this->file_name(), target);
  }

  // optional int32 line_number = 3;
  if (has_line_number()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->line_number(), target);
  }

  // optional string method_name = 4;
  if (has_method_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->method_name().data(), this->method_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        4, this->method_name(), target);
  }

  // optional bool is_native_method = 5;
  if (has_is_native_method()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->is_native_method(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int StackTraceElementWrapper::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional string class_name = 1;
    if (has_class_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->class_name());
    }

    // optional string file_name = 2;
    if (has_file_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->file_name());
    }

    // optional int32 line_number = 3;
    if (has_line_number()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->line_number());
    }

    // optional string method_name = 4;
    if (has_method_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->method_name());
    }

    // optional bool is_native_method = 5;
    if (has_is_native_method()) {
      total_size += 1 + 1;
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void StackTraceElementWrapper::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const StackTraceElementWrapper* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const StackTraceElementWrapper*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void StackTraceElementWrapper::MergeFrom(const StackTraceElementWrapper& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_class_name()) {
      set_class_name(from.class_name());
    }
    if (from.has_file_name()) {
      set_file_name(from.file_name());
    }
    if (from.has_line_number()) {
      set_line_number(from.line_number());
    }
    if (from.has_method_name()) {
      set_method_name(from.method_name());
    }
    if (from.has_is_native_method()) {
      set_is_native_method(from.is_native_method());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void StackTraceElementWrapper::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void StackTraceElementWrapper::CopyFrom(const StackTraceElementWrapper& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool StackTraceElementWrapper::IsInitialized() const {

  return true;
}

void StackTraceElementWrapper::Swap(StackTraceElementWrapper* other) {
  if (other != this) {
    std::swap(class_name_, other->class_name_);
    std::swap(file_name_, other->file_name_);
    std::swap(line_number_, other->line_number_);
    std::swap(method_name_, other->method_name_);
    std::swap(is_native_method_, other->is_native_method_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata StackTraceElementWrapper::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = StackTraceElementWrapper_descriptor_;
  metadata.reflection = StackTraceElementWrapper_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int ParsingError::kStartColumnFieldNumber;
const int ParsingError::kStartRowFieldNumber;
const int ParsingError::kEndColumnFieldNumber;
const int ParsingError::kEndRowFieldNumber;
#endif  // !_MSC_VER

ParsingError::ParsingError()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void ParsingError::InitAsDefaultInstance() {
}

ParsingError::ParsingError(const ParsingError& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void ParsingError::SharedCtor() {
  _cached_size_ = 0;
  start_column_ = 0;
  start_row_ = 0;
  end_column_ = 0;
  end_row_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ParsingError::~ParsingError() {
  SharedDtor();
}

void ParsingError::SharedDtor() {
  if (this != default_instance_) {
  }
}

void ParsingError::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ParsingError::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return ParsingError_descriptor_;
}

const ParsingError& ParsingError::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_UserBitShared_2eproto();
  return *default_instance_;
}

ParsingError* ParsingError::default_instance_ = NULL;

ParsingError* ParsingError::New() const {
  return new ParsingError;
}

void ParsingError::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    start_column_ = 0;
    start_row_ = 0;
    end_column_ = 0;
    end_row_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool ParsingError::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 start_column = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &start_column_)));
          set_has_start_column();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_start_row;
        break;
      }

      // optional int32 start_row = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_start_row:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &start_row_)));
          set_has_start_row();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_end_column;
        break;
      }

      // optional int32 end_column = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_end_column:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &end_column_)));
          set_has_end_column();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(40)) goto parse_end_row;
        break;
      }

      // optional int32 end_row = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_end_row:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &end_row_)));
          set_has_end_row();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void ParsingError::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional int32 start_column = 2;
  if (has_start_column()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->start_column(), output);
  }

  // optional int32 start_row = 3;
  if (has_start_row()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->start_row(), output);
  }

  // optional int32 end_column = 4;
  if (has_end_column()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->end_column(), output);
  }

  // optional int32 end_row = 5;
  if (has_end_row()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->end_row(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* ParsingError::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional int32 start_column = 2;
  if (has_start_column()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->start_column(), target);
  }

  // optional int32 start_row = 3;
  if (has_start_row()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->start_row(), target);
  }

  // optional int32 end_column = 4;
  if (has_end_column()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->end_column(), target);
  }

  // optional int32 end_row = 5;
  if (has_end_row()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->end_row(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int ParsingError::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional int32 start_column = 2;
    if (has_start_column()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->start_column());
    }

    // optional int32 start_row = 3;
    if (has_start_row()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->start_row());
    }

    // optional int32 end_column = 4;
    if (has_end_column()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->end_column());
    }

    // optional int32 end_row = 5;
    if (has_end_row()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->end_row());
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ParsingError::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const ParsingError* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const ParsingError*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void ParsingError::MergeFrom(const ParsingError& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_start_column()) {
      set_start_column(from.start_column());
    }
    if (from.has_start_row()) {
      set_start_row(from.start_row());
    }
    if (from.has_end_column()) {
      set_end_column(from.end_column());
    }
    if (from.has_end_row()) {
      set_end_row(from.end_row());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void ParsingError::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ParsingError::CopyFrom(const ParsingError& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ParsingError::IsInitialized() const {

  return true;
}

void ParsingError::Swap(ParsingError* other) {
  if (other != this) {
    std::swap(start_column_, other->start_column_);
    std::swap(start_row_, other->start_row_);
    std::swap(end_column_, other->end_column_);
    std::swap(end_row_, other->end_row_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata ParsingError::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = ParsingError_descriptor_;
  metadata.reflection = ParsingError_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int RecordBatchDef::kRecordCountFieldNumber;
const int RecordBatchDef::kFieldFieldNumber;
const int RecordBatchDef::kCarriesTwoByteSelectionVectorFieldNumber;
const int RecordBatchDef::kAffectedRowsCountFieldNumber;
#endif  // !_MSC_VER

RecordBatchDef::RecordBatchDef()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void RecordBatchDef::InitAsDefaultInstance() {
}

RecordBatchDef::RecordBatchDef(const RecordBatchDef& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void RecordBatchDef::SharedCtor() {
  _cached_size_ = 0;
  record_count_ = 0;
  carries_two_byte_selection_vector_ = false;
  affected_rows_count_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

RecordBatchDef::~RecordBatchDef() {
  SharedDtor();
}

void RecordBatchDef::SharedDtor() {
  if (this != default_instance_) {
  }
}

void RecordBatchDef::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* RecordBatchDef::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return RecordBatchDef_descriptor_;
}

const RecordBatchDef& RecordBatchDef::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_UserBitShared_2eproto();
  return *default_instance_;
}

RecordBatchDef* RecordBatchDef::default_instance_ = NULL;

RecordBatchDef* RecordBatchDef::New() const {
  return new RecordBatchDef;
}

void RecordBatchDef::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    record_count_ = 0;
    carries_two_byte_selection_vector_ = false;
    affected_rows_count_ = 0;
  }
  field_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool RecordBatchDef::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 record_count = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &record_count_)));
          set_has_record_count();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_field;
        break;
      }

      // repeated .exec.shared.SerializedField field = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_field:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_field()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_field;
        if (input->ExpectTag(24)) goto parse_carries_two_byte_selection_vector;
        break;
      }

      // optional bool carries_two_byte_selection_vector = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_carries_two_byte_selection_vector:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &carries_two_byte_selection_vector_)));
          set_has_carries_two_byte_selection_vector();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_affected_rows_count;
        break;
      }

      // optional int32 affected_rows_count = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_affected_rows_count:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &affected_rows_count_)));
          set_has_affected_rows_count();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void RecordBatchDef::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional int32 record_count = 1;
  if (has_record_count()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->record_count(), output);
  }

  // repeated .exec.shared.SerializedField field = 2;
  for (int i = 0; i < this->field_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->field(i), output);
  }

  // optional bool carries_two_byte_selection_vector = 3;
  if (has_carries_two_byte_selection_vector()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->carries_two_byte_selection_vector(), output);
  }

  // optional int32 affected_rows_count = 4;
  if (has_affected_rows_count()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->affected_rows_count(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* RecordBatchDef::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional int32 record_count = 1;
  if (has_record_count()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->record_count(), target);
  }

  // repeated .exec.shared.SerializedField field = 2;
  for (int i = 0; i < this->field_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->field(i), target);
  }

  // optional bool carries_two_byte_selection_vector = 3;
  if (has_carries_two_byte_selection_vector()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->carries_two_byte_selection_vector(), target);
  }

  // optional int32 affected_rows_count = 4;
  if (has_affected_rows_count()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->affected_rows_count(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int RecordBatchDef::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional int32 record_count = 1;
    if (has_record_count()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->record_count());
    }

    // optional bool carries_two_byte_selection_vector = 3;
    if (has_carries_two_byte_selection_vector()) {
      total_size += 1 + 1;
    }

    // optional int32 affected_rows_count = 4;
    if (has_affected_rows_count()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->affected_rows_count());
    }

  }
  // repeated .exec.shared.SerializedField field = 2;
  total_size += 1 * this->field_size();
  for (int i = 0; i < this->field_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->field(i));
  }

  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RecordBatchDef::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const RecordBatchDef* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const RecordBatchDef*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void RecordBatchDef::MergeFrom(const RecordBatchDef& from) {
  GOOGLE_CHECK_NE(&from, this);
  field_.MergeFrom(from.field_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_record_count()) {
      set_record_count(from.record_count());
    }
    if (from.has_carries_two_byte_selection_vector()) {
      set_carries_two_byte_selection_vector(from.carries_two_byte_selection_vector());
    }
    if (from.has_affected_rows_count()) {
      set_affected_rows_count(from.affected_rows_count());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void RecordBatchDef::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RecordBatchDef::CopyFrom(const RecordBatchDef& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RecordBatchDef::IsInitialized() const {

  return true;
}

void RecordBatchDef::Swap(RecordBatchDef* other) {
  if (other != this) {
    std::swap(record_count_, other->record_count_);
    field_.Swap(&other->field_);
    std::swap(carries_two_byte_selection_vector_, other->carries_two_byte_selection_vector_);
    std::swap(affected_rows_count_, other->affected_rows_count_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata RecordBatchDef::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = RecordBatchDef_descriptor_;
  metadata.reflection = RecordBatchDef_reflection_;
  return metadata;
}


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

const ::google::protobuf::EnumDescriptor* NamePart_Type_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return NamePart_Type_descriptor_;
}
bool NamePart_Type_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
      return true;
    default:
      return false;
  }
}

#ifndef _MSC_VER
const NamePart_Type NamePart::NAME;
const NamePart_Type NamePart::ARRAY;
const NamePart_Type NamePart::Type_MIN;
const NamePart_Type NamePart::Type_MAX;
const int NamePart::Type_ARRAYSIZE;
#endif  // _MSC_VER
#ifndef _MSC_VER
const int NamePart::kTypeFieldNumber;
const int NamePart::kNameFieldNumber;
const int NamePart::kChildFieldNumber;
#endif  // !_MSC_VER

NamePart::NamePart()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void NamePart::InitAsDefaultInstance() {
  child_ = const_cast< ::exec::shared::NamePart*>(&::exec::shared::NamePart::default_instance());
}

NamePart::NamePart(const NamePart& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void NamePart::SharedCtor() {
  _cached_size_ = 0;
  type_ = 0;
  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  child_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

NamePart::~NamePart() {
  SharedDtor();
}

void NamePart::SharedDtor() {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    delete name_;
  }
  if (this != default_instance_) {
    delete child_;
  }
}

void NamePart::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* NamePart::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return NamePart_descriptor_;
}

const NamePart& NamePart::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_UserBitShared_2eproto();
  return *default_instance_;
}

NamePart* NamePart::default_instance_ = NULL;

NamePart* NamePart::New() const {
  return new NamePart;
}

void NamePart::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    type_ = 0;
    if (has_name()) {
      if (name_ != &::google::protobuf::internal::kEmptyString) {
        name_->clear();
      }
    }
    if (has_child()) {
      if (child_ != NULL) child_->::exec::shared::NamePart::Clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool NamePart::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .exec.shared.NamePart.Type type = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::exec::shared::NamePart_Type_IsValid(value)) {
            set_type(static_cast< ::exec::shared::NamePart_Type >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_name;
        break;
      }

      // optional string name = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->name().data(), this->name().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(26)) goto parse_child;
        break;
      }

      // optional .exec.shared.NamePart child = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_child:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_child()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void NamePart::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional .exec.shared.NamePart.Type type = 1;
  if (has_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->type(), output);
  }

  // optional string name = 2;
  if (has_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      2, this->name(), output);
  }

  // optional .exec.shared.NamePart child = 3;
  if (has_child()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, this->child(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* NamePart::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional .exec.shared.NamePart.Type type = 1;
  if (has_type()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->type(), target);
  }

  // optional string name = 2;
  if (has_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        2, this->name(), target);
  }

  // optional .exec.shared.NamePart child = 3;
  if (has_child()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        3, this->child(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int NamePart::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .exec.shared.NamePart.Type type = 1;
    if (has_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
    }

    // optional string name = 2;
    if (has_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->name());
    }

    // optional .exec.shared.NamePart child = 3;
    if (has_child()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->child());
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void NamePart::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const NamePart* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const NamePart*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void NamePart::MergeFrom(const NamePart& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_type()) {
      set_type(from.type());
    }
    if (from.has_name()) {
      set_name(from.name());
    }
    if (from.has_child()) {
      mutable_child()->::exec::shared::NamePart::MergeFrom(from.child());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void NamePart::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void NamePart::CopyFrom(const NamePart& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool NamePart::IsInitialized() const {

  return true;
}

void NamePart::Swap(NamePart* other) {
  if (other != this) {
    std::swap(type_, other->type_);
    std::swap(name_, other->name_);
    std::swap(child_, other->child_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata NamePart::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = NamePart_descriptor_;
  metadata.reflection = NamePart_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int SerializedField::kMajorTypeFieldNumber;
const int SerializedField::kNamePartFieldNumber;
const int SerializedField::kChildFieldNumber;
const int SerializedField::kValueCountFieldNumber;
const int SerializedField::kVarByteLengthFieldNumber;
const int SerializedField::kBufferLengthFieldNumber;
#endif  // !_MSC_VER

SerializedField::SerializedField()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void SerializedField::InitAsDefaultInstance() {
  major_type_ = const_cast< ::common::MajorType*>(&::common::MajorType::default_instance());
  name_part_ = const_cast< ::exec::shared::NamePart*>(&::exec::shared::NamePart::default_instance());
}

SerializedField::SerializedField(const SerializedField& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void SerializedField::SharedCtor() {
  _cached_size_ = 0;
  major_type_ = NULL;
  name_part_ = NULL;
  value_count_ = 0;
  var_byte_length_ = 0;
  buffer_length_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

SerializedField::~SerializedField() {
  SharedDtor();
}

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

void SerializedField::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* SerializedField::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return SerializedField_descriptor_;
}

const SerializedField& SerializedField::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_UserBitShared_2eproto();
  return *default_instance_;
}

SerializedField* SerializedField::default_instance_ = NULL;

SerializedField* SerializedField::New() const {
  return new SerializedField;
}

void SerializedField::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_major_type()) {
      if (major_type_ != NULL) major_type_->::common::MajorType::Clear();
    }
    if (has_name_part()) {
      if (name_part_ != NULL) name_part_->::exec::shared::NamePart::Clear();
    }
    value_count_ = 0;
    var_byte_length_ = 0;
    buffer_length_ = 0;
  }
  child_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool SerializedField::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .common.MajorType major_type = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_major_type()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_name_part;
        break;
      }

      // optional .exec.shared.NamePart name_part = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_name_part:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_name_part()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(26)) goto parse_child;
        break;
      }

      // repeated .exec.shared.SerializedField child = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_child:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_child()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(26)) goto parse_child;
        if (input->ExpectTag(32)) goto parse_value_count;
        break;
      }

      // optional int32 value_count = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_value_count:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &value_count_)));
          set_has_value_count();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(40)) goto parse_var_byte_length;
        break;
      }

      // optional int32 var_byte_length = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_var_byte_length:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &var_byte_length_)));
          set_has_var_byte_length();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(56)) goto parse_buffer_length;
        break;
      }

      // optional int32 buffer_length = 7;
      case 7: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_buffer_length:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &buffer_length_)));
          set_has_buffer_length();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void SerializedField::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional .common.MajorType major_type = 1;
  if (has_major_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->major_type(), output);
  }

  // optional .exec.shared.NamePart name_part = 2;
  if (has_name_part()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->name_part(), output);
  }

  // repeated .exec.shared.SerializedField child = 3;
  for (int i = 0; i < this->child_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, this->child(i), output);
  }

  // optional int32 value_count = 4;
  if (has_value_count()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->value_count(), output);
  }

  // optional int32 var_byte_length = 5;
  if (has_var_byte_length()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->var_byte_length(), output);
  }

  // optional int32 buffer_length = 7;
  if (has_buffer_length()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(7, this->buffer_length(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* SerializedField::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional .common.MajorType major_type = 1;
  if (has_major_type()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->major_type(), target);
  }

  // optional .exec.shared.NamePart name_part = 2;
  if (has_name_part()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->name_part(), target);
  }

  // repeated .exec.shared.SerializedField child = 3;
  for (int i = 0; i < this->child_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        3, this->child(i), target);
  }

  // optional int32 value_count = 4;
  if (has_value_count()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->value_count(), target);
  }

  // optional int32 var_byte_length = 5;
  if (has_var_byte_length()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->var_byte_length(), target);
  }

  // optional int32 buffer_length = 7;
  if (has_buffer_length()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(7, this->buffer_length(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int SerializedField::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .common.MajorType major_type = 1;
    if (has_major_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->major_type());
    }

    // optional .exec.shared.NamePart name_part = 2;
    if (has_name_part()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->name_part());
    }

    // optional int32 value_count = 4;
    if (has_value_count()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->value_count());
    }

    // optional int32 var_byte_length = 5;
    if (has_var_byte_length()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->var_byte_length());
    }

    // optional int32 buffer_length = 7;
    if (has_buffer_length()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->buffer_length());
    }

  }
  // repeated .exec.shared.SerializedField child = 3;
  total_size += 1 * this->child_size();
  for (int i = 0; i < this->child_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->child(i));
  }

  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void SerializedField::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const SerializedField* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const SerializedField*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void SerializedField::MergeFrom(const SerializedField& from) {
  GOOGLE_CHECK_NE(&from, this);
  child_.MergeFrom(from.child_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_major_type()) {
      mutable_major_type()->::common::MajorType::MergeFrom(from.major_type());
    }
    if (from.has_name_part()) {
      mutable_name_part()->::exec::shared::NamePart::MergeFrom(from.name_part());
    }
    if (from.has_value_count()) {
      set_value_count(from.value_count());
    }
    if (from.has_var_byte_length()) {
      set_var_byte_length(from.var_byte_length());
    }
    if (from.has_buffer_length()) {
      set_buffer_length(from.buffer_length());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void SerializedField::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void SerializedField::CopyFrom(const SerializedField& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SerializedField::IsInitialized() const {

  return true;
}

void SerializedField::Swap(SerializedField* other) {
  if (other != this) {
    std::swap(major_type_, other->major_type_);
    std::swap(name_part_, other->name_part_);
    child_.Swap(&other->child_);
    std::swap(value_count_, other->value_count_);
    std::swap(var_byte_length_, other->var_byte_length_);
    std::swap(buffer_length_, other->buffer_length_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata SerializedField::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = SerializedField_descriptor_;
  metadata.reflection = SerializedField_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int NodeStatus::kNodeIdFieldNumber;
const int NodeStatus::kMemoryFootprintFieldNumber;
#endif  // !_MSC_VER

NodeStatus::NodeStatus()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void NodeStatus::InitAsDefaultInstance() {
}

NodeStatus::NodeStatus(const NodeStatus& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void NodeStatus::SharedCtor() {
  _cached_size_ = 0;
  node_id_ = 0;
  memory_footprint_ = GOOGLE_LONGLONG(0);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

NodeStatus::~NodeStatus() {
  SharedDtor();
}

void NodeStatus::SharedDtor() {
  if (this != default_instance_) {
  }
}

void NodeStatus::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* NodeStatus::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return NodeStatus_descriptor_;
}

const NodeStatus& NodeStatus::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_UserBitShared_2eproto();
  return *default_instance_;
}

NodeStatus* NodeStatus::default_instance_ = NULL;

NodeStatus* NodeStatus::New() const {
  return new NodeStatus;
}

void NodeStatus::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    node_id_ = 0;
    memory_footprint_ = GOOGLE_LONGLONG(0);
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool NodeStatus::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 node_id = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &node_id_)));
          set_has_node_id();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_memory_footprint;
        break;
      }

      // optional int64 memory_footprint = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_memory_footprint:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &memory_footprint_)));
          set_has_memory_footprint();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void NodeStatus::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional int32 node_id = 1;
  if (has_node_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->node_id(), output);
  }

  // optional int64 memory_footprint = 2;
  if (has_memory_footprint()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(2, this->memory_footprint(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* NodeStatus::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional int32 node_id = 1;
  if (has_node_id()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->node_id(), target);
  }

  // optional int64 memory_footprint = 2;
  if (has_memory_footprint()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(2, this->memory_footprint(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int NodeStatus::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional int32 node_id = 1;
    if (has_node_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->node_id());
    }

    // optional int64 memory_footprint = 2;
    if (has_memory_footprint()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->memory_footprint());
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void NodeStatus::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const NodeStatus* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const NodeStatus*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void NodeStatus::MergeFrom(const NodeStatus& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_node_id()) {
      set_node_id(from.node_id());
    }
    if (from.has_memory_footprint()) {
      set_memory_footprint(from.memory_footprint());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void NodeStatus::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void NodeStatus::CopyFrom(const NodeStatus& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool NodeStatus::IsInitialized() const {

  return true;
}

void NodeStatus::Swap(NodeStatus* other) {
  if (other != this) {
    std::swap(node_id_, other->node_id_);
    std::swap(memory_footprint_, other->memory_footprint_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata NodeStatus::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = NodeStatus_descriptor_;
  metadata.reflection = NodeStatus_reflection_;
  return metadata;
}


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

const ::google::protobuf::EnumDescriptor* QueryResult_QueryState_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return QueryResult_QueryState_descriptor_;
}
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;
  }
}

#ifndef _MSC_VER
const QueryResult_QueryState QueryResult::STARTING;
const QueryResult_QueryState QueryResult::RUNNING;
const QueryResult_QueryState QueryResult::COMPLETED;
const QueryResult_QueryState QueryResult::CANCELED;
const QueryResult_QueryState QueryResult::FAILED;
const QueryResult_QueryState QueryResult::CANCELLATION_REQUESTED;
const QueryResult_QueryState QueryResult::ENQUEUED;
const QueryResult_QueryState QueryResult::PREPARING;
const QueryResult_QueryState QueryResult::PLANNING;
const QueryResult_QueryState QueryResult::QueryState_MIN;
const QueryResult_QueryState QueryResult::QueryState_MAX;
const int QueryResult::QueryState_ARRAYSIZE;
#endif  // _MSC_VER
#ifndef _MSC_VER
const int QueryResult::kQueryStateFieldNumber;
const int QueryResult::kQueryIdFieldNumber;
const int QueryResult::kErrorFieldNumber;
#endif  // !_MSC_VER

QueryResult::QueryResult()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void QueryResult::InitAsDefaultInstance() {
  query_id_ = const_cast< ::exec::shared::QueryId*>(&::exec::shared::QueryId::default_instance());
}

QueryResult::QueryResult(const QueryResult& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void QueryResult::SharedCtor() {
  _cached_size_ = 0;
  query_state_ = 0;
  query_id_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

QueryResult::~QueryResult() {
  SharedDtor();
}

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

void QueryResult::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* QueryResult::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return QueryResult_descriptor_;
}

const QueryResult& QueryResult::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_UserBitShared_2eproto();
  return *default_instance_;
}

QueryResult* QueryResult::default_instance_ = NULL;

QueryResult* QueryResult::New() const {
  return new QueryResult;
}

void QueryResult::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    query_state_ = 0;
    if (has_query_id()) {
      if (query_id_ != NULL) query_id_->::exec::shared::QueryId::Clear();
    }
  }
  error_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool QueryResult::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .exec.shared.QueryResult.QueryState query_state = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::exec::shared::QueryResult_QueryState_IsValid(value)) {
            set_query_state(static_cast< ::exec::shared::QueryResult_QueryState >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_query_id;
        break;
      }

      // optional .exec.shared.QueryId query_id = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_query_id:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_query_id()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(26)) goto parse_error;
        break;
      }

      // repeated .exec.shared.DrillPBError error = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_error:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_error()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(26)) goto parse_error;
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void QueryResult::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional .exec.shared.QueryResult.QueryState query_state = 1;
  if (has_query_state()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->query_state(), output);
  }

  // optional .exec.shared.QueryId query_id = 2;
  if (has_query_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->query_id(), output);
  }

  // repeated .exec.shared.DrillPBError error = 3;
  for (int i = 0; i < this->error_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, this->error(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* QueryResult::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional .exec.shared.QueryResult.QueryState query_state = 1;
  if (has_query_state()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->query_state(), target);
  }

  // optional .exec.shared.QueryId query_id = 2;
  if (has_query_id()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->query_id(), target);
  }

  // repeated .exec.shared.DrillPBError error = 3;
  for (int i = 0; i < this->error_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        3, this->error(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int QueryResult::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .exec.shared.QueryResult.QueryState query_state = 1;
    if (has_query_state()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->query_state());
    }

    // optional .exec.shared.QueryId query_id = 2;
    if (has_query_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->query_id());
    }

  }
  // repeated .exec.shared.DrillPBError error = 3;
  total_size += 1 * this->error_size();
  for (int i = 0; i < this->error_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->error(i));
  }

  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void QueryResult::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const QueryResult* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const QueryResult*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void QueryResult::MergeFrom(const QueryResult& from) {
  GOOGLE_CHECK_NE(&from, this);
  error_.MergeFrom(from.error_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_query_state()) {
      set_query_state(from.query_state());
    }
    if (from.has_query_id()) {
      mutable_query_id()->::exec::shared::QueryId::MergeFrom(from.query_id());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void QueryResult::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void QueryResult::CopyFrom(const QueryResult& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool QueryResult::IsInitialized() const {

  return true;
}

void QueryResult::Swap(QueryResult* other) {
  if (other != this) {
    std::swap(query_state_, other->query_state_);
    std::swap(query_id_, other->query_id_);
    error_.Swap(&other->error_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata QueryResult::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = QueryResult_descriptor_;
  metadata.reflection = QueryResult_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int QueryData::kQueryIdFieldNumber;
const int QueryData::kRowCountFieldNumber;
const int QueryData::kDefFieldNumber;
const int QueryData::kAffectedRowsCountFieldNumber;
#endif  // !_MSC_VER

QueryData::QueryData()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void QueryData::InitAsDefaultInstance() {
  query_id_ = const_cast< ::exec::shared::QueryId*>(&::exec::shared::QueryId::default_instance());
  def_ = const_cast< ::exec::shared::RecordBatchDef*>(&::exec::shared::RecordBatchDef::default_instance());
}

QueryData::QueryData(const QueryData& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void QueryData::SharedCtor() {
  _cached_size_ = 0;
  query_id_ = NULL;
  row_count_ = 0;
  def_ = NULL;
  affected_rows_count_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

QueryData::~QueryData() {
  SharedDtor();
}

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

void QueryData::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* QueryData::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return QueryData_descriptor_;
}

const QueryData& QueryData::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_UserBitShared_2eproto();
  return *default_instance_;
}

QueryData* QueryData::default_instance_ = NULL;

QueryData* QueryData::New() const {
  return new QueryData;
}

void QueryData::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_query_id()) {
      if (query_id_ != NULL) query_id_->::exec::shared::QueryId::Clear();
    }
    row_count_ = 0;
    if (has_def()) {
      if (def_ != NULL) def_->::exec::shared::RecordBatchDef::Clear();
    }
    affected_rows_count_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool QueryData::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .exec.shared.QueryId query_id = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_query_id()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_row_count;
        break;
      }

      // optional int32 row_count = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_row_count:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &row_count_)));
          set_has_row_count();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(26)) goto parse_def;
        break;
      }

      // optional .exec.shared.RecordBatchDef def = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_def:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_def()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_affected_rows_count;
        break;
      }

      // optional int32 affected_rows_count = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_affected_rows_count:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &affected_rows_count_)));
          set_has_affected_rows_count();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void QueryData::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional .exec.shared.QueryId query_id = 1;
  if (has_query_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->query_id(), output);
  }

  // optional int32 row_count = 2;
  if (has_row_count()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->row_count(), output);
  }

  // optional .exec.shared.RecordBatchDef def = 3;
  if (has_def()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, this->def(), output);
  }

  // optional int32 affected_rows_count = 4;
  if (has_affected_rows_count()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->affected_rows_count(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* QueryData::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional .exec.shared.QueryId query_id = 1;
  if (has_query_id()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->query_id(), target);
  }

  // optional int32 row_count = 2;
  if (has_row_count()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->row_count(), target);
  }

  // optional .exec.shared.RecordBatchDef def = 3;
  if (has_def()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        3, this->def(), target);
  }

  // optional int32 affected_rows_count = 4;
  if (has_affected_rows_count()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->affected_rows_count(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int QueryData::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .exec.shared.QueryId query_id = 1;
    if (has_query_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->query_id());
    }

    // optional int32 row_count = 2;
    if (has_row_count()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->row_count());
    }

    // optional .exec.shared.RecordBatchDef def = 3;
    if (has_def()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->def());
    }

    // optional int32 affected_rows_count = 4;
    if (has_affected_rows_count()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->affected_rows_count());
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void QueryData::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const QueryData* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const QueryData*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void QueryData::MergeFrom(const QueryData& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_query_id()) {
      mutable_query_id()->::exec::shared::QueryId::MergeFrom(from.query_id());
    }
    if (from.has_row_count()) {
      set_row_count(from.row_count());
    }
    if (from.has_def()) {
      mutable_def()->::exec::shared::RecordBatchDef::MergeFrom(from.def());
    }
    if (from.has_affected_rows_count()) {
      set_affected_rows_count(from.affected_rows_count());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void QueryData::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void QueryData::CopyFrom(const QueryData& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool QueryData::IsInitialized() const {

  return true;
}

void QueryData::Swap(QueryData* other) {
  if (other != this) {
    std::swap(query_id_, other->query_id_);
    std::swap(row_count_, other->row_count_);
    std::swap(def_, other->def_);
    std::swap(affected_rows_count_, other->affected_rows_count_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata QueryData::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = QueryData_descriptor_;
  metadata.reflection = QueryData_reflection_;
  return metadata;
}


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

::std::string* QueryInfo::_default_user_ = NULL;
::std::string* QueryInfo::_default_queue_name_ = NULL;
#ifndef _MSC_VER
const int QueryInfo::kQueryFieldNumber;
const int QueryInfo::kStartFieldNumber;
const int QueryInfo::kStateFieldNumber;
const int QueryInfo::kUserFieldNumber;
const int QueryInfo::kForemanFieldNumber;
const int QueryInfo::kOptionsJsonFieldNumber;
const int QueryInfo::kTotalCostFieldNumber;
const int QueryInfo::kQueueNameFieldNumber;
#endif  // !_MSC_VER

QueryInfo::QueryInfo()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void QueryInfo::InitAsDefaultInstance() {
  foreman_ = const_cast< ::exec::DrillbitEndpoint*>(&::exec::DrillbitEndpoint::default_instance());
}

QueryInfo::QueryInfo(const QueryInfo& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void QueryInfo::SharedCtor() {
  _cached_size_ = 0;
  query_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  start_ = GOOGLE_LONGLONG(0);
  state_ = 0;
  user_ = const_cast< ::std::string*>(_default_user_);
  foreman_ = NULL;
  options_json_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  total_cost_ = 0;
  queue_name_ = const_cast< ::std::string*>(_default_queue_name_);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

QueryInfo::~QueryInfo() {
  SharedDtor();
}

void QueryInfo::SharedDtor() {
  if (query_ != &::google::protobuf::internal::kEmptyString) {
    delete query_;
  }
  if (user_ != _default_user_) {
    delete user_;
  }
  if (options_json_ != &::google::protobuf::internal::kEmptyString) {
    delete options_json_;
  }
  if (queue_name_ != _default_queue_name_) {
    delete queue_name_;
  }
  if (this != default_instance_) {
    delete foreman_;
  }
}

void QueryInfo::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* QueryInfo::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return QueryInfo_descriptor_;
}

const QueryInfo& QueryInfo::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_UserBitShared_2eproto();
  return *default_instance_;
}

QueryInfo* QueryInfo::default_instance_ = NULL;

QueryInfo* QueryInfo::New() const {
  return new QueryInfo;
}

void QueryInfo::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_query()) {
      if (query_ != &::google::protobuf::internal::kEmptyString) {
        query_->clear();
      }
    }
    start_ = GOOGLE_LONGLONG(0);
    state_ = 0;
    if (has_user()) {
      if (user_ != _default_user_) {
        user_->assign(*_default_user_);
      }
    }
    if (has_foreman()) {
      if (foreman_ != NULL) foreman_->::exec::DrillbitEndpoint::Clear();
    }
    if (has_options_json()) {
      if (options_json_ != &::google::protobuf::internal::kEmptyString) {
        options_json_->clear();
      }
    }
    total_cost_ = 0;
    if (has_queue_name()) {
      if (queue_name_ != _default_queue_name_) {
        queue_name_->assign(*_default_queue_name_);
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool QueryInfo::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string query = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_query()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->query().data(), this->query().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_start;
        break;
      }

      // optional int64 start = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_start:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &start_)));
          set_has_start();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_state;
        break;
      }

      // optional .exec.shared.QueryResult.QueryState state = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_state:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::exec::shared::QueryResult_QueryState_IsValid(value)) {
            set_state(static_cast< ::exec::shared::QueryResult_QueryState >(value));
          } else {
            mutable_unknown_fields()->AddVarint(3, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(34)) goto parse_user;
        break;
      }

      // optional string user = 4 [default = "-"];
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_user:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_user()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->user().data(), this->user().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(42)) goto parse_foreman;
        break;
      }

      // optional .exec.DrillbitEndpoint foreman = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_foreman:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_foreman()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(50)) goto parse_options_json;
        break;
      }

      // optional string options_json = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_options_json:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_options_json()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->options_json().data(), this->options_json().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(57)) goto parse_total_cost;
        break;
      }

      // optional double total_cost = 7;
      case 7: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_total_cost:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &total_cost_)));
          set_has_total_cost();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(66)) goto parse_queue_name;
        break;
      }

      // optional string queue_name = 8 [default = "-"];
      case 8: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_queue_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_queue_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->queue_name().data(), this->queue_name().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void QueryInfo::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional string query = 1;
  if (has_query()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->query().data(), this->query().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->query(), output);
  }

  // optional int64 start = 2;
  if (has_start()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(2, this->start(), output);
  }

  // optional .exec.shared.QueryResult.QueryState state = 3;
  if (has_state()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      3, this->state(), output);
  }

  // optional string user = 4 [default = "-"];
  if (has_user()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->user().data(), this->user().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      4, this->user(), output);
  }

  // optional .exec.DrillbitEndpoint foreman = 5;
  if (has_foreman()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      5, this->foreman(), output);
  }

  // optional string options_json = 6;
  if (has_options_json()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->options_json().data(), this->options_json().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      6, this->options_json(), output);
  }

  // optional double total_cost = 7;
  if (has_total_cost()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(7, this->total_cost(), output);
  }

  // optional string queue_name = 8 [default = "-"];
  if (has_queue_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->queue_name().data(), this->queue_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      8, this->queue_name(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* QueryInfo::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional string query = 1;
  if (has_query()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->query().data(), this->query().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->query(), target);
  }

  // optional int64 start = 2;
  if (has_start()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(2, this->start(), target);
  }

  // optional .exec.shared.QueryResult.QueryState state = 3;
  if (has_state()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      3, this->state(), target);
  }

  // optional string user = 4 [default = "-"];
  if (has_user()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->user().data(), this->user().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        4, this->user(), target);
  }

  // optional .exec.DrillbitEndpoint foreman = 5;
  if (has_foreman()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        5, this->foreman(), target);
  }

  // optional string options_json = 6;
  if (has_options_json()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->options_json().data(), this->options_json().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        6, this->options_json(), target);
  }

  // optional double total_cost = 7;
  if (has_total_cost()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(7, this->total_cost(), target);
  }

  // optional string queue_name = 8 [default = "-"];
  if (has_queue_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->queue_name().data(), this->queue_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        8, this->queue_name(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int QueryInfo::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional string query = 1;
    if (has_query()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->query());
    }

    // optional int64 start = 2;
    if (has_start()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->start());
    }

    // optional .exec.shared.QueryResult.QueryState state = 3;
    if (has_state()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->state());
    }

    // optional string user = 4 [default = "-"];
    if (has_user()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->user());
    }

    // optional .exec.DrillbitEndpoint foreman = 5;
    if (has_foreman()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->foreman());
    }

    // optional string options_json = 6;
    if (has_options_json()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->options_json());
    }

    // optional double total_cost = 7;
    if (has_total_cost()) {
      total_size += 1 + 8;
    }

    // optional string queue_name = 8 [default = "-"];
    if (has_queue_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->queue_name());
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void QueryInfo::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const QueryInfo* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const QueryInfo*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void QueryInfo::MergeFrom(const QueryInfo& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_query()) {
      set_query(from.query());
    }
    if (from.has_start()) {
      set_start(from.start());
    }
    if (from.has_state()) {
      set_state(from.state());
    }
    if (from.has_user()) {
      set_user(from.user());
    }
    if (from.has_foreman()) {
      mutable_foreman()->::exec::DrillbitEndpoint::MergeFrom(from.foreman());
    }
    if (from.has_options_json()) {
      set_options_json(from.options_json());
    }
    if (from.has_total_cost()) {
      set_total_cost(from.total_cost());
    }
    if (from.has_queue_name()) {
      set_queue_name(from.queue_name());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void QueryInfo::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void QueryInfo::CopyFrom(const QueryInfo& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool QueryInfo::IsInitialized() const {

  return true;
}

void QueryInfo::Swap(QueryInfo* other) {
  if (other != this) {
    std::swap(query_, other->query_);
    std::swap(start_, other->start_);
    std::swap(state_, other->state_);
    std::swap(user_, other->user_);
    std::swap(foreman_, other->foreman_);
    std::swap(options_json_, other->options_json_);
    std::swap(total_cost_, other->total_cost_);
    std::swap(queue_name_, other->queue_name_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata QueryInfo::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = QueryInfo_descriptor_;
  metadata.reflection = QueryInfo_reflection_;
  return metadata;
}


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

::std::string* QueryProfile::_default_user_ = NULL;
::std::string* QueryProfile::_default_queue_name_ = NULL;
#ifndef _MSC_VER
const int QueryProfile::kIdFieldNumber;
const int QueryProfile::kTypeFieldNumber;
const int QueryProfile::kStartFieldNumber;
const int QueryProfile::kEndFieldNumber;
const int QueryProfile::kQueryFieldNumber;
const int QueryProfile::kPlanFieldNumber;
const int QueryProfile::kForemanFieldNumber;
const int QueryProfile::kStateFieldNumber;
const int QueryProfile::kTotalFragmentsFieldNumber;
const int QueryProfile::kFinishedFragmentsFieldNumber;
const int QueryProfile::kFragmentProfileFieldNumber;
const int QueryProfile::kUserFieldNumber;
const int QueryProfile::kErrorFieldNumber;
const int QueryProfile::kVerboseErrorFieldNumber;
const int QueryProfile::kErrorIdFieldNumber;
const int QueryProfile::kErrorNodeFieldNumber;
const int QueryProfile::kOptionsJsonFieldNumber;
const int QueryProfile::kPlanEndFieldNumber;
const int QueryProfile::kQueueWaitEndFieldNumber;
const int QueryProfile::kTotalCostFieldNumber;
const int QueryProfile::kQueueNameFieldNumber;
const int QueryProfile::kQueryIdFieldNumber;
#endif  // !_MSC_VER

QueryProfile::QueryProfile()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void QueryProfile::InitAsDefaultInstance() {
  id_ = const_cast< ::exec::shared::QueryId*>(&::exec::shared::QueryId::default_instance());
  foreman_ = const_cast< ::exec::DrillbitEndpoint*>(&::exec::DrillbitEndpoint::default_instance());
}

QueryProfile::QueryProfile(const QueryProfile& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void QueryProfile::SharedCtor() {
  _cached_size_ = 0;
  id_ = NULL;
  type_ = 1;
  start_ = GOOGLE_LONGLONG(0);
  end_ = GOOGLE_LONGLONG(0);
  query_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  plan_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  foreman_ = NULL;
  state_ = 0;
  total_fragments_ = 0;
  finished_fragments_ = 0;
  user_ = const_cast< ::std::string*>(_default_user_);
  error_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  verboseerror_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  error_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  error_node_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  options_json_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  planend_ = GOOGLE_LONGLONG(0);
  queuewaitend_ = GOOGLE_LONGLONG(0);
  total_cost_ = 0;
  queue_name_ = const_cast< ::std::string*>(_default_queue_name_);
  queryid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

QueryProfile::~QueryProfile() {
  SharedDtor();
}

void QueryProfile::SharedDtor() {
  if (query_ != &::google::protobuf::internal::kEmptyString) {
    delete query_;
  }
  if (plan_ != &::google::protobuf::internal::kEmptyString) {
    delete plan_;
  }
  if (user_ != _default_user_) {
    delete user_;
  }
  if (error_ != &::google::protobuf::internal::kEmptyString) {
    delete error_;
  }
  if (verboseerror_ != &::google::protobuf::internal::kEmptyString) {
    delete verboseerror_;
  }
  if (error_id_ != &::google::protobuf::internal::kEmptyString) {
    delete error_id_;
  }
  if (error_node_ != &::google::protobuf::internal::kEmptyString) {
    delete error_node_;
  }
  if (options_json_ != &::google::protobuf::internal::kEmptyString) {
    delete options_json_;
  }
  if (queue_name_ != _default_queue_name_) {
    delete queue_name_;
  }
  if (queryid_ != &::google::protobuf::internal::kEmptyString) {
    delete queryid_;
  }
  if (this != default_instance_) {
    delete id_;
    delete foreman_;
  }
}

void QueryProfile::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* QueryProfile::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return QueryProfile_descriptor_;
}

const QueryProfile& QueryProfile::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_UserBitShared_2eproto();
  return *default_instance_;
}

QueryProfile* QueryProfile::default_instance_ = NULL;

QueryProfile* QueryProfile::New() const {
  return new QueryProfile;
}

void QueryProfile::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_id()) {
      if (id_ != NULL) id_->::exec::shared::QueryId::Clear();
    }
    type_ = 1;
    start_ = GOOGLE_LONGLONG(0);
    end_ = GOOGLE_LONGLONG(0);
    if (has_query()) {
      if (query_ != &::google::protobuf::internal::kEmptyString) {
        query_->clear();
      }
    }
    if (has_plan()) {
      if (plan_ != &::google::protobuf::internal::kEmptyString) {
        plan_->clear();
      }
    }
    if (has_foreman()) {
      if (foreman_ != NULL) foreman_->::exec::DrillbitEndpoint::Clear();
    }
    state_ = 0;
  }
  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    total_fragments_ = 0;
    finished_fragments_ = 0;
    if (has_user()) {
      if (user_ != _default_user_) {
        user_->assign(*_default_user_);
      }
    }
    if (has_error()) {
      if (error_ != &::google::protobuf::internal::kEmptyString) {
        error_->clear();
      }
    }
    if (has_verboseerror()) {
      if (verboseerror_ != &::google::protobuf::internal::kEmptyString) {
        verboseerror_->clear();
      }
    }
    if (has_error_id()) {
      if (error_id_ != &::google::protobuf::internal::kEmptyString) {
        error_id_->clear();
      }
    }
    if (has_error_node()) {
      if (error_node_ != &::google::protobuf::internal::kEmptyString) {
        error_node_->clear();
      }
    }
  }
  if (_has_bits_[16 / 32] & (0xffu << (16 % 32))) {
    if (has_options_json()) {
      if (options_json_ != &::google::protobuf::internal::kEmptyString) {
        options_json_->clear();
      }
    }
    planend_ = GOOGLE_LONGLONG(0);
    queuewaitend_ = GOOGLE_LONGLONG(0);
    total_cost_ = 0;
    if (has_queue_name()) {
      if (queue_name_ != _default_queue_name_) {
        queue_name_->assign(*_default_queue_name_);
      }
    }
    if (has_queryid()) {
      if (queryid_ != &::google::protobuf::internal::kEmptyString) {
        queryid_->clear();
      }
    }
  }
  fragment_profile_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool QueryProfile::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .exec.shared.QueryId id = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_id()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_type;
        break;
      }

      // optional .exec.shared.QueryType type = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_type:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::exec::shared::QueryType_IsValid(value)) {
            set_type(static_cast< ::exec::shared::QueryType >(value));
          } else {
            mutable_unknown_fields()->AddVarint(2, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_start;
        break;
      }

      // optional int64 start = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_start:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &start_)));
          set_has_start();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_end;
        break;
      }

      // optional int64 end = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_end:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &end_)));
          set_has_end();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(42)) goto parse_query;
        break;
      }

      // optional string query = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_query:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_query()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->query().data(), this->query().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(50)) goto parse_plan;
        break;
      }

      // optional string plan = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_plan:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_plan()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->plan().data(), this->plan().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(58)) goto parse_foreman;
        break;
      }

      // optional .exec.DrillbitEndpoint foreman = 7;
      case 7: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_foreman:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_foreman()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(64)) goto parse_state;
        break;
      }

      // optional .exec.shared.QueryResult.QueryState state = 8;
      case 8: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_state:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::exec::shared::QueryResult_QueryState_IsValid(value)) {
            set_state(static_cast< ::exec::shared::QueryResult_QueryState >(value));
          } else {
            mutable_unknown_fields()->AddVarint(8, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(72)) goto parse_total_fragments;
        break;
      }

      // optional int32 total_fragments = 9;
      case 9: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_total_fragments:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &total_fragments_)));
          set_has_total_fragments();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(80)) goto parse_finished_fragments;
        break;
      }

      // optional int32 finished_fragments = 10;
      case 10: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_finished_fragments:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &finished_fragments_)));
          set_has_finished_fragments();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(90)) goto parse_fragment_profile;
        break;
      }

      // repeated .exec.shared.MajorFragmentProfile fragment_profile = 11;
      case 11: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_fragment_profile:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_fragment_profile()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(90)) goto parse_fragment_profile;
        if (input->ExpectTag(98)) goto parse_user;
        break;
      }

      // optional string user = 12 [default = "-"];
      case 12: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_user:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_user()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->user().data(), this->user().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(106)) goto parse_error;
        break;
      }

      // optional string error = 13;
      case 13: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_error:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_error()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->error().data(), this->error().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(114)) goto parse_verboseError;
        break;
      }

      // optional string verboseError = 14;
      case 14: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_verboseError:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_verboseerror()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->verboseerror().data(), this->verboseerror().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(122)) goto parse_error_id;
        break;
      }

      // optional string error_id = 15;
      case 15: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_error_id:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_error_id()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->error_id().data(), this->error_id().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(130)) goto parse_error_node;
        break;
      }

      // optional string error_node = 16;
      case 16: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_error_node:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_error_node()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->error_node().data(), this->error_node().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(138)) goto parse_options_json;
        break;
      }

      // optional string options_json = 17;
      case 17: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_options_json:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_options_json()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->options_json().data(), this->options_json().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(144)) goto parse_planEnd;
        break;
      }

      // optional int64 planEnd = 18;
      case 18: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_planEnd:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &planend_)));
          set_has_planend();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(152)) goto parse_queueWaitEnd;
        break;
      }

      // optional int64 queueWaitEnd = 19;
      case 19: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_queueWaitEnd:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &queuewaitend_)));
          set_has_queuewaitend();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(161)) goto parse_total_cost;
        break;
      }

      // optional double total_cost = 20;
      case 20: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_total_cost:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &total_cost_)));
          set_has_total_cost();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(170)) goto parse_queue_name;
        break;
      }

      // optional string queue_name = 21 [default = "-"];
      case 21: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_queue_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_queue_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->queue_name().data(), this->queue_name().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(178)) goto parse_queryId;
        break;
      }

      // optional string queryId = 22;
      case 22: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_queryId:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_queryid()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->queryid().data(), this->queryid().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void QueryProfile::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional .exec.shared.QueryId id = 1;
  if (has_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->id(), output);
  }

  // optional .exec.shared.QueryType type = 2;
  if (has_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->type(), output);
  }

  // optional int64 start = 3;
  if (has_start()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(3, this->start(), output);
  }

  // optional int64 end = 4;
  if (has_end()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(4, this->end(), output);
  }

  // optional string query = 5;
  if (has_query()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->query().data(), this->query().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      5, this->query(), output);
  }

  // optional string plan = 6;
  if (has_plan()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->plan().data(), this->plan().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      6, this->plan(), output);
  }

  // optional .exec.DrillbitEndpoint foreman = 7;
  if (has_foreman()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      7, this->foreman(), output);
  }

  // optional .exec.shared.QueryResult.QueryState state = 8;
  if (has_state()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      8, this->state(), output);
  }

  // optional int32 total_fragments = 9;
  if (has_total_fragments()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(9, this->total_fragments(), output);
  }

  // optional int32 finished_fragments = 10;
  if (has_finished_fragments()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(10, this->finished_fragments(), output);
  }

  // repeated .exec.shared.MajorFragmentProfile fragment_profile = 11;
  for (int i = 0; i < this->fragment_profile_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      11, this->fragment_profile(i), output);
  }

  // optional string user = 12 [default = "-"];
  if (has_user()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->user().data(), this->user().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      12, this->user(), output);
  }

  // optional string error = 13;
  if (has_error()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->error().data(), this->error().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      13, this->error(), output);
  }

  // optional string verboseError = 14;
  if (has_verboseerror()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->verboseerror().data(), this->verboseerror().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      14, this->verboseerror(), output);
  }

  // optional string error_id = 15;
  if (has_error_id()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->error_id().data(), this->error_id().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      15, this->error_id(), output);
  }

  // optional string error_node = 16;
  if (has_error_node()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->error_node().data(), this->error_node().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      16, this->error_node(), output);
  }

  // optional string options_json = 17;
  if (has_options_json()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->options_json().data(), this->options_json().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      17, this->options_json(), output);
  }

  // optional int64 planEnd = 18;
  if (has_planend()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(18, this->planend(), output);
  }

  // optional int64 queueWaitEnd = 19;
  if (has_queuewaitend()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(19, this->queuewaitend(), output);
  }

  // optional double total_cost = 20;
  if (has_total_cost()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(20, this->total_cost(), output);
  }

  // optional string queue_name = 21 [default = "-"];
  if (has_queue_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->queue_name().data(), this->queue_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      21, this->queue_name(), output);
  }

  // optional string queryId = 22;
  if (has_queryid()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->queryid().data(), this->queryid().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      22, this->queryid(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* QueryProfile::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional .exec.shared.QueryId id = 1;
  if (has_id()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->id(), target);
  }

  // optional .exec.shared.QueryType type = 2;
  if (has_type()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      2, this->type(), target);
  }

  // optional int64 start = 3;
  if (has_start()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(3, this->start(), target);
  }

  // optional int64 end = 4;
  if (has_end()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(4, this->end(), target);
  }

  // optional string query = 5;
  if (has_query()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->query().data(), this->query().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        5, this->query(), target);
  }

  // optional string plan = 6;
  if (has_plan()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->plan().data(), this->plan().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        6, this->plan(), target);
  }

  // optional .exec.DrillbitEndpoint foreman = 7;
  if (has_foreman()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        7, this->foreman(), target);
  }

  // optional .exec.shared.QueryResult.QueryState state = 8;
  if (has_state()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      8, this->state(), target);
  }

  // optional int32 total_fragments = 9;
  if (has_total_fragments()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(9, this->total_fragments(), target);
  }

  // optional int32 finished_fragments = 10;
  if (has_finished_fragments()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(10, this->finished_fragments(), target);
  }

  // repeated .exec.shared.MajorFragmentProfile fragment_profile = 11;
  for (int i = 0; i < this->fragment_profile_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        11, this->fragment_profile(i), target);
  }

  // optional string user = 12 [default = "-"];
  if (has_user()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->user().data(), this->user().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        12, this->user(), target);
  }

  // optional string error = 13;
  if (has_error()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->error().data(), this->error().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        13, this->error(), target);
  }

  // optional string verboseError = 14;
  if (has_verboseerror()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->verboseerror().data(), this->verboseerror().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        14, this->verboseerror(), target);
  }

  // optional string error_id = 15;
  if (has_error_id()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->error_id().data(), this->error_id().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        15, this->error_id(), target);
  }

  // optional string error_node = 16;
  if (has_error_node()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->error_node().data(), this->error_node().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        16, this->error_node(), target);
  }

  // optional string options_json = 17;
  if (has_options_json()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->options_json().data(), this->options_json().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        17, this->options_json(), target);
  }

  // optional int64 planEnd = 18;
  if (has_planend()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(18, this->planend(), target);
  }

  // optional int64 queueWaitEnd = 19;
  if (has_queuewaitend()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(19, this->queuewaitend(), target);
  }

  // optional double total_cost = 20;
  if (has_total_cost()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(20, this->total_cost(), target);
  }

  // optional string queue_name = 21 [default = "-"];
  if (has_queue_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->queue_name().data(), this->queue_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        21, this->queue_name(), target);
  }

  // optional string queryId = 22;
  if (has_queryid()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->queryid().data(), this->queryid().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        22, this->queryid(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int QueryProfile::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .exec.shared.QueryId id = 1;
    if (has_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->id());
    }

    // optional .exec.shared.QueryType type = 2;
    if (has_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
    }

    // optional int64 start = 3;
    if (has_start()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->start());
    }

    // optional int64 end = 4;
    if (has_end()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->end());
    }

    // optional string query = 5;
    if (has_query()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->query());
    }

    // optional string plan = 6;
    if (has_plan()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->plan());
    }

    // optional .exec.DrillbitEndpoint foreman = 7;
    if (has_foreman()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->foreman());
    }

    // optional .exec.shared.QueryResult.QueryState state = 8;
    if (has_state()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->state());
    }

  }
  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    // optional int32 total_fragments = 9;
    if (has_total_fragments()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->total_fragments());
    }

    // optional int32 finished_fragments = 10;
    if (has_finished_fragments()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->finished_fragments());
    }

    // optional string user = 12 [default = "-"];
    if (has_user()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->user());
    }

    // optional string error = 13;
    if (has_error()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->error());
    }

    // optional string verboseError = 14;
    if (has_verboseerror()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->verboseerror());
    }

    // optional string error_id = 15;
    if (has_error_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->error_id());
    }

    // optional string error_node = 16;
    if (has_error_node()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->error_node());
    }

  }
  if (_has_bits_[16 / 32] & (0xffu << (16 % 32))) {
    // optional string options_json = 17;
    if (has_options_json()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->options_json());
    }

    // optional int64 planEnd = 18;
    if (has_planend()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->planend());
    }

    // optional int64 queueWaitEnd = 19;
    if (has_queuewaitend()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->queuewaitend());
    }

    // optional double total_cost = 20;
    if (has_total_cost()) {
      total_size += 2 + 8;
    }

    // optional string queue_name = 21 [default = "-"];
    if (has_queue_name()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->queue_name());
    }

    // optional string queryId = 22;
    if (has_queryid()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->queryid());
    }

  }
  // repeated .exec.shared.MajorFragmentProfile fragment_profile = 11;
  total_size += 1 * this->fragment_profile_size();
  for (int i = 0; i < this->fragment_profile_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->fragment_profile(i));
  }

  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void QueryProfile::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const QueryProfile* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const QueryProfile*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void QueryProfile::MergeFrom(const QueryProfile& from) {
  GOOGLE_CHECK_NE(&from, this);
  fragment_profile_.MergeFrom(from.fragment_profile_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_id()) {
      mutable_id()->::exec::shared::QueryId::MergeFrom(from.id());
    }
    if (from.has_type()) {
      set_type(from.type());
    }
    if (from.has_start()) {
      set_start(from.start());
    }
    if (from.has_end()) {
      set_end(from.end());
    }
    if (from.has_query()) {
      set_query(from.query());
    }
    if (from.has_plan()) {
      set_plan(from.plan());
    }
    if (from.has_foreman()) {
      mutable_foreman()->::exec::DrillbitEndpoint::MergeFrom(from.foreman());
    }
    if (from.has_state()) {
      set_state(from.state());
    }
  }
  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    if (from.has_total_fragments()) {
      set_total_fragments(from.total_fragments());
    }
    if (from.has_finished_fragments()) {
      set_finished_fragments(from.finished_fragments());
    }
    if (from.has_user()) {
      set_user(from.user());
    }
    if (from.has_error()) {
      set_error(from.error());
    }
    if (from.has_verboseerror()) {
      set_verboseerror(from.verboseerror());
    }
    if (from.has_error_id()) {
      set_error_id(from.error_id());
    }
    if (from.has_error_node()) {
      set_error_node(from.error_node());
    }
  }
  if (from._has_bits_[16 / 32] & (0xffu << (16 % 32))) {
    if (from.has_options_json()) {
      set_options_json(from.options_json());
    }
    if (from.has_planend()) {
      set_planend(from.planend());
    }
    if (from.has_queuewaitend()) {
      set_queuewaitend(from.queuewaitend());
    }
    if (from.has_total_cost()) {
      set_total_cost(from.total_cost());
    }
    if (from.has_queue_name()) {
      set_queue_name(from.queue_name());
    }
    if (from.has_queryid()) {
      set_queryid(from.queryid());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void QueryProfile::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void QueryProfile::CopyFrom(const QueryProfile& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool QueryProfile::IsInitialized() const {

  return true;
}

void QueryProfile::Swap(QueryProfile* other) {
  if (other != this) {
    std::swap(id_, other->id_);
    std::swap(type_, other->type_);
    std::swap(start_, other->start_);
    std::swap(end_, other->end_);
    std::swap(query_, other->query_);
    std::swap(plan_, other->plan_);
    std::swap(foreman_, other->foreman_);
    std::swap(state_, other->state_);
    std::swap(total_fragments_, other->total_fragments_);
    std::swap(finished_fragments_, other->finished_fragments_);
    fragment_profile_.Swap(&other->fragment_profile_);
    std::swap(user_, other->user_);
    std::swap(error_, other->error_);
    std::swap(verboseerror_, other->verboseerror_);
    std::swap(error_id_, other->error_id_);
    std::swap(error_node_, other->error_node_);
    std::swap(options_json_, other->options_json_);
    std::swap(planend_, other->planend_);
    std::swap(queuewaitend_, other->queuewaitend_);
    std::swap(total_cost_, other->total_cost_);
    std::swap(queue_name_, other->queue_name_);
    std::swap(queryid_, other->queryid_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata QueryProfile::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = QueryProfile_descriptor_;
  metadata.reflection = QueryProfile_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int MajorFragmentProfile::kMajorFragmentIdFieldNumber;
const int MajorFragmentProfile::kMinorFragmentProfileFieldNumber;
#endif  // !_MSC_VER

MajorFragmentProfile::MajorFragmentProfile()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void MajorFragmentProfile::InitAsDefaultInstance() {
}

MajorFragmentProfile::MajorFragmentProfile(const MajorFragmentProfile& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void MajorFragmentProfile::SharedCtor() {
  _cached_size_ = 0;
  major_fragment_id_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

MajorFragmentProfile::~MajorFragmentProfile() {
  SharedDtor();
}

void MajorFragmentProfile::SharedDtor() {
  if (this != default_instance_) {
  }
}

void MajorFragmentProfile::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* MajorFragmentProfile::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return MajorFragmentProfile_descriptor_;
}

const MajorFragmentProfile& MajorFragmentProfile::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_UserBitShared_2eproto();
  return *default_instance_;
}

MajorFragmentProfile* MajorFragmentProfile::default_instance_ = NULL;

MajorFragmentProfile* MajorFragmentProfile::New() const {
  return new MajorFragmentProfile;
}

void MajorFragmentProfile::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    major_fragment_id_ = 0;
  }
  minor_fragment_profile_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool MajorFragmentProfile::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 major_fragment_id = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &major_fragment_id_)));
          set_has_major_fragment_id();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_minor_fragment_profile;
        break;
      }

      // repeated .exec.shared.MinorFragmentProfile minor_fragment_profile = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_minor_fragment_profile:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_minor_fragment_profile()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_minor_fragment_profile;
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void MajorFragmentProfile::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional int32 major_fragment_id = 1;
  if (has_major_fragment_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->major_fragment_id(), output);
  }

  // repeated .exec.shared.MinorFragmentProfile minor_fragment_profile = 2;
  for (int i = 0; i < this->minor_fragment_profile_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->minor_fragment_profile(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* MajorFragmentProfile::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional int32 major_fragment_id = 1;
  if (has_major_fragment_id()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->major_fragment_id(), target);
  }

  // repeated .exec.shared.MinorFragmentProfile minor_fragment_profile = 2;
  for (int i = 0; i < this->minor_fragment_profile_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->minor_fragment_profile(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int MajorFragmentProfile::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional int32 major_fragment_id = 1;
    if (has_major_fragment_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->major_fragment_id());
    }

  }
  // repeated .exec.shared.MinorFragmentProfile minor_fragment_profile = 2;
  total_size += 1 * this->minor_fragment_profile_size();
  for (int i = 0; i < this->minor_fragment_profile_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->minor_fragment_profile(i));
  }

  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void MajorFragmentProfile::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const MajorFragmentProfile* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const MajorFragmentProfile*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void MajorFragmentProfile::MergeFrom(const MajorFragmentProfile& from) {
  GOOGLE_CHECK_NE(&from, this);
  minor_fragment_profile_.MergeFrom(from.minor_fragment_profile_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_major_fragment_id()) {
      set_major_fragment_id(from.major_fragment_id());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void MajorFragmentProfile::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void MajorFragmentProfile::CopyFrom(const MajorFragmentProfile& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MajorFragmentProfile::IsInitialized() const {

  return true;
}

void MajorFragmentProfile::Swap(MajorFragmentProfile* other) {
  if (other != this) {
    std::swap(major_fragment_id_, other->major_fragment_id_);
    minor_fragment_profile_.Swap(&other->minor_fragment_profile_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata MajorFragmentProfile::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = MajorFragmentProfile_descriptor_;
  metadata.reflection = MajorFragmentProfile_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int MinorFragmentProfile::kStateFieldNumber;
const int MinorFragmentProfile::kErrorFieldNumber;
const int MinorFragmentProfile::kMinorFragmentIdFieldNumber;
const int MinorFragmentProfile::kOperatorProfileFieldNumber;
const int MinorFragmentProfile::kStartTimeFieldNumber;
const int MinorFragmentProfile::kEndTimeFieldNumber;
const int MinorFragmentProfile::kMemoryUsedFieldNumber;
const int MinorFragmentProfile::kMaxMemoryUsedFieldNumber;
const int MinorFragmentProfile::kEndpointFieldNumber;
const int MinorFragmentProfile::kLastUpdateFieldNumber;
const int MinorFragmentProfile::kLastProgressFieldNumber;
#endif  // !_MSC_VER

MinorFragmentProfile::MinorFragmentProfile()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void MinorFragmentProfile::InitAsDefaultInstance() {
  error_ = const_cast< ::exec::shared::DrillPBError*>(&::exec::shared::DrillPBError::default_instance());
  endpoint_ = const_cast< ::exec::DrillbitEndpoint*>(&::exec::DrillbitEndpoint::default_instance());
}

MinorFragmentProfile::MinorFragmentProfile(const MinorFragmentProfile& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void MinorFragmentProfile::SharedCtor() {
  _cached_size_ = 0;
  state_ = 0;
  error_ = NULL;
  minor_fragment_id_ = 0;
  start_time_ = GOOGLE_LONGLONG(0);
  end_time_ = GOOGLE_LONGLONG(0);
  memory_used_ = GOOGLE_LONGLONG(0);
  max_memory_used_ = GOOGLE_LONGLONG(0);
  endpoint_ = NULL;
  last_update_ = GOOGLE_LONGLONG(0);
  last_progress_ = GOOGLE_LONGLONG(0);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

MinorFragmentProfile::~MinorFragmentProfile() {
  SharedDtor();
}

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

void MinorFragmentProfile::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* MinorFragmentProfile::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return MinorFragmentProfile_descriptor_;
}

const MinorFragmentProfile& MinorFragmentProfile::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_UserBitShared_2eproto();
  return *default_instance_;
}

MinorFragmentProfile* MinorFragmentProfile::default_instance_ = NULL;

MinorFragmentProfile* MinorFragmentProfile::New() const {
  return new MinorFragmentProfile;
}

void MinorFragmentProfile::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    state_ = 0;
    if (has_error()) {
      if (error_ != NULL) error_->::exec::shared::DrillPBError::Clear();
    }
    minor_fragment_id_ = 0;
    start_time_ = GOOGLE_LONGLONG(0);
    end_time_ = GOOGLE_LONGLONG(0);
    memory_used_ = GOOGLE_LONGLONG(0);
    max_memory_used_ = GOOGLE_LONGLONG(0);
  }
  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    if (has_endpoint()) {
      if (endpoint_ != NULL) endpoint_->::exec::DrillbitEndpoint::Clear();
    }
    last_update_ = GOOGLE_LONGLONG(0);
    last_progress_ = GOOGLE_LONGLONG(0);
  }
  operator_profile_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool MinorFragmentProfile::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .exec.shared.FragmentState state = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::exec::shared::FragmentState_IsValid(value)) {
            set_state(static_cast< ::exec::shared::FragmentState >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_error;
        break;
      }

      // optional .exec.shared.DrillPBError error = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_error:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_error()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_minor_fragment_id;
        break;
      }

      // optional int32 minor_fragment_id = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_minor_fragment_id:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &minor_fragment_id_)));
          set_has_minor_fragment_id();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(34)) goto parse_operator_profile;
        break;
      }

      // repeated .exec.shared.OperatorProfile operator_profile = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_operator_profile:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_operator_profile()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(34)) goto parse_operator_profile;
        if (input->ExpectTag(40)) goto parse_start_time;
        break;
      }

      // optional int64 start_time = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_start_time:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &start_time_)));
          set_has_start_time();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(48)) goto parse_end_time;
        break;
      }

      // optional int64 end_time = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_end_time:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &end_time_)));
          set_has_end_time();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(56)) goto parse_memory_used;
        break;
      }

      // optional int64 memory_used = 7;
      case 7: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_memory_used:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &memory_used_)));
          set_has_memory_used();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(64)) goto parse_max_memory_used;
        break;
      }

      // optional int64 max_memory_used = 8;
      case 8: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_max_memory_used:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &max_memory_used_)));
          set_has_max_memory_used();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(74)) goto parse_endpoint;
        break;
      }

      // optional .exec.DrillbitEndpoint endpoint = 9;
      case 9: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_endpoint:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_endpoint()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(80)) goto parse_last_update;
        break;
      }

      // optional int64 last_update = 10;
      case 10: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_last_update:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &last_update_)));
          set_has_last_update();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(88)) goto parse_last_progress;
        break;
      }

      // optional int64 last_progress = 11;
      case 11: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_last_progress:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &last_progress_)));
          set_has_last_progress();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void MinorFragmentProfile::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional .exec.shared.FragmentState state = 1;
  if (has_state()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->state(), output);
  }

  // optional .exec.shared.DrillPBError error = 2;
  if (has_error()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->error(), output);
  }

  // optional int32 minor_fragment_id = 3;
  if (has_minor_fragment_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->minor_fragment_id(), output);
  }

  // repeated .exec.shared.OperatorProfile operator_profile = 4;
  for (int i = 0; i < this->operator_profile_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      4, this->operator_profile(i), output);
  }

  // optional int64 start_time = 5;
  if (has_start_time()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(5, this->start_time(), output);
  }

  // optional int64 end_time = 6;
  if (has_end_time()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(6, this->end_time(), output);
  }

  // optional int64 memory_used = 7;
  if (has_memory_used()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(7, this->memory_used(), output);
  }

  // optional int64 max_memory_used = 8;
  if (has_max_memory_used()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(8, this->max_memory_used(), output);
  }

  // optional .exec.DrillbitEndpoint endpoint = 9;
  if (has_endpoint()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      9, this->endpoint(), output);
  }

  // optional int64 last_update = 10;
  if (has_last_update()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(10, this->last_update(), output);
  }

  // optional int64 last_progress = 11;
  if (has_last_progress()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(11, this->last_progress(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* MinorFragmentProfile::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional .exec.shared.FragmentState state = 1;
  if (has_state()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->state(), target);
  }

  // optional .exec.shared.DrillPBError error = 2;
  if (has_error()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->error(), target);
  }

  // optional int32 minor_fragment_id = 3;
  if (has_minor_fragment_id()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->minor_fragment_id(), target);
  }

  // repeated .exec.shared.OperatorProfile operator_profile = 4;
  for (int i = 0; i < this->operator_profile_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        4, this->operator_profile(i), target);
  }

  // optional int64 start_time = 5;
  if (has_start_time()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(5, this->start_time(), target);
  }

  // optional int64 end_time = 6;
  if (has_end_time()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(6, this->end_time(), target);
  }

  // optional int64 memory_used = 7;
  if (has_memory_used()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(7, this->memory_used(), target);
  }

  // optional int64 max_memory_used = 8;
  if (has_max_memory_used()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(8, this->max_memory_used(), target);
  }

  // optional .exec.DrillbitEndpoint endpoint = 9;
  if (has_endpoint()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        9, this->endpoint(), target);
  }

  // optional int64 last_update = 10;
  if (has_last_update()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(10, this->last_update(), target);
  }

  // optional int64 last_progress = 11;
  if (has_last_progress()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(11, this->last_progress(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int MinorFragmentProfile::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .exec.shared.FragmentState state = 1;
    if (has_state()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->state());
    }

    // optional .exec.shared.DrillPBError error = 2;
    if (has_error()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->error());
    }

    // optional int32 minor_fragment_id = 3;
    if (has_minor_fragment_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->minor_fragment_id());
    }

    // optional int64 start_time = 5;
    if (has_start_time()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->start_time());
    }

    // optional int64 end_time = 6;
    if (has_end_time()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->end_time());
    }

    // optional int64 memory_used = 7;
    if (has_memory_used()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->memory_used());
    }

    // optional int64 max_memory_used = 8;
    if (has_max_memory_used()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->max_memory_used());
    }

  }
  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    // optional .exec.DrillbitEndpoint endpoint = 9;
    if (has_endpoint()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->endpoint());
    }

    // optional int64 last_update = 10;
    if (has_last_update()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->last_update());
    }

    // optional int64 last_progress = 11;
    if (has_last_progress()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->last_progress());
    }

  }
  // repeated .exec.shared.OperatorProfile operator_profile = 4;
  total_size += 1 * this->operator_profile_size();
  for (int i = 0; i < this->operator_profile_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->operator_profile(i));
  }

  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void MinorFragmentProfile::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const MinorFragmentProfile* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const MinorFragmentProfile*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void MinorFragmentProfile::MergeFrom(const MinorFragmentProfile& from) {
  GOOGLE_CHECK_NE(&from, this);
  operator_profile_.MergeFrom(from.operator_profile_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_state()) {
      set_state(from.state());
    }
    if (from.has_error()) {
      mutable_error()->::exec::shared::DrillPBError::MergeFrom(from.error());
    }
    if (from.has_minor_fragment_id()) {
      set_minor_fragment_id(from.minor_fragment_id());
    }
    if (from.has_start_time()) {
      set_start_time(from.start_time());
    }
    if (from.has_end_time()) {
      set_end_time(from.end_time());
    }
    if (from.has_memory_used()) {
      set_memory_used(from.memory_used());
    }
    if (from.has_max_memory_used()) {
      set_max_memory_used(from.max_memory_used());
    }
  }
  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    if (from.has_endpoint()) {
      mutable_endpoint()->::exec::DrillbitEndpoint::MergeFrom(from.endpoint());
    }
    if (from.has_last_update()) {
      set_last_update(from.last_update());
    }
    if (from.has_last_progress()) {
      set_last_progress(from.last_progress());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void MinorFragmentProfile::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void MinorFragmentProfile::CopyFrom(const MinorFragmentProfile& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MinorFragmentProfile::IsInitialized() const {

  return true;
}

void MinorFragmentProfile::Swap(MinorFragmentProfile* other) {
  if (other != this) {
    std::swap(state_, other->state_);
    std::swap(error_, other->error_);
    std::swap(minor_fragment_id_, other->minor_fragment_id_);
    operator_profile_.Swap(&other->operator_profile_);
    std::swap(start_time_, other->start_time_);
    std::swap(end_time_, other->end_time_);
    std::swap(memory_used_, other->memory_used_);
    std::swap(max_memory_used_, other->max_memory_used_);
    std::swap(endpoint_, other->endpoint_);
    std::swap(last_update_, other->last_update_);
    std::swap(last_progress_, other->last_progress_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata MinorFragmentProfile::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = MinorFragmentProfile_descriptor_;
  metadata.reflection = MinorFragmentProfile_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int OperatorProfile::kInputProfileFieldNumber;
const int OperatorProfile::kOperatorIdFieldNumber;
const int OperatorProfile::kOperatorTypeFieldNumber;
const int OperatorProfile::kSetupNanosFieldNumber;
const int OperatorProfile::kProcessNanosFieldNumber;
const int OperatorProfile::kPeakLocalMemoryAllocatedFieldNumber;
const int OperatorProfile::kMetricFieldNumber;
const int OperatorProfile::kWaitNanosFieldNumber;
#endif  // !_MSC_VER

OperatorProfile::OperatorProfile()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void OperatorProfile::InitAsDefaultInstance() {
}

OperatorProfile::OperatorProfile(const OperatorProfile& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void OperatorProfile::SharedCtor() {
  _cached_size_ = 0;
  operator_id_ = 0;
  operator_type_ = 0;
  setup_nanos_ = GOOGLE_LONGLONG(0);
  process_nanos_ = GOOGLE_LONGLONG(0);
  peak_local_memory_allocated_ = GOOGLE_LONGLONG(0);
  wait_nanos_ = GOOGLE_LONGLONG(0);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

OperatorProfile::~OperatorProfile() {
  SharedDtor();
}

void OperatorProfile::SharedDtor() {
  if (this != default_instance_) {
  }
}

void OperatorProfile::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* OperatorProfile::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return OperatorProfile_descriptor_;
}

const OperatorProfile& OperatorProfile::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_UserBitShared_2eproto();
  return *default_instance_;
}

OperatorProfile* OperatorProfile::default_instance_ = NULL;

OperatorProfile* OperatorProfile::New() const {
  return new OperatorProfile;
}

void OperatorProfile::Clear() {
  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
    operator_id_ = 0;
    operator_type_ = 0;
    setup_nanos_ = GOOGLE_LONGLONG(0);
    process_nanos_ = GOOGLE_LONGLONG(0);
    peak_local_memory_allocated_ = GOOGLE_LONGLONG(0);
    wait_nanos_ = GOOGLE_LONGLONG(0);
  }
  input_profile_.Clear();
  metric_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool OperatorProfile::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated .exec.shared.StreamProfile input_profile = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_input_profile:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_input_profile()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(10)) goto parse_input_profile;
        if (input->ExpectTag(24)) goto parse_operator_id;
        break;
      }

      // optional int32 operator_id = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_operator_id:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &operator_id_)));
          set_has_operator_id();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_operator_type;
        break;
      }

      // optional int32 operator_type = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_operator_type:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &operator_type_)));
          set_has_operator_type();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(40)) goto parse_setup_nanos;
        break;
      }

      // optional int64 setup_nanos = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_setup_nanos:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &setup_nanos_)));
          set_has_setup_nanos();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(48)) goto parse_process_nanos;
        break;
      }

      // optional int64 process_nanos = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_process_nanos:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &process_nanos_)));
          set_has_process_nanos();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(56)) goto parse_peak_local_memory_allocated;
        break;
      }

      // optional int64 peak_local_memory_allocated = 7;
      case 7: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_peak_local_memory_allocated:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &peak_local_memory_allocated_)));
          set_has_peak_local_memory_allocated();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(66)) goto parse_metric;
        break;
      }

      // repeated .exec.shared.MetricValue metric = 8;
      case 8: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_metric:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_metric()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(66)) goto parse_metric;
        if (input->ExpectTag(72)) goto parse_wait_nanos;
        break;
      }

      // optional int64 wait_nanos = 9;
      case 9: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_wait_nanos:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &wait_nanos_)));
          set_has_wait_nanos();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void OperatorProfile::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // repeated .exec.shared.StreamProfile input_profile = 1;
  for (int i = 0; i < this->input_profile_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->input_profile(i), output);
  }

  // optional int32 operator_id = 3;
  if (has_operator_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->operator_id(), output);
  }

  // optional int32 operator_type = 4;
  if (has_operator_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->operator_type(), output);
  }

  // optional int64 setup_nanos = 5;
  if (has_setup_nanos()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(5, this->setup_nanos(), output);
  }

  // optional int64 process_nanos = 6;
  if (has_process_nanos()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(6, this->process_nanos(), output);
  }

  // optional int64 peak_local_memory_allocated = 7;
  if (has_peak_local_memory_allocated()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(7, this->peak_local_memory_allocated(), output);
  }

  // repeated .exec.shared.MetricValue metric = 8;
  for (int i = 0; i < this->metric_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      8, this->metric(i), output);
  }

  // optional int64 wait_nanos = 9;
  if (has_wait_nanos()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(9, this->wait_nanos(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* OperatorProfile::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // repeated .exec.shared.StreamProfile input_profile = 1;
  for (int i = 0; i < this->input_profile_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->input_profile(i), target);
  }

  // optional int32 operator_id = 3;
  if (has_operator_id()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->operator_id(), target);
  }

  // optional int32 operator_type = 4;
  if (has_operator_type()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->operator_type(), target);
  }

  // optional int64 setup_nanos = 5;
  if (has_setup_nanos()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(5, this->setup_nanos(), target);
  }

  // optional int64 process_nanos = 6;
  if (has_process_nanos()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(6, this->process_nanos(), target);
  }

  // optional int64 peak_local_memory_allocated = 7;
  if (has_peak_local_memory_allocated()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(7, this->peak_local_memory_allocated(), target);
  }

  // repeated .exec.shared.MetricValue metric = 8;
  for (int i = 0; i < this->metric_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        8, this->metric(i), target);
  }

  // optional int64 wait_nanos = 9;
  if (has_wait_nanos()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(9, this->wait_nanos(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int OperatorProfile::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
    // optional int32 operator_id = 3;
    if (has_operator_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->operator_id());
    }

    // optional int32 operator_type = 4;
    if (has_operator_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->operator_type());
    }

    // optional int64 setup_nanos = 5;
    if (has_setup_nanos()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->setup_nanos());
    }

    // optional int64 process_nanos = 6;
    if (has_process_nanos()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->process_nanos());
    }

    // optional int64 peak_local_memory_allocated = 7;
    if (has_peak_local_memory_allocated()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->peak_local_memory_allocated());
    }

    // optional int64 wait_nanos = 9;
    if (has_wait_nanos()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->wait_nanos());
    }

  }
  // repeated .exec.shared.StreamProfile input_profile = 1;
  total_size += 1 * this->input_profile_size();
  for (int i = 0; i < this->input_profile_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->input_profile(i));
  }

  // repeated .exec.shared.MetricValue metric = 8;
  total_size += 1 * this->metric_size();
  for (int i = 0; i < this->metric_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->metric(i));
  }

  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void OperatorProfile::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const OperatorProfile* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const OperatorProfile*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void OperatorProfile::MergeFrom(const OperatorProfile& from) {
  GOOGLE_CHECK_NE(&from, this);
  input_profile_.MergeFrom(from.input_profile_);
  metric_.MergeFrom(from.metric_);
  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
    if (from.has_operator_id()) {
      set_operator_id(from.operator_id());
    }
    if (from.has_operator_type()) {
      set_operator_type(from.operator_type());
    }
    if (from.has_setup_nanos()) {
      set_setup_nanos(from.setup_nanos());
    }
    if (from.has_process_nanos()) {
      set_process_nanos(from.process_nanos());
    }
    if (from.has_peak_local_memory_allocated()) {
      set_peak_local_memory_allocated(from.peak_local_memory_allocated());
    }
    if (from.has_wait_nanos()) {
      set_wait_nanos(from.wait_nanos());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void OperatorProfile::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void OperatorProfile::CopyFrom(const OperatorProfile& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool OperatorProfile::IsInitialized() const {

  return true;
}

void OperatorProfile::Swap(OperatorProfile* other) {
  if (other != this) {
    input_profile_.Swap(&other->input_profile_);
    std::swap(operator_id_, other->operator_id_);
    std::swap(operator_type_, other->operator_type_);
    std::swap(setup_nanos_, other->setup_nanos_);
    std::swap(process_nanos_, other->process_nanos_);
    std::swap(peak_local_memory_allocated_, other->peak_local_memory_allocated_);
    metric_.Swap(&other->metric_);
    std::swap(wait_nanos_, other->wait_nanos_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata OperatorProfile::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = OperatorProfile_descriptor_;
  metadata.reflection = OperatorProfile_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int StreamProfile::kRecordsFieldNumber;
const int StreamProfile::kBatchesFieldNumber;
const int StreamProfile::kSchemasFieldNumber;
#endif  // !_MSC_VER

StreamProfile::StreamProfile()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void StreamProfile::InitAsDefaultInstance() {
}

StreamProfile::StreamProfile(const StreamProfile& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void StreamProfile::SharedCtor() {
  _cached_size_ = 0;
  records_ = GOOGLE_LONGLONG(0);
  batches_ = GOOGLE_LONGLONG(0);
  schemas_ = GOOGLE_LONGLONG(0);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

StreamProfile::~StreamProfile() {
  SharedDtor();
}

void StreamProfile::SharedDtor() {
  if (this != default_instance_) {
  }
}

void StreamProfile::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* StreamProfile::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return StreamProfile_descriptor_;
}

const StreamProfile& StreamProfile::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_UserBitShared_2eproto();
  return *default_instance_;
}

StreamProfile* StreamProfile::default_instance_ = NULL;

StreamProfile* StreamProfile::New() const {
  return new StreamProfile;
}

void StreamProfile::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    records_ = GOOGLE_LONGLONG(0);
    batches_ = GOOGLE_LONGLONG(0);
    schemas_ = GOOGLE_LONGLONG(0);
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool StreamProfile::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int64 records = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &records_)));
          set_has_records();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_batches;
        break;
      }

      // optional int64 batches = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_batches:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &batches_)));
          set_has_batches();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_schemas;
        break;
      }

      // optional int64 schemas = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_schemas:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &schemas_)));
          set_has_schemas();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void StreamProfile::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional int64 records = 1;
  if (has_records()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->records(), output);
  }

  // optional int64 batches = 2;
  if (has_batches()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(2, this->batches(), output);
  }

  // optional int64 schemas = 3;
  if (has_schemas()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(3, this->schemas(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* StreamProfile::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional int64 records = 1;
  if (has_records()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(1, this->records(), target);
  }

  // optional int64 batches = 2;
  if (has_batches()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(2, this->batches(), target);
  }

  // optional int64 schemas = 3;
  if (has_schemas()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(3, this->schemas(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int StreamProfile::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional int64 records = 1;
    if (has_records()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->records());
    }

    // optional int64 batches = 2;
    if (has_batches()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->batches());
    }

    // optional int64 schemas = 3;
    if (has_schemas()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->schemas());
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void StreamProfile::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const StreamProfile* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const StreamProfile*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void StreamProfile::MergeFrom(const StreamProfile& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_records()) {
      set_records(from.records());
    }
    if (from.has_batches()) {
      set_batches(from.batches());
    }
    if (from.has_schemas()) {
      set_schemas(from.schemas());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void StreamProfile::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void StreamProfile::CopyFrom(const StreamProfile& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool StreamProfile::IsInitialized() const {

  return true;
}

void StreamProfile::Swap(StreamProfile* other) {
  if (other != this) {
    std::swap(records_, other->records_);
    std::swap(batches_, other->batches_);
    std::swap(schemas_, other->schemas_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata StreamProfile::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = StreamProfile_descriptor_;
  metadata.reflection = StreamProfile_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int MetricValue::kMetricIdFieldNumber;
const int MetricValue::kLongValueFieldNumber;
const int MetricValue::kDoubleValueFieldNumber;
#endif  // !_MSC_VER

MetricValue::MetricValue()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void MetricValue::InitAsDefaultInstance() {
}

MetricValue::MetricValue(const MetricValue& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void MetricValue::SharedCtor() {
  _cached_size_ = 0;
  metric_id_ = 0;
  long_value_ = GOOGLE_LONGLONG(0);
  double_value_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

MetricValue::~MetricValue() {
  SharedDtor();
}

void MetricValue::SharedDtor() {
  if (this != default_instance_) {
  }
}

void MetricValue::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* MetricValue::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return MetricValue_descriptor_;
}

const MetricValue& MetricValue::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_UserBitShared_2eproto();
  return *default_instance_;
}

MetricValue* MetricValue::default_instance_ = NULL;

MetricValue* MetricValue::New() const {
  return new MetricValue;
}

void MetricValue::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    metric_id_ = 0;
    long_value_ = GOOGLE_LONGLONG(0);
    double_value_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool MetricValue::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 metric_id = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &metric_id_)));
          set_has_metric_id();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_long_value;
        break;
      }

      // optional int64 long_value = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_long_value:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &long_value_)));
          set_has_long_value();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(25)) goto parse_double_value;
        break;
      }

      // optional double double_value = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_double_value:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &double_value_)));
          set_has_double_value();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void MetricValue::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional int32 metric_id = 1;
  if (has_metric_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->metric_id(), output);
  }

  // optional int64 long_value = 2;
  if (has_long_value()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(2, this->long_value(), output);
  }

  // optional double double_value = 3;
  if (has_double_value()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(3, this->double_value(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* MetricValue::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional int32 metric_id = 1;
  if (has_metric_id()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->metric_id(), target);
  }

  // optional int64 long_value = 2;
  if (has_long_value()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(2, this->long_value(), target);
  }

  // optional double double_value = 3;
  if (has_double_value()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(3, this->double_value(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int MetricValue::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional int32 metric_id = 1;
    if (has_metric_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->metric_id());
    }

    // optional int64 long_value = 2;
    if (has_long_value()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->long_value());
    }

    // optional double double_value = 3;
    if (has_double_value()) {
      total_size += 1 + 8;
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void MetricValue::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const MetricValue* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const MetricValue*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void MetricValue::MergeFrom(const MetricValue& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_metric_id()) {
      set_metric_id(from.metric_id());
    }
    if (from.has_long_value()) {
      set_long_value(from.long_value());
    }
    if (from.has_double_value()) {
      set_double_value(from.double_value());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void MetricValue::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void MetricValue::CopyFrom(const MetricValue& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MetricValue::IsInitialized() const {

  return true;
}

void MetricValue::Swap(MetricValue* other) {
  if (other != this) {
    std::swap(metric_id_, other->metric_id_);
    std::swap(long_value_, other->long_value_);
    std::swap(double_value_, other->double_value_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata MetricValue::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = MetricValue_descriptor_;
  metadata.reflection = MetricValue_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int Registry::kJarFieldNumber;
#endif  // !_MSC_VER

Registry::Registry()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void Registry::InitAsDefaultInstance() {
}

Registry::Registry(const Registry& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void Registry::SharedCtor() {
  _cached_size_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

Registry::~Registry() {
  SharedDtor();
}

void Registry::SharedDtor() {
  if (this != default_instance_) {
  }
}

void Registry::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* Registry::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return Registry_descriptor_;
}

const Registry& Registry::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_UserBitShared_2eproto();
  return *default_instance_;
}

Registry* Registry::default_instance_ = NULL;

Registry* Registry::New() const {
  return new Registry;
}

void Registry::Clear() {
  jar_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool Registry::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated .exec.shared.Jar jar = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_jar:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_jar()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(10)) goto parse_jar;
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void Registry::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // repeated .exec.shared.Jar jar = 1;
  for (int i = 0; i < this->jar_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->jar(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* Registry::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // repeated .exec.shared.Jar jar = 1;
  for (int i = 0; i < this->jar_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->jar(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int Registry::ByteSize() const {
  int total_size = 0;

  // repeated .exec.shared.Jar jar = 1;
  total_size += 1 * this->jar_size();
  for (int i = 0; i < this->jar_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->jar(i));
  }

  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Registry::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const Registry* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const Registry*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void Registry::MergeFrom(const Registry& from) {
  GOOGLE_CHECK_NE(&from, this);
  jar_.MergeFrom(from.jar_);
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void Registry::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Registry::CopyFrom(const Registry& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Registry::IsInitialized() const {

  return true;
}

void Registry::Swap(Registry* other) {
  if (other != this) {
    jar_.Swap(&other->jar_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata Registry::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Registry_descriptor_;
  metadata.reflection = Registry_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int Jar::kNameFieldNumber;
const int Jar::kFunctionSignatureFieldNumber;
#endif  // !_MSC_VER

Jar::Jar()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void Jar::InitAsDefaultInstance() {
}

Jar::Jar(const Jar& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void Jar::SharedCtor() {
  _cached_size_ = 0;
  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

Jar::~Jar() {
  SharedDtor();
}

void Jar::SharedDtor() {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    delete name_;
  }
  if (this != default_instance_) {
  }
}

void Jar::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* Jar::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return Jar_descriptor_;
}

const Jar& Jar::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_UserBitShared_2eproto();
  return *default_instance_;
}

Jar* Jar::default_instance_ = NULL;

Jar* Jar::New() const {
  return new Jar;
}

void Jar::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_name()) {
      if (name_ != &::google::protobuf::internal::kEmptyString) {
        name_->clear();
      }
    }
  }
  function_signature_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool Jar::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string name = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->name().data(), this->name().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_function_signature;
        break;
      }

      // repeated string function_signature = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_function_signature:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->add_function_signature()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->function_signature(this->function_signature_size() - 1).data(),
            this->function_signature(this->function_signature_size() - 1).length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_function_signature;
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void Jar::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional string name = 1;
  if (has_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->name(), output);
  }

  // repeated string function_signature = 2;
  for (int i = 0; i < this->function_signature_size(); i++) {
  ::google::protobuf::internal::WireFormat::VerifyUTF8String(
    this->function_signature(i).data(), this->function_signature(i).length(),
    ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      2, this->function_signature(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* Jar::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional string name = 1;
  if (has_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->name(), target);
  }

  // repeated string function_signature = 2;
  for (int i = 0; i < this->function_signature_size(); i++) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->function_signature(i).data(), this->function_signature(i).length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target = ::google::protobuf::internal::WireFormatLite::
      WriteStringToArray(2, this->function_signature(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int Jar::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional string name = 1;
    if (has_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->name());
    }

  }
  // repeated string function_signature = 2;
  total_size += 1 * this->function_signature_size();
  for (int i = 0; i < this->function_signature_size(); i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
      this->function_signature(i));
  }

  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Jar::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const Jar* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const Jar*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void Jar::MergeFrom(const Jar& from) {
  GOOGLE_CHECK_NE(&from, this);
  function_signature_.MergeFrom(from.function_signature_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_name()) {
      set_name(from.name());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void Jar::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Jar::CopyFrom(const Jar& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Jar::IsInitialized() const {

  return true;
}

void Jar::Swap(Jar* other) {
  if (other != this) {
    std::swap(name_, other->name_);
    function_signature_.Swap(&other->function_signature_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata Jar::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Jar_descriptor_;
  metadata.reflection = Jar_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int SaslMessage::kMechanismFieldNumber;
const int SaslMessage::kDataFieldNumber;
const int SaslMessage::kStatusFieldNumber;
#endif  // !_MSC_VER

SaslMessage::SaslMessage()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void SaslMessage::InitAsDefaultInstance() {
}

SaslMessage::SaslMessage(const SaslMessage& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void SaslMessage::SharedCtor() {
  _cached_size_ = 0;
  mechanism_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  status_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

SaslMessage::~SaslMessage() {
  SharedDtor();
}

void SaslMessage::SharedDtor() {
  if (mechanism_ != &::google::protobuf::internal::kEmptyString) {
    delete mechanism_;
  }
  if (data_ != &::google::protobuf::internal::kEmptyString) {
    delete data_;
  }
  if (this != default_instance_) {
  }
}

void SaslMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* SaslMessage::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return SaslMessage_descriptor_;
}

const SaslMessage& SaslMessage::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_UserBitShared_2eproto();
  return *default_instance_;
}

SaslMessage* SaslMessage::default_instance_ = NULL;

SaslMessage* SaslMessage::New() const {
  return new SaslMessage;
}

void SaslMessage::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_mechanism()) {
      if (mechanism_ != &::google::protobuf::internal::kEmptyString) {
        mechanism_->clear();
      }
    }
    if (has_data()) {
      if (data_ != &::google::protobuf::internal::kEmptyString) {
        data_->clear();
      }
    }
    status_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool SaslMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string mechanism = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_mechanism()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->mechanism().data(), this->mechanism().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_data;
        break;
      }

      // optional bytes data = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_data:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_data()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_status;
        break;
      }

      // optional .exec.shared.SaslStatus status = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_status:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::exec::shared::SaslStatus_IsValid(value)) {
            set_status(static_cast< ::exec::shared::SaslStatus >(value));
          } else {
            mutable_unknown_fields()->AddVarint(3, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void SaslMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional string mechanism = 1;
  if (has_mechanism()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->mechanism().data(), this->mechanism().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->mechanism(), output);
  }

  // optional bytes data = 2;
  if (has_data()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytes(
      2, this->data(), output);
  }

  // optional .exec.shared.SaslStatus status = 3;
  if (has_status()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      3, this->status(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* SaslMessage::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional string mechanism = 1;
  if (has_mechanism()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->mechanism().data(), this->mechanism().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->mechanism(), target);
  }

  // optional bytes data = 2;
  if (has_data()) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        2, this->data(), target);
  }

  // optional .exec.shared.SaslStatus status = 3;
  if (has_status()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      3, this->status(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int SaslMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional string mechanism = 1;
    if (has_mechanism()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->mechanism());
    }

    // optional bytes data = 2;
    if (has_data()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->data());
    }

    // optional .exec.shared.SaslStatus status = 3;
    if (has_status()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->status());
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void SaslMessage::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const SaslMessage* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const SaslMessage*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void SaslMessage::MergeFrom(const SaslMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_mechanism()) {
      set_mechanism(from.mechanism());
    }
    if (from.has_data()) {
      set_data(from.data());
    }
    if (from.has_status()) {
      set_status(from.status());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void SaslMessage::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void SaslMessage::CopyFrom(const SaslMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SaslMessage::IsInitialized() const {

  return true;
}

void SaslMessage::Swap(SaslMessage* other) {
  if (other != this) {
    std::swap(mechanism_, other->mechanism_);
    std::swap(data_, other->data_);
    std::swap(status_, other->status_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata SaslMessage::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = SaslMessage_descriptor_;
  metadata.reflection = SaslMessage_reflection_;
  return metadata;
}


// @@protoc_insertion_point(namespace_scope)

}  // namespace shared
}  // namespace exec

// @@protoc_insertion_point(global_scope)
