drill-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From par...@apache.org
Subject [2/3] drill git commit: DRILL-2998: Implement heartbeat in C++ client
Date Wed, 13 May 2015 18:19:03 GMT
http://git-wip-us.apache.org/repos/asf/drill/blob/ffbb9c7a/contrib/native/client/src/protobuf/User.pb.cc
----------------------------------------------------------------------
diff --git a/contrib/native/client/src/protobuf/User.pb.cc b/contrib/native/client/src/protobuf/User.pb.cc
index 59f2157..212ad6a 100644
--- a/contrib/native/client/src/protobuf/User.pb.cc
+++ b/contrib/native/client/src/protobuf/User.pb.cc
@@ -84,13 +84,14 @@ void protobuf_AssignDesc_User_2eproto() {
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(UserProperties));
   UserToBitHandshake_descriptor_ = file->message_type(2);
-  static const int UserToBitHandshake_offsets_[6] = {
+  static const int UserToBitHandshake_offsets_[7] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserToBitHandshake, channel_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserToBitHandshake, support_listening_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserToBitHandshake, rpc_version_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserToBitHandshake, credentials_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserToBitHandshake, properties_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserToBitHandshake, support_complex_types_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserToBitHandshake, support_timeout_),
   };
   UserToBitHandshake_reflection_ =
     new ::google::protobuf::internal::GeneratedMessageReflection(
@@ -213,31 +214,32 @@ void protobuf_AddDesc_User_2eproto() {
     "\032\023UserBitShared.proto\"&\n\010Property\022\013\n\003key"
     "\030\001 \002(\t\022\r\n\005value\030\002 \002(\t\"9\n\016UserProperties\022"
     "\'\n\nproperties\030\001 \003(\0132\023.exec.user.Property"
-    "\"\374\001\n\022UserToBitHandshake\022.\n\007channel\030\001 \001(\016"
+    "\"\234\002\n\022UserToBitHandshake\022.\n\007channel\030\001 \001(\016"
     "2\027.exec.shared.RpcChannel:\004USER\022\031\n\021suppo"
     "rt_listening\030\002 \001(\010\022\023\n\013rpc_version\030\003 \001(\005\022"
     "1\n\013credentials\030\004 \001(\0132\034.exec.shared.UserC"
     "redentials\022-\n\nproperties\030\005 \001(\0132\031.exec.us"
     "er.UserProperties\022$\n\025support_complex_typ"
-    "es\030\006 \001(\010:\005false\"S\n\016RequestResults\022&\n\010que"
-    "ry_id\030\001 \001(\0132\024.exec.shared.QueryId\022\031\n\021max"
-    "imum_responses\030\002 \001(\005\"q\n\010RunQuery\0221\n\014resu"
-    "lts_mode\030\001 \001(\0162\033.exec.user.QueryResultsM"
-    "ode\022$\n\004type\030\002 \001(\0162\026.exec.shared.QueryTyp"
-    "e\022\014\n\004plan\030\003 \001(\t\"|\n\022BitToUserHandshake\022\023\n"
-    "\013rpc_version\030\002 \001(\005\022*\n\006status\030\003 \001(\0162\032.exe"
-    "c.user.HandshakeStatus\022\017\n\007errorId\030\004 \001(\t\022"
-    "\024\n\014errorMessage\030\005 \001(\t*\310\001\n\007RpcType\022\r\n\tHAN"
-    "DSHAKE\020\000\022\007\n\003ACK\020\001\022\013\n\007GOODBYE\020\002\022\r\n\tRUN_QU"
-    "ERY\020\003\022\020\n\014CANCEL_QUERY\020\004\022\023\n\017REQUEST_RESUL"
-    "TS\020\005\022\016\n\nQUERY_DATA\020\006\022\020\n\014QUERY_HANDLE\020\007\022\026"
-    "\n\022REQ_META_FUNCTIONS\020\010\022\026\n\022RESP_FUNCTION_"
-    "LIST\020\t\022\020\n\014QUERY_RESULT\020\n*#\n\020QueryResults"
-    "Mode\022\017\n\013STREAM_FULL\020\001*^\n\017HandshakeStatus"
-    "\022\013\n\007SUCCESS\020\001\022\030\n\024RPC_VERSION_MISMATCH\020\002\022"
-    "\017\n\013AUTH_FAILED\020\003\022\023\n\017UNKNOWN_FAILURE\020\004B+\n"
-    "\033org.apache.drill.exec.protoB\nUserProtos"
-    "H\001", 1122);
+    "es\030\006 \001(\010:\005false\022\036\n\017support_timeout\030\007 \001(\010"
+    ":\005false\"S\n\016RequestResults\022&\n\010query_id\030\001 "
+    "\001(\0132\024.exec.shared.QueryId\022\031\n\021maximum_res"
+    "ponses\030\002 \001(\005\"q\n\010RunQuery\0221\n\014results_mode"
+    "\030\001 \001(\0162\033.exec.user.QueryResultsMode\022$\n\004t"
+    "ype\030\002 \001(\0162\026.exec.shared.QueryType\022\014\n\004pla"
+    "n\030\003 \001(\t\"|\n\022BitToUserHandshake\022\023\n\013rpc_ver"
+    "sion\030\002 \001(\005\022*\n\006status\030\003 \001(\0162\032.exec.user.H"
+    "andshakeStatus\022\017\n\007errorId\030\004 \001(\t\022\024\n\014error"
+    "Message\030\005 \001(\t*\341\001\n\007RpcType\022\r\n\tHANDSHAKE\020\000"
+    "\022\007\n\003ACK\020\001\022\013\n\007GOODBYE\020\002\022\r\n\tRUN_QUERY\020\003\022\020\n"
+    "\014CANCEL_QUERY\020\004\022\023\n\017REQUEST_RESULTS\020\005\022\027\n\023"
+    "RESUME_PAUSED_QUERY\020\013\022\016\n\nQUERY_DATA\020\006\022\020\n"
+    "\014QUERY_HANDLE\020\007\022\026\n\022REQ_META_FUNCTIONS\020\010\022"
+    "\026\n\022RESP_FUNCTION_LIST\020\t\022\020\n\014QUERY_RESULT\020"
+    "\n*#\n\020QueryResultsMode\022\017\n\013STREAM_FULL\020\001*^"
+    "\n\017HandshakeStatus\022\013\n\007SUCCESS\020\001\022\030\n\024RPC_VE"
+    "RSION_MISMATCH\020\002\022\017\n\013AUTH_FAILED\020\003\022\023\n\017UNK"
+    "NOWN_FAILURE\020\004B+\n\033org.apache.drill.exec."
+    "protoB\nUserProtosH\001", 1179);
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
     "User.proto", &protobuf_RegisterTypes);
   Property::default_instance_ = new Property();
@@ -278,6 +280,7 @@ bool RpcType_IsValid(int value) {
     case 8:
     case 9:
     case 10:
+    case 11:
       return true;
     default:
       return false;
@@ -812,6 +815,7 @@ const int UserToBitHandshake::kRpcVersionFieldNumber;
 const int UserToBitHandshake::kCredentialsFieldNumber;
 const int UserToBitHandshake::kPropertiesFieldNumber;
 const int UserToBitHandshake::kSupportComplexTypesFieldNumber;
+const int UserToBitHandshake::kSupportTimeoutFieldNumber;
 #endif  // !_MSC_VER
 
 UserToBitHandshake::UserToBitHandshake()
@@ -838,6 +842,7 @@ void UserToBitHandshake::SharedCtor() {
   credentials_ = NULL;
   properties_ = NULL;
   support_complex_types_ = false;
+  support_timeout_ = false;
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
@@ -885,6 +890,7 @@ void UserToBitHandshake::Clear() {
       if (properties_ != NULL) properties_->::exec::user::UserProperties::Clear();
     }
     support_complex_types_ = false;
+    support_timeout_ = false;
   }
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
   mutable_unknown_fields()->Clear();
@@ -988,6 +994,22 @@ bool UserToBitHandshake::MergePartialFromCodedStream(
         } else {
           goto handle_uninterpreted;
         }
+        if (input->ExpectTag(56)) goto parse_support_timeout;
+        break;
+      }
+
+      // optional bool support_timeout = 7 [default = false];
+      case 7: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_support_timeout:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &support_timeout_)));
+          set_has_support_timeout();
+        } else {
+          goto handle_uninterpreted;
+        }
         if (input->ExpectAtEnd()) return true;
         break;
       }
@@ -1043,6 +1065,11 @@ void UserToBitHandshake::SerializeWithCachedSizes(
     ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->support_complex_types(), output);
   }
 
+  // optional bool support_timeout = 7 [default = false];
+  if (has_support_timeout()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->support_timeout(), output);
+  }
+
   if (!unknown_fields().empty()) {
     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
         unknown_fields(), output);
@@ -1086,6 +1113,11 @@ void UserToBitHandshake::SerializeWithCachedSizes(
     target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->support_complex_types(), target);
   }
 
+  // optional bool support_timeout = 7 [default = false];
+  if (has_support_timeout()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(7, this->support_timeout(), target);
+  }
+
   if (!unknown_fields().empty()) {
     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
         unknown_fields(), target);
@@ -1134,6 +1166,11 @@ int UserToBitHandshake::ByteSize() const {
       total_size += 1 + 1;
     }
 
+    // optional bool support_timeout = 7 [default = false];
+    if (has_support_timeout()) {
+      total_size += 1 + 1;
+    }
+
   }
   if (!unknown_fields().empty()) {
     total_size +=
@@ -1179,6 +1216,9 @@ void UserToBitHandshake::MergeFrom(const UserToBitHandshake& from) {
     if (from.has_support_complex_types()) {
       set_support_complex_types(from.support_complex_types());
     }
+    if (from.has_support_timeout()) {
+      set_support_timeout(from.support_timeout());
+    }
   }
   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 }
@@ -1211,6 +1251,7 @@ void UserToBitHandshake::Swap(UserToBitHandshake* other) {
     std::swap(credentials_, other->credentials_);
     std::swap(properties_, other->properties_);
     std::swap(support_complex_types_, other->support_complex_types_);
+    std::swap(support_timeout_, other->support_timeout_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
     std::swap(_cached_size_, other->_cached_size_);

http://git-wip-us.apache.org/repos/asf/drill/blob/ffbb9c7a/contrib/native/client/src/protobuf/User.pb.h
----------------------------------------------------------------------
diff --git a/contrib/native/client/src/protobuf/User.pb.h b/contrib/native/client/src/protobuf/User.pb.h
index c7deac3..8628a54 100644
--- a/contrib/native/client/src/protobuf/User.pb.h
+++ b/contrib/native/client/src/protobuf/User.pb.h
@@ -51,6 +51,7 @@ enum RpcType {
   RUN_QUERY = 3,
   CANCEL_QUERY = 4,
   REQUEST_RESULTS = 5,
+  RESUME_PAUSED_QUERY = 11,
   QUERY_DATA = 6,
   QUERY_HANDLE = 7,
   REQ_META_FUNCTIONS = 8,
@@ -59,7 +60,7 @@ enum RpcType {
 };
 bool RpcType_IsValid(int value);
 const RpcType RpcType_MIN = HANDSHAKE;
-const RpcType RpcType_MAX = QUERY_RESULT;
+const RpcType RpcType_MAX = RESUME_PAUSED_QUERY;
 const int RpcType_ARRAYSIZE = RpcType_MAX + 1;
 
 const ::google::protobuf::EnumDescriptor* RpcType_descriptor();
@@ -400,6 +401,13 @@ class UserToBitHandshake : public ::google::protobuf::Message {
   inline bool support_complex_types() const;
   inline void set_support_complex_types(bool value);
 
+  // optional bool support_timeout = 7 [default = false];
+  inline bool has_support_timeout() const;
+  inline void clear_support_timeout();
+  static const int kSupportTimeoutFieldNumber = 7;
+  inline bool support_timeout() const;
+  inline void set_support_timeout(bool value);
+
   // @@protoc_insertion_point(class_scope:exec.user.UserToBitHandshake)
  private:
   inline void set_has_channel();
@@ -414,6 +422,8 @@ class UserToBitHandshake : public ::google::protobuf::Message {
   inline void clear_has_properties();
   inline void set_has_support_complex_types();
   inline void clear_has_support_complex_types();
+  inline void set_has_support_timeout();
+  inline void clear_has_support_timeout();
 
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
@@ -423,9 +433,10 @@ class UserToBitHandshake : public ::google::protobuf::Message {
   ::exec::user::UserProperties* properties_;
   bool support_listening_;
   bool support_complex_types_;
+  bool support_timeout_;
 
   mutable int _cached_size_;
-  ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32];
+  ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32];
 
   friend void  protobuf_AddDesc_User_2eproto();
   friend void protobuf_AssignDesc_User_2eproto();
@@ -1102,6 +1113,28 @@ inline void UserToBitHandshake::set_support_complex_types(bool value) {
   support_complex_types_ = value;
 }
 
+// optional bool support_timeout = 7 [default = false];
+inline bool UserToBitHandshake::has_support_timeout() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void UserToBitHandshake::set_has_support_timeout() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void UserToBitHandshake::clear_has_support_timeout() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void UserToBitHandshake::clear_support_timeout() {
+  support_timeout_ = false;
+  clear_has_support_timeout();
+}
+inline bool UserToBitHandshake::support_timeout() const {
+  return support_timeout_;
+}
+inline void UserToBitHandshake::set_support_timeout(bool value) {
+  set_has_support_timeout();
+  support_timeout_ = value;
+}
+
 // -------------------------------------------------------------------
 
 // RequestResults

http://git-wip-us.apache.org/repos/asf/drill/blob/ffbb9c7a/contrib/native/client/src/protobuf/UserBitShared.pb.cc
----------------------------------------------------------------------
diff --git a/contrib/native/client/src/protobuf/UserBitShared.pb.cc b/contrib/native/client/src/protobuf/UserBitShared.pb.cc
index b07ecda..a975438 100644
--- a/contrib/native/client/src/protobuf/UserBitShared.pb.cc
+++ b/contrib/native/client/src/protobuf/UserBitShared.pb.cc
@@ -30,6 +30,7 @@ const ::google::protobuf::internal::GeneratedMessageReflection*
 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;
@@ -145,6 +146,7 @@ void protobuf_AssignDesc_UserBitShared_2eproto() {
       ::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_),
@@ -327,7 +329,7 @@ void protobuf_AssignDesc_UserBitShared_2eproto() {
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(QueryInfo));
   QueryProfile_descriptor_ = file->message_type(13);
-  static const int QueryProfile_offsets_[11] = {
+  static const int QueryProfile_offsets_[16] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryProfile, id_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryProfile, type_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryProfile, start_),
@@ -339,6 +341,11 @@ void protobuf_AssignDesc_UserBitShared_2eproto() {
     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_),
   };
   QueryProfile_reflection_ =
     new ::google::protobuf::internal::GeneratedMessageReflection(
@@ -368,7 +375,7 @@ void protobuf_AssignDesc_UserBitShared_2eproto() {
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(MajorFragmentProfile));
   MinorFragmentProfile_descriptor_ = file->message_type(15);
-  static const int MinorFragmentProfile_offsets_[9] = {
+  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_),
@@ -378,6 +385,8 @@ void protobuf_AssignDesc_UserBitShared_2eproto() {
     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(
@@ -531,8 +540,10 @@ void protobuf_ShutdownFile_UserBitShared_2eproto() {
   delete QueryData_reflection_;
   delete QueryInfo::default_instance_;
   delete QueryInfo_reflection_;
+  delete QueryInfo::_default_user_;
   delete QueryProfile::default_instance_;
   delete QueryProfile_reflection_;
+  delete QueryProfile::_default_user_;
   delete MajorFragmentProfile::default_instance_;
   delete MajorFragmentProfile_reflection_;
   delete MinorFragmentProfile::default_instance_;
@@ -559,103 +570,113 @@ void protobuf_AddDesc_UserBitShared_2eproto() {
     "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\"\323\001\n\014DrillPBError\022\020\n\010error_id\030\001 \001(\t\022("
+    "\001(\020\"\255\003\n\014DrillPBError\022\020\n\010error_id\030\001 \001(\t\022("
     "\n\010endpoint\030\002 \001(\0132\026.exec.DrillbitEndpoint"
-    "\022\022\n\nerror_type\030\003 \001(\005\022\017\n\007message\030\004 \001(\t\0220\n"
-    "\texception\030\005 \001(\0132\035.exec.shared.Exception"
-    "Wrapper\0220\n\rparsing_error\030\006 \003(\0132\031.exec.sh"
-    "ared.ParsingError\"\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.Stac"
-    "kTraceElementWrapper\022,\n\005cause\030\004 \001(\0132\035.ex"
-    "ec.shared.ExceptionWrapper\"\205\001\n\030StackTrac"
-    "eElementWrapper\022\022\n\nclass_name\030\001 \001(\t\022\021\n\tf"
-    "ile_name\030\002 \001(\t\022\023\n\013line_number\030\003 \001(\005\022\023\n\013m"
-    "ethod_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\"~\n\016RecordBatchDef\022\024\n\014re"
-    "cord_count\030\001 \001(\005\022+\n\005field\030\002 \003(\0132\034.exec.s"
-    "hared.SerializedField\022)\n!carries_two_byt"
-    "e_selection_vector\030\003 \001(\010\"\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.shar"
-    "ed.NamePart\"\033\n\004Type\022\010\n\004NAME\020\000\022\t\n\005ARRAY\020\001"
-    "\"\351\001\n\017SerializedField\022%\n\nmajor_type\030\001 \001(\013"
-    "2\021.common.MajorType\022(\n\tname_part\030\002 \001(\0132\025"
-    ".exec.shared.NamePart\022+\n\005child\030\003 \003(\0132\034.e"
-    "xec.shared.SerializedField\022\023\n\013value_coun"
-    "t\030\004 \001(\005\022\027\n\017var_byte_length\030\005 \001(\005\022\023\n\013grou"
-    "p_count\030\006 \001(\005\022\025\n\rbuffer_length\030\007 \001(\005\"7\n\n"
-    "NodeStatus\022\017\n\007node_id\030\001 \001(\005\022\030\n\020memory_fo"
-    "otprint\030\002 \001(\003\"\206\002\n\013QueryResult\0228\n\013query_s"
-    "tate\030\001 \001(\0162#.exec.shared.QueryResult.Que"
-    "ryState\022&\n\010query_id\030\002 \001(\0132\024.exec.shared."
-    "QueryId\022(\n\005error\030\003 \003(\0132\031.exec.shared.Dri"
-    "llPBError\"k\n\nQueryState\022\013\n\007PENDING\020\000\022\013\n\007"
-    "RUNNING\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\"p"
-    "\n\tQueryData\022&\n\010query_id\030\001 \001(\0132\024.exec.sha"
-    "red.QueryId\022\021\n\trow_count\030\002 \001(\005\022(\n\003def\030\003 "
-    "\001(\0132\033.exec.shared.RecordBatchDef\"\224\001\n\tQue"
-    "ryInfo\022\r\n\005query\030\001 \001(\t\022\r\n\005start\030\002 \001(\003\0222\n\005"
-    "state\030\003 \001(\0162#.exec.shared.QueryResult.Qu"
-    "eryState\022\014\n\004user\030\004 \001(\t\022\'\n\007foreman\030\005 \001(\0132"
-    "\026.exec.DrillbitEndpoint\"\336\002\n\014QueryProfile"
-    "\022 \n\002id\030\001 \001(\0132\024.exec.shared.QueryId\022$\n\004ty"
-    "pe\030\002 \001(\0162\026.exec.shared.QueryType\022\r\n\005star"
-    "t\030\003 \001(\003\022\013\n\003end\030\004 \001(\003\022\r\n\005query\030\005 \001(\t\022\014\n\004p"
-    "lan\030\006 \001(\t\022\'\n\007foreman\030\007 \001(\0132\026.exec.Drillb"
-    "itEndpoint\0222\n\005state\030\010 \001(\0162#.exec.shared."
-    "QueryResult.QueryState\022\027\n\017total_fragment"
-    "s\030\t \001(\005\022\032\n\022finished_fragments\030\n \001(\005\022;\n\020f"
-    "ragment_profile\030\013 \003(\0132!.exec.shared.Majo"
-    "rFragmentProfile\"t\n\024MajorFragmentProfile"
-    "\022\031\n\021major_fragment_id\030\001 \001(\005\022A\n\026minor_fra"
-    "gment_profile\030\002 \003(\0132!.exec.shared.MinorF"
-    "ragmentProfile\"\274\002\n\024MinorFragmentProfile\022"
-    ")\n\005state\030\001 \001(\0162\032.exec.shared.FragmentSta"
-    "te\022(\n\005error\030\002 \001(\0132\031.exec.shared.DrillPBE"
-    "rror\022\031\n\021minor_fragment_id\030\003 \001(\005\0226\n\020opera"
-    "tor_profile\030\004 \003(\0132\034.exec.shared.Operator"
-    "Profile\022\022\n\nstart_time\030\005 \001(\003\022\020\n\010end_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.exec.Dri"
-    "llbitEndpoint\"\377\001\n\017OperatorProfile\0221\n\rinp"
-    "ut_profile\030\001 \003(\0132\032.exec.shared.StreamPro"
-    "file\022\023\n\013operator_id\030\003 \001(\005\022\025\n\roperator_ty"
-    "pe\030\004 \001(\005\022\023\n\013setup_nanos\030\005 \001(\003\022\025\n\rprocess"
-    "_nanos\030\006 \001(\003\022#\n\033peak_local_memory_alloca"
-    "ted\030\007 \001(\003\022(\n\006metric\030\010 \003(\0132\030.exec.shared."
-    "MetricValue\022\022\n\nwait_nanos\030\t \001(\003\"B\n\rStrea"
-    "mProfile\022\017\n\007records\030\001 \001(\003\022\017\n\007batches\030\002 \001"
-    "(\003\022\017\n\007schemas\030\003 \001(\003\"J\n\013MetricValue\022\021\n\tme"
-    "tric_id\030\001 \001(\005\022\022\n\nlong_value\030\002 \001(\003\022\024\n\014dou"
-    "ble_value\030\003 \001(\001*5\n\nRpcChannel\022\017\n\013BIT_CON"
-    "TROL\020\000\022\014\n\010BIT_DATA\020\001\022\010\n\004USER\020\002*/\n\tQueryT"
-    "ype\022\007\n\003SQL\020\001\022\013\n\007LOGICAL\020\002\022\014\n\010PHYSICAL\020\003*"
-    "k\n\rFragmentState\022\013\n\007SENDING\020\000\022\027\n\023AWAITIN"
-    "G_ALLOCATION\020\001\022\013\n\007RUNNING\020\002\022\014\n\010FINISHED\020"
-    "\003\022\r\n\tCANCELLED\020\004\022\n\n\006FAILED\020\005*\264\005\n\020CoreOpe"
-    "ratorType\022\021\n\rSINGLE_SENDER\020\000\022\024\n\020BROADCAS"
-    "T_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\025HAS"
-    "H_PARTITION_SENDER\020\006\022\t\n\005LIMIT\020\007\022\024\n\020MERGI"
-    "NG_RECEIVER\020\010\022\034\n\030ORDERED_PARTITION_SENDE"
-    "R\020\t\022\013\n\007PROJECT\020\n\022\026\n\022UNORDERED_RECEIVER\020\013"
-    "\022\020\n\014RANGE_SENDER\020\014\022\n\n\006SCREEN\020\r\022\034\n\030SELECT"
-    "ION_VECTOR_REMOVER\020\016\022\027\n\023STREAMING_AGGREG"
-    "ATE\020\017\022\016\n\nTOP_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\026"
-    "PARQUET_ROW_GROUP_SCAN\020\025\022\021\n\rHIVE_SUB_SCA"
-    "N\020\026\022\025\n\021SYSTEM_TABLE_SCAN\020\027\022\021\n\rMOCK_SUB_S"
-    "CAN\020\030\022\022\n\016PARQUET_WRITER\020\031\022\023\n\017DIRECT_SUB_"
-    "SCAN\020\032\022\017\n\013TEXT_WRITER\020\033\022\021\n\rTEXT_SUB_SCAN"
-    "\020\034\022\021\n\rJSON_SUB_SCAN\020\035\022\030\n\024INFO_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\006WINDO"
-    "W\020\"B.\n\033org.apache.drill.exec.protoB\rUser"
-    "BitSharedH\001", 4011);
+    "\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\"\262\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\"\246\001\n\020"
+    "ExceptionWrapper\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.StackTraceElementWrapper\022,"
+    "\n\005cause\030\004 \001(\0132\035.exec.shared.ExceptionWra"
+    "pper\"\205\001\n\030StackTraceElementWrapper\022\022\n\ncla"
+    "ss_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\014"
+    "start_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\"~\n\016Re"
+    "cordBatchDef\022\024\n\014record_count\030\001 \001(\005\022+\n\005fi"
+    "eld\030\002 \003(\0132\034.exec.shared.SerializedField\022"
+    ")\n!carries_two_byte_selection_vector\030\003 \001"
+    "(\010\"\205\001\n\010NamePart\022(\n\004type\030\001 \001(\0162\032.exec.sha"
+    "red.NamePart.Type\022\014\n\004name\030\002 \001(\t\022$\n\005child"
+    "\030\003 \001(\0132\025.exec.shared.NamePart\"\033\n\004Type\022\010\n"
+    "\004NAME\020\000\022\t\n\005ARRAY\020\001\"\351\001\n\017SerializedField\022%"
+    "\n\nmajor_type\030\001 \001(\0132\021.common.MajorType\022(\n"
+    "\tname_part\030\002 \001(\0132\025.exec.shared.NamePart\022"
+    "+\n\005child\030\003 \003(\0132\034.exec.shared.SerializedF"
+    "ield\022\023\n\013value_count\030\004 \001(\005\022\027\n\017var_byte_le"
+    "ngth\030\005 \001(\005\022\023\n\013group_count\030\006 \001(\005\022\025\n\rbuffe"
+    "r_length\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\"\206\002\n\013Quer"
+    "yResult\0228\n\013query_state\030\001 \001(\0162#.exec.shar"
+    "ed.QueryResult.QueryState\022&\n\010query_id\030\002 "
+    "\001(\0132\024.exec.shared.QueryId\022(\n\005error\030\003 \003(\013"
+    "2\031.exec.shared.DrillPBError\"k\n\nQueryStat"
+    "e\022\013\n\007PENDING\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\026CANCELLA"
+    "TION_REQUESTED\020\005\"p\n\tQueryData\022&\n\010query_i"
+    "d\030\001 \001(\0132\024.exec.shared.QueryId\022\021\n\trow_cou"
+    "nt\030\002 \001(\005\022(\n\003def\030\003 \001(\0132\033.exec.shared.Reco"
+    "rdBatchDef\"\227\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.sha"
+    "red.QueryResult.QueryState\022\017\n\004user\030\004 \001(\t"
+    ":\001-\022\'\n\007foreman\030\005 \001(\0132\026.exec.DrillbitEndp"
+    "oint\"\272\003\n\014QueryProfile\022 \n\002id\030\001 \001(\0132\024.exec"
+    ".shared.QueryId\022$\n\004type\030\002 \001(\0162\026.exec.sha"
+    "red.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\007forema"
+    "n\030\007 \001(\0132\026.exec.DrillbitEndpoint\0222\n\005state"
+    "\030\010 \001(\0162#.exec.shared.QueryResult.QuerySt"
+    "ate\022\027\n\017total_fragments\030\t \001(\005\022\032\n\022finished"
+    "_fragments\030\n \001(\005\022;\n\020fragment_profile\030\013 \003"
+    "(\0132!.exec.shared.MajorFragmentProfile\022\017\n"
+    "\004user\030\014 \001(\t:\001-\022\r\n\005error\030\r \001(\t\022\024\n\014verbose"
+    "Error\030\016 \001(\t\022\020\n\010error_id\030\017 \001(\t\022\022\n\nerror_n"
+    "ode\030\020 \001(\t\"t\n\024MajorFragmentProfile\022\031\n\021maj"
+    "or_fragment_id\030\001 \001(\005\022A\n\026minor_fragment_p"
+    "rofile\030\002 \003(\0132!.exec.shared.MinorFragment"
+    "Profile\"\350\002\n\024MinorFragmentProfile\022)\n\005stat"
+    "e\030\001 \001(\0162\032.exec.shared.FragmentState\022(\n\005e"
+    "rror\030\002 \001(\0132\031.exec.shared.DrillPBError\022\031\n"
+    "\021minor_fragment_id\030\003 \001(\005\0226\n\020operator_pro"
+    "file\030\004 \003(\0132\034.exec.shared.OperatorProfile"
+    "\022\022\n\nstart_time\030\005 \001(\003\022\020\n\010end_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.exec.DrillbitEn"
+    "dpoint\022\023\n\013last_update\030\n \001(\003\022\025\n\rlast_prog"
+    "ress\030\013 \001(\003\"\377\001\n\017OperatorProfile\0221\n\rinput_"
+    "profile\030\001 \003(\0132\032.exec.shared.StreamProfil"
+    "e\022\023\n\013operator_id\030\003 \001(\005\022\025\n\roperator_type\030"
+    "\004 \001(\005\022\023\n\013setup_nanos\030\005 \001(\003\022\025\n\rprocess_na"
+    "nos\030\006 \001(\003\022#\n\033peak_local_memory_allocated"
+    "\030\007 \001(\003\022(\n\006metric\030\010 \003(\0132\030.exec.shared.Met"
+    "ricValue\022\022\n\nwait_nanos\030\t \001(\003\"B\n\rStreamPr"
+    "ofile\022\017\n\007records\030\001 \001(\003\022\017\n\007batches\030\002 \001(\003\022"
+    "\017\n\007schemas\030\003 \001(\003\"J\n\013MetricValue\022\021\n\tmetri"
+    "c_id\030\001 \001(\005\022\022\n\nlong_value\030\002 \001(\003\022\024\n\014double"
+    "_value\030\003 \001(\001*5\n\nRpcChannel\022\017\n\013BIT_CONTRO"
+    "L\020\000\022\014\n\010BIT_DATA\020\001\022\010\n\004USER\020\002*/\n\tQueryType"
+    "\022\007\n\003SQL\020\001\022\013\n\007LOGICAL\020\002\022\014\n\010PHYSICAL\020\003*\207\001\n"
+    "\rFragmentState\022\013\n\007SENDING\020\000\022\027\n\023AWAITING_"
+    "ALLOCATION\020\001\022\013\n\007RUNNING\020\002\022\014\n\010FINISHED\020\003\022"
+    "\r\n\tCANCELLED\020\004\022\n\n\006FAILED\020\005\022\032\n\026CANCELLATI"
+    "ON_REQUESTED\020\006*\335\005\n\020CoreOperatorType\022\021\n\rS"
+    "INGLE_SENDER\020\000\022\024\n\020BROADCAST_SENDER\020\001\022\n\n\006"
+    "FILTER\020\002\022\022\n\016HASH_AGGREGATE\020\003\022\r\n\tHASH_JOI"
+    "N\020\004\022\016\n\nMERGE_JOIN\020\005\022\031\n\025HASH_PARTITION_SE"
+    "NDER\020\006\022\t\n\005LIMIT\020\007\022\024\n\020MERGING_RECEIVER\020\010\022"
+    "\034\n\030ORDERED_PARTITION_SENDER\020\t\022\013\n\007PROJECT"
+    "\020\n\022\026\n\022UNORDERED_RECEIVER\020\013\022\020\n\014RANGE_SEND"
+    "ER\020\014\022\n\n\006SCREEN\020\r\022\034\n\030SELECTION_VECTOR_REM"
+    "OVER\020\016\022\027\n\023STREAMING_AGGREGATE\020\017\022\016\n\nTOP_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_ROW_GR"
+    "OUP_SCAN\020\025\022\021\n\rHIVE_SUB_SCAN\020\026\022\025\n\021SYSTEM_"
+    "TABLE_SCAN\020\027\022\021\n\rMOCK_SUB_SCAN\020\030\022\022\n\016PARQU"
+    "ET_WRITER\020\031\022\023\n\017DIRECT_SUB_SCAN\020\032\022\017\n\013TEXT"
+    "_WRITER\020\033\022\021\n\rTEXT_SUB_SCAN\020\034\022\021\n\rJSON_SUB"
+    "_SCAN\020\035\022\030\n\024INFO_SCHEMA_SUB_SCAN\020\036\022\023\n\017COM"
+    "PLEX_TO_JSON\020\037\022\025\n\021PRODUCER_CONSUMER\020 \022\022\n"
+    "\016HBASE_SUB_SCAN\020!\022\n\n\006WINDOW\020\"\022\024\n\020NESTED_"
+    "LOOP_JOIN\020#\022\021\n\rAVRO_SUB_SCAN\020$B.\n\033org.ap"
+    "ache.drill.exec.protoB\rUserBitSharedH\001", 4438);
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
     "UserBitShared.proto", &protobuf_RegisterTypes);
   UserCredentials::default_instance_ = new UserCredentials();
@@ -670,7 +691,11 @@ void protobuf_AddDesc_UserBitShared_2eproto() {
   NodeStatus::default_instance_ = new NodeStatus();
   QueryResult::default_instance_ = new QueryResult();
   QueryData::default_instance_ = new QueryData();
+  QueryInfo::_default_user_ =
+      new ::std::string("-", 1);
   QueryInfo::default_instance_ = new QueryInfo();
+  QueryProfile::_default_user_ =
+      new ::std::string("-", 1);
   QueryProfile::default_instance_ = new QueryProfile();
   MajorFragmentProfile::default_instance_ = new MajorFragmentProfile();
   MinorFragmentProfile::default_instance_ = new MinorFragmentProfile();
@@ -747,6 +772,7 @@ bool FragmentState_IsValid(int value) {
     case 3:
     case 4:
     case 5:
+    case 6:
       return true;
     default:
       return false;
@@ -794,6 +820,8 @@ bool CoreOperatorType_IsValid(int value) {
     case 32:
     case 33:
     case 34:
+    case 35:
+    case 36:
       return true;
     default:
       return false;
@@ -1272,6 +1300,45 @@ void QueryId::Swap(QueryId* other) {
 
 // ===================================================================
 
+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:
+      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::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;
@@ -1406,15 +1473,20 @@ bool DrillPBError::MergePartialFromCodedStream(
         break;
       }
 
-      // optional int32 error_type = 3;
+      // 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<
-                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
-                 input, &error_type_)));
-          set_has_error_type();
+                   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;
         }
@@ -1501,9 +1573,10 @@ void DrillPBError::SerializeWithCachedSizes(
       2, this->endpoint(), output);
   }
 
-  // optional int32 error_type = 3;
+  // optional .exec.shared.DrillPBError.ErrorType error_type = 3;
   if (has_error_type()) {
-    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->error_type(), output);
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      3, this->error_type(), output);
   }
 
   // optional string message = 4;
@@ -1552,9 +1625,10 @@ void DrillPBError::SerializeWithCachedSizes(
         2, this->endpoint(), target);
   }
 
-  // optional int32 error_type = 3;
+  // optional .exec.shared.DrillPBError.ErrorType error_type = 3;
   if (has_error_type()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->error_type(), target);
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      3, this->error_type(), target);
   }
 
   // optional string message = 4;
@@ -1606,11 +1680,10 @@ int DrillPBError::ByteSize() const {
           this->endpoint());
     }
 
-    // optional int32 error_type = 3;
+    // optional .exec.shared.DrillPBError.ErrorType error_type = 3;
     if (has_error_type()) {
       total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::Int32Size(
-          this->error_type());
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->error_type());
     }
 
     // optional string message = 4;
@@ -4791,6 +4864,7 @@ void QueryData::Swap(QueryData* other) {
 
 // ===================================================================
 
+::std::string* QueryInfo::_default_user_ = NULL;
 #ifndef _MSC_VER
 const int QueryInfo::kQueryFieldNumber;
 const int QueryInfo::kStartFieldNumber;
@@ -4819,7 +4893,7 @@ void QueryInfo::SharedCtor() {
   query_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
   start_ = GOOGLE_LONGLONG(0);
   state_ = 0;
-  user_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  user_ = const_cast< ::std::string*>(_default_user_);
   foreman_ = NULL;
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
@@ -4832,7 +4906,7 @@ void QueryInfo::SharedDtor() {
   if (query_ != &::google::protobuf::internal::kEmptyString) {
     delete query_;
   }
-  if (user_ != &::google::protobuf::internal::kEmptyString) {
+  if (user_ != _default_user_) {
     delete user_;
   }
   if (this != default_instance_) {
@@ -4871,8 +4945,8 @@ void QueryInfo::Clear() {
     start_ = GOOGLE_LONGLONG(0);
     state_ = 0;
     if (has_user()) {
-      if (user_ != &::google::protobuf::internal::kEmptyString) {
-        user_->clear();
+      if (user_ != _default_user_) {
+        user_->assign(*_default_user_);
       }
     }
     if (has_foreman()) {
@@ -4942,7 +5016,7 @@ bool QueryInfo::MergePartialFromCodedStream(
         break;
       }
 
-      // optional string user = 4;
+      // optional string user = 4 [default = "-"];
       case 4: {
         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
@@ -5011,7 +5085,7 @@ void QueryInfo::SerializeWithCachedSizes(
       3, this->state(), output);
   }
 
-  // optional string user = 4;
+  // optional string user = 4 [default = "-"];
   if (has_user()) {
     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
       this->user().data(), this->user().length(),
@@ -5055,7 +5129,7 @@ void QueryInfo::SerializeWithCachedSizes(
       3, this->state(), target);
   }
 
-  // optional string user = 4;
+  // optional string user = 4 [default = "-"];
   if (has_user()) {
     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
       this->user().data(), this->user().length(),
@@ -5103,7 +5177,7 @@ int QueryInfo::ByteSize() const {
         ::google::protobuf::internal::WireFormatLite::EnumSize(this->state());
     }
 
-    // optional string user = 4;
+    // optional string user = 4 [default = "-"];
     if (has_user()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::StringSize(
@@ -5204,6 +5278,7 @@ void QueryInfo::Swap(QueryInfo* other) {
 
 // ===================================================================
 
+::std::string* QueryProfile::_default_user_ = NULL;
 #ifndef _MSC_VER
 const int QueryProfile::kIdFieldNumber;
 const int QueryProfile::kTypeFieldNumber;
@@ -5216,6 +5291,11 @@ 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;
 #endif  // !_MSC_VER
 
 QueryProfile::QueryProfile()
@@ -5246,6 +5326,11 @@ void QueryProfile::SharedCtor() {
   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);
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
@@ -5260,6 +5345,21 @@ void QueryProfile::SharedDtor() {
   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 (this != default_instance_) {
     delete id_;
     delete foreman_;
@@ -5313,6 +5413,31 @@ void QueryProfile::Clear() {
   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();
+      }
+    }
   }
   fragment_profile_.Clear();
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
@@ -5503,6 +5628,91 @@ bool QueryProfile::MergePartialFromCodedStream(
           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->ExpectAtEnd()) return true;
         break;
       }
@@ -5593,6 +5803,51 @@ void QueryProfile::SerializeWithCachedSizes(
       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);
+  }
+
   if (!unknown_fields().empty()) {
     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
         unknown_fields(), output);
@@ -5674,6 +5929,56 @@ void QueryProfile::SerializeWithCachedSizes(
         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);
+  }
+
   if (!unknown_fields().empty()) {
     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
         unknown_fields(), target);
@@ -5755,6 +6060,41 @@ int QueryProfile::ByteSize() const {
           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());
+    }
+
   }
   // repeated .exec.shared.MajorFragmentProfile fragment_profile = 11;
   total_size += 1 * this->fragment_profile_size();
@@ -5823,6 +6163,21 @@ void QueryProfile::MergeFrom(const QueryProfile& from) {
     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());
+    }
   }
   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 }
@@ -5857,6 +6212,11 @@ void QueryProfile::Swap(QueryProfile* other) {
     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(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
     std::swap(_cached_size_, other->_cached_size_);
@@ -6132,6 +6492,8 @@ 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()
@@ -6160,6 +6522,8 @@ void MinorFragmentProfile::SharedCtor() {
   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_));
 }
 
@@ -6211,6 +6575,8 @@ void MinorFragmentProfile::Clear() {
     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_));
@@ -6362,6 +6728,38 @@ bool MinorFragmentProfile::MergePartialFromCodedStream(
         } 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;
       }
@@ -6433,6 +6831,16 @@ void MinorFragmentProfile::SerializeWithCachedSizes(
       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);
@@ -6493,6 +6901,16 @@ void MinorFragmentProfile::SerializeWithCachedSizes(
         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);
@@ -6561,6 +6979,20 @@ int MinorFragmentProfile::ByteSize() const {
           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();
@@ -6623,6 +7055,12 @@ void MinorFragmentProfile::MergeFrom(const MinorFragmentProfile& from) {
     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());
 }
@@ -6655,6 +7093,8 @@ void MinorFragmentProfile::Swap(MinorFragmentProfile* other) {
     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_);

http://git-wip-us.apache.org/repos/asf/drill/blob/ffbb9c7a/contrib/native/client/src/protobuf/UserBitShared.pb.h
----------------------------------------------------------------------
diff --git a/contrib/native/client/src/protobuf/UserBitShared.pb.h b/contrib/native/client/src/protobuf/UserBitShared.pb.h
index e2f5fd0..b7073ff 100644
--- a/contrib/native/client/src/protobuf/UserBitShared.pb.h
+++ b/contrib/native/client/src/protobuf/UserBitShared.pb.h
@@ -58,6 +58,34 @@ class OperatorProfile;
 class StreamProfile;
 class MetricValue;
 
+enum DrillPBError_ErrorType {
+  DrillPBError_ErrorType_CONNECTION = 0,
+  DrillPBError_ErrorType_DATA_READ = 1,
+  DrillPBError_ErrorType_DATA_WRITE = 2,
+  DrillPBError_ErrorType_FUNCTION = 3,
+  DrillPBError_ErrorType_PARSE = 4,
+  DrillPBError_ErrorType_PERMISSION = 5,
+  DrillPBError_ErrorType_PLAN = 6,
+  DrillPBError_ErrorType_RESOURCE = 7,
+  DrillPBError_ErrorType_SYSTEM = 8,
+  DrillPBError_ErrorType_UNSUPPORTED_OPERATION = 9,
+  DrillPBError_ErrorType_VALIDATION = 10
+};
+bool DrillPBError_ErrorType_IsValid(int value);
+const DrillPBError_ErrorType DrillPBError_ErrorType_ErrorType_MIN = DrillPBError_ErrorType_CONNECTION;
+const DrillPBError_ErrorType DrillPBError_ErrorType_ErrorType_MAX = DrillPBError_ErrorType_VALIDATION;
+const int DrillPBError_ErrorType_ErrorType_ARRAYSIZE = DrillPBError_ErrorType_ErrorType_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* DrillPBError_ErrorType_descriptor();
+inline const ::std::string& DrillPBError_ErrorType_Name(DrillPBError_ErrorType value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    DrillPBError_ErrorType_descriptor(), value);
+}
+inline bool DrillPBError_ErrorType_Parse(
+    const ::std::string& name, DrillPBError_ErrorType* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<DrillPBError_ErrorType>(
+    DrillPBError_ErrorType_descriptor(), name, value);
+}
 enum NamePart_Type {
   NamePart_Type_NAME = 0,
   NamePart_Type_ARRAY = 1
@@ -146,11 +174,12 @@ enum FragmentState {
   RUNNING = 2,
   FINISHED = 3,
   CANCELLED = 4,
-  FAILED = 5
+  FAILED = 5,
+  CANCELLATION_REQUESTED = 6
 };
 bool FragmentState_IsValid(int value);
 const FragmentState FragmentState_MIN = SENDING;
-const FragmentState FragmentState_MAX = FAILED;
+const FragmentState FragmentState_MAX = CANCELLATION_REQUESTED;
 const int FragmentState_ARRAYSIZE = FragmentState_MAX + 1;
 
 const ::google::protobuf::EnumDescriptor* FragmentState_descriptor();
@@ -198,11 +227,13 @@ enum CoreOperatorType {
   COMPLEX_TO_JSON = 31,
   PRODUCER_CONSUMER = 32,
   HBASE_SUB_SCAN = 33,
-  WINDOW = 34
+  WINDOW = 34,
+  NESTED_LOOP_JOIN = 35,
+  AVRO_SUB_SCAN = 36
 };
 bool CoreOperatorType_IsValid(int value);
 const CoreOperatorType CoreOperatorType_MIN = SINGLE_SENDER;
-const CoreOperatorType CoreOperatorType_MAX = WINDOW;
+const CoreOperatorType CoreOperatorType_MAX = AVRO_SUB_SCAN;
 const int CoreOperatorType_ARRAYSIZE = CoreOperatorType_MAX + 1;
 
 const ::google::protobuf::EnumDescriptor* CoreOperatorType_descriptor();
@@ -448,6 +479,39 @@ class DrillPBError : public ::google::protobuf::Message {
 
   // nested types ----------------------------------------------------
 
+  typedef DrillPBError_ErrorType ErrorType;
+  static const ErrorType CONNECTION = DrillPBError_ErrorType_CONNECTION;
+  static const ErrorType DATA_READ = DrillPBError_ErrorType_DATA_READ;
+  static const ErrorType DATA_WRITE = DrillPBError_ErrorType_DATA_WRITE;
+  static const ErrorType FUNCTION = DrillPBError_ErrorType_FUNCTION;
+  static const ErrorType PARSE = DrillPBError_ErrorType_PARSE;
+  static const ErrorType PERMISSION = DrillPBError_ErrorType_PERMISSION;
+  static const ErrorType PLAN = DrillPBError_ErrorType_PLAN;
+  static const ErrorType RESOURCE = DrillPBError_ErrorType_RESOURCE;
+  static const ErrorType SYSTEM = DrillPBError_ErrorType_SYSTEM;
+  static const ErrorType UNSUPPORTED_OPERATION = DrillPBError_ErrorType_UNSUPPORTED_OPERATION;
+  static const ErrorType VALIDATION = DrillPBError_ErrorType_VALIDATION;
+  static inline bool ErrorType_IsValid(int value) {
+    return DrillPBError_ErrorType_IsValid(value);
+  }
+  static const ErrorType ErrorType_MIN =
+    DrillPBError_ErrorType_ErrorType_MIN;
+  static const ErrorType ErrorType_MAX =
+    DrillPBError_ErrorType_ErrorType_MAX;
+  static const int ErrorType_ARRAYSIZE =
+    DrillPBError_ErrorType_ErrorType_ARRAYSIZE;
+  static inline const ::google::protobuf::EnumDescriptor*
+  ErrorType_descriptor() {
+    return DrillPBError_ErrorType_descriptor();
+  }
+  static inline const ::std::string& ErrorType_Name(ErrorType value) {
+    return DrillPBError_ErrorType_Name(value);
+  }
+  static inline bool ErrorType_Parse(const ::std::string& name,
+      ErrorType* value) {
+    return DrillPBError_ErrorType_Parse(name, value);
+  }
+
   // accessors -------------------------------------------------------
 
   // optional string error_id = 1;
@@ -471,12 +535,12 @@ class DrillPBError : public ::google::protobuf::Message {
   inline ::exec::DrillbitEndpoint* release_endpoint();
   inline void set_allocated_endpoint(::exec::DrillbitEndpoint* endpoint);
 
-  // optional int32 error_type = 3;
+  // optional .exec.shared.DrillPBError.ErrorType error_type = 3;
   inline bool has_error_type() const;
   inline void clear_error_type();
   static const int kErrorTypeFieldNumber = 3;
-  inline ::google::protobuf::int32 error_type() const;
-  inline void set_error_type(::google::protobuf::int32 value);
+  inline ::exec::shared::DrillPBError_ErrorType error_type() const;
+  inline void set_error_type(::exec::shared::DrillPBError_ErrorType value);
 
   // optional string message = 4;
   inline bool has_message() const;
@@ -531,7 +595,7 @@ class DrillPBError : public ::google::protobuf::Message {
   ::std::string* message_;
   ::exec::shared::ExceptionWrapper* exception_;
   ::google::protobuf::RepeatedPtrField< ::exec::shared::ParsingError > parsing_error_;
-  ::google::protobuf::int32 error_type_;
+  int error_type_;
 
   mutable int _cached_size_;
   ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32];
@@ -1721,7 +1785,7 @@ class QueryInfo : public ::google::protobuf::Message {
   inline ::exec::shared::QueryResult_QueryState state() const;
   inline void set_state(::exec::shared::QueryResult_QueryState value);
 
-  // optional string user = 4;
+  // optional string user = 4 [default = "-"];
   inline bool has_user() const;
   inline void clear_user();
   static const int kUserFieldNumber = 4;
@@ -1760,6 +1824,7 @@ class QueryInfo : public ::google::protobuf::Message {
   ::std::string* query_;
   ::google::protobuf::int64 start_;
   ::std::string* user_;
+  static ::std::string* _default_user_;
   ::exec::DrillbitEndpoint* foreman_;
   int state_;
 
@@ -1925,6 +1990,66 @@ class QueryProfile : public ::google::protobuf::Message {
   inline ::google::protobuf::RepeatedPtrField< ::exec::shared::MajorFragmentProfile >*
       mutable_fragment_profile();
 
+  // optional string user = 12 [default = "-"];
+  inline bool has_user() const;
+  inline void clear_user();
+  static const int kUserFieldNumber = 12;
+  inline const ::std::string& user() const;
+  inline void set_user(const ::std::string& value);
+  inline void set_user(const char* value);
+  inline void set_user(const char* value, size_t size);
+  inline ::std::string* mutable_user();
+  inline ::std::string* release_user();
+  inline void set_allocated_user(::std::string* user);
+
+  // optional string error = 13;
+  inline bool has_error() const;
+  inline void clear_error();
+  static const int kErrorFieldNumber = 13;
+  inline const ::std::string& error() const;
+  inline void set_error(const ::std::string& value);
+  inline void set_error(const char* value);
+  inline void set_error(const char* value, size_t size);
+  inline ::std::string* mutable_error();
+  inline ::std::string* release_error();
+  inline void set_allocated_error(::std::string* error);
+
+  // optional string verboseError = 14;
+  inline bool has_verboseerror() const;
+  inline void clear_verboseerror();
+  static const int kVerboseErrorFieldNumber = 14;
+  inline const ::std::string& verboseerror() const;
+  inline void set_verboseerror(const ::std::string& value);
+  inline void set_verboseerror(const char* value);
+  inline void set_verboseerror(const char* value, size_t size);
+  inline ::std::string* mutable_verboseerror();
+  inline ::std::string* release_verboseerror();
+  inline void set_allocated_verboseerror(::std::string* verboseerror);
+
+  // optional string error_id = 15;
+  inline bool has_error_id() const;
+  inline void clear_error_id();
+  static const int kErrorIdFieldNumber = 15;
+  inline const ::std::string& error_id() const;
+  inline void set_error_id(const ::std::string& value);
+  inline void set_error_id(const char* value);
+  inline void set_error_id(const char* value, size_t size);
+  inline ::std::string* mutable_error_id();
+  inline ::std::string* release_error_id();
+  inline void set_allocated_error_id(::std::string* error_id);
+
+  // optional string error_node = 16;
+  inline bool has_error_node() const;
+  inline void clear_error_node();
+  static const int kErrorNodeFieldNumber = 16;
+  inline const ::std::string& error_node() const;
+  inline void set_error_node(const ::std::string& value);
+  inline void set_error_node(const char* value);
+  inline void set_error_node(const char* value, size_t size);
+  inline ::std::string* mutable_error_node();
+  inline ::std::string* release_error_node();
+  inline void set_allocated_error_node(::std::string* error_node);
+
   // @@protoc_insertion_point(class_scope:exec.shared.QueryProfile)
  private:
   inline void set_has_id();
@@ -1947,6 +2072,16 @@ class QueryProfile : public ::google::protobuf::Message {
   inline void clear_has_total_fragments();
   inline void set_has_finished_fragments();
   inline void clear_has_finished_fragments();
+  inline void set_has_user();
+  inline void clear_has_user();
+  inline void set_has_error();
+  inline void clear_has_error();
+  inline void set_has_verboseerror();
+  inline void clear_has_verboseerror();
+  inline void set_has_error_id();
+  inline void clear_has_error_id();
+  inline void set_has_error_node();
+  inline void clear_has_error_node();
 
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
@@ -1961,9 +2096,15 @@ class QueryProfile : public ::google::protobuf::Message {
   ::google::protobuf::int32 total_fragments_;
   ::google::protobuf::int32 finished_fragments_;
   ::google::protobuf::RepeatedPtrField< ::exec::shared::MajorFragmentProfile > fragment_profile_;
+  ::std::string* user_;
+  static ::std::string* _default_user_;
+  ::std::string* error_;
+  ::std::string* verboseerror_;
+  ::std::string* error_id_;
+  ::std::string* error_node_;
 
   mutable int _cached_size_;
-  ::google::protobuf::uint32 _has_bits_[(11 + 31) / 32];
+  ::google::protobuf::uint32 _has_bits_[(16 + 31) / 32];
 
   friend void  protobuf_AddDesc_UserBitShared_2eproto();
   friend void protobuf_AssignDesc_UserBitShared_2eproto();
@@ -2195,6 +2336,20 @@ class MinorFragmentProfile : public ::google::protobuf::Message {
   inline ::exec::DrillbitEndpoint* release_endpoint();
   inline void set_allocated_endpoint(::exec::DrillbitEndpoint* endpoint);
 
+  // optional int64 last_update = 10;
+  inline bool has_last_update() const;
+  inline void clear_last_update();
+  static const int kLastUpdateFieldNumber = 10;
+  inline ::google::protobuf::int64 last_update() const;
+  inline void set_last_update(::google::protobuf::int64 value);
+
+  // optional int64 last_progress = 11;
+  inline bool has_last_progress() const;
+  inline void clear_last_progress();
+  static const int kLastProgressFieldNumber = 11;
+  inline ::google::protobuf::int64 last_progress() const;
+  inline void set_last_progress(::google::protobuf::int64 value);
+
   // @@protoc_insertion_point(class_scope:exec.shared.MinorFragmentProfile)
  private:
   inline void set_has_state();
@@ -2213,6 +2368,10 @@ class MinorFragmentProfile : public ::google::protobuf::Message {
   inline void clear_has_max_memory_used();
   inline void set_has_endpoint();
   inline void clear_has_endpoint();
+  inline void set_has_last_update();
+  inline void clear_has_last_update();
+  inline void set_has_last_progress();
+  inline void clear_has_last_progress();
 
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
@@ -2225,9 +2384,11 @@ class MinorFragmentProfile : public ::google::protobuf::Message {
   ::google::protobuf::int64 memory_used_;
   ::google::protobuf::int64 max_memory_used_;
   ::exec::DrillbitEndpoint* endpoint_;
+  ::google::protobuf::int64 last_update_;
+  ::google::protobuf::int64 last_progress_;
 
   mutable int _cached_size_;
-  ::google::protobuf::uint32 _has_bits_[(9 + 31) / 32];
+  ::google::protobuf::uint32 _has_bits_[(11 + 31) / 32];
 
   friend void  protobuf_AddDesc_UserBitShared_2eproto();
   friend void protobuf_AssignDesc_UserBitShared_2eproto();
@@ -2835,7 +2996,7 @@ inline void DrillPBError::set_allocated_endpoint(::exec::DrillbitEndpoint* endpo
   }
 }
 
-// optional int32 error_type = 3;
+// optional .exec.shared.DrillPBError.ErrorType error_type = 3;
 inline bool DrillPBError::has_error_type() const {
   return (_has_bits_[0] & 0x00000004u) != 0;
 }
@@ -2849,10 +3010,11 @@ inline void DrillPBError::clear_error_type() {
   error_type_ = 0;
   clear_has_error_type();
 }
-inline ::google::protobuf::int32 DrillPBError::error_type() const {
-  return error_type_;
+inline ::exec::shared::DrillPBError_ErrorType DrillPBError::error_type() const {
+  return static_cast< ::exec::shared::DrillPBError_ErrorType >(error_type_);
 }
-inline void DrillPBError::set_error_type(::google::protobuf::int32 value) {
+inline void DrillPBError::set_error_type(::exec::shared::DrillPBError_ErrorType value) {
+  assert(::exec::shared::DrillPBError_ErrorType_IsValid(value));
   set_has_error_type();
   error_type_ = value;
 }
@@ -4307,7 +4469,7 @@ inline void QueryInfo::set_state(::exec::shared::QueryResult_QueryState value) {
   state_ = value;
 }
 
-// optional string user = 4;
+// optional string user = 4 [default = "-"];
 inline bool QueryInfo::has_user() const {
   return (_has_bits_[0] & 0x00000008u) != 0;
 }
@@ -4318,8 +4480,8 @@ inline void QueryInfo::clear_has_user() {
   _has_bits_[0] &= ~0x00000008u;
 }
 inline void QueryInfo::clear_user() {
-  if (user_ != &::google::protobuf::internal::kEmptyString) {
-    user_->clear();
+  if (user_ != _default_user_) {
+    user_->assign(*_default_user_);
   }
   clear_has_user();
 }
@@ -4328,44 +4490,44 @@ inline const ::std::string& QueryInfo::user() const {
 }
 inline void QueryInfo::set_user(const ::std::string& value) {
   set_has_user();
-  if (user_ == &::google::protobuf::internal::kEmptyString) {
+  if (user_ == _default_user_) {
     user_ = new ::std::string;
   }
   user_->assign(value);
 }
 inline void QueryInfo::set_user(const char* value) {
   set_has_user();
-  if (user_ == &::google::protobuf::internal::kEmptyString) {
+  if (user_ == _default_user_) {
     user_ = new ::std::string;
   }
   user_->assign(value);
 }
 inline void QueryInfo::set_user(const char* value, size_t size) {
   set_has_user();
-  if (user_ == &::google::protobuf::internal::kEmptyString) {
+  if (user_ == _default_user_) {
     user_ = new ::std::string;
   }
   user_->assign(reinterpret_cast<const char*>(value), size);
 }
 inline ::std::string* QueryInfo::mutable_user() {
   set_has_user();
-  if (user_ == &::google::protobuf::internal::kEmptyString) {
-    user_ = new ::std::string;
+  if (user_ == _default_user_) {
+    user_ = new ::std::string(*_default_user_);
   }
   return user_;
 }
 inline ::std::string* QueryInfo::release_user() {
   clear_has_user();
-  if (user_ == &::google::protobuf::internal::kEmptyString) {
+  if (user_ == _default_user_) {
     return NULL;
   } else {
     ::std::string* temp = user_;
-    user_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    user_ = const_cast< ::std::string*>(_default_user_);
     return temp;
   }
 }
 inline void QueryInfo::set_allocated_user(::std::string* user) {
-  if (user_ != &::google::protobuf::internal::kEmptyString) {
+  if (user_ != _default_user_) {
     delete user_;
   }
   if (user) {
@@ -4373,7 +4535,7 @@ inline void QueryInfo::set_allocated_user(::std::string* user) {
     user_ = user;
   } else {
     clear_has_user();
-    user_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    user_ = const_cast< ::std::string*>(_default_user_);
   }
 }
 
@@ -4794,6 +4956,356 @@ QueryProfile::mutable_fragment_profile() {
   return &fragment_profile_;
 }
 
+// optional string user = 12 [default = "-"];
+inline bool QueryProfile::has_user() const {
+  return (_has_bits_[0] & 0x00000800u) != 0;
+}
+inline void QueryProfile::set_has_user() {
+  _has_bits_[0] |= 0x00000800u;
+}
+inline void QueryProfile::clear_has_user() {
+  _has_bits_[0] &= ~0x00000800u;
+}
+inline void QueryProfile::clear_user() {
+  if (user_ != _default_user_) {
+    user_->assign(*_default_user_);
+  }
+  clear_has_user();
+}
+inline const ::std::string& QueryProfile::user() const {
+  return *user_;
+}
+inline void QueryProfile::set_user(const ::std::string& value) {
+  set_has_user();
+  if (user_ == _default_user_) {
+    user_ = new ::std::string;
+  }
+  user_->assign(value);
+}
+inline void QueryProfile::set_user(const char* value) {
+  set_has_user();
+  if (user_ == _default_user_) {
+    user_ = new ::std::string;
+  }
+  user_->assign(value);
+}
+inline void QueryProfile::set_user(const char* value, size_t size) {
+  set_has_user();
+  if (user_ == _default_user_) {
+    user_ = new ::std::string;
+  }
+  user_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* QueryProfile::mutable_user() {
+  set_has_user();
+  if (user_ == _default_user_) {
+    user_ = new ::std::string(*_default_user_);
+  }
+  return user_;
+}
+inline ::std::string* QueryProfile::release_user() {
+  clear_has_user();
+  if (user_ == _default_user_) {
+    return NULL;
+  } else {
+    ::std::string* temp = user_;
+    user_ = const_cast< ::std::string*>(_default_user_);
+    return temp;
+  }
+}
+inline void QueryProfile::set_allocated_user(::std::string* user) {
+  if (user_ != _default_user_) {
+    delete user_;
+  }
+  if (user) {
+    set_has_user();
+    user_ = user;
+  } else {
+    clear_has_user();
+    user_ = const_cast< ::std::string*>(_default_user_);
+  }
+}
+
+// optional string error = 13;
+inline bool QueryProfile::has_error() const {
+  return (_has_bits_[0] & 0x00001000u) != 0;
+}
+inline void QueryProfile::set_has_error() {
+  _has_bits_[0] |= 0x00001000u;
+}
+inline void QueryProfile::clear_has_error() {
+  _has_bits_[0] &= ~0x00001000u;
+}
+inline void QueryProfile::clear_error() {
+  if (error_ != &::google::protobuf::internal::kEmptyString) {
+    error_->clear();
+  }
+  clear_has_error();
+}
+inline const ::std::string& QueryProfile::error() const {
+  return *error_;
+}
+inline void QueryProfile::set_error(const ::std::string& value) {
+  set_has_error();
+  if (error_ == &::google::protobuf::internal::kEmptyString) {
+    error_ = new ::std::string;
+  }
+  error_->assign(value);
+}
+inline void QueryProfile::set_error(const char* value) {
+  set_has_error();
+  if (error_ == &::google::protobuf::internal::kEmptyString) {
+    error_ = new ::std::string;
+  }
+  error_->assign(value);
+}
+inline void QueryProfile::set_error(const char* value, size_t size) {
+  set_has_error();
+  if (error_ == &::google::protobuf::internal::kEmptyString) {
+    error_ = new ::std::string;
+  }
+  error_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* QueryProfile::mutable_error() {
+  set_has_error();
+  if (error_ == &::google::protobuf::internal::kEmptyString) {
+    error_ = new ::std::string;
+  }
+  return error_;
+}
+inline ::std::string* QueryProfile::release_error() {
+  clear_has_error();
+  if (error_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = error_;
+    error_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void QueryProfile::set_allocated_error(::std::string* error) {
+  if (error_ != &::google::protobuf::internal::kEmptyString) {
+    delete error_;
+  }
+  if (error) {
+    set_has_error();
+    error_ = error;
+  } else {
+    clear_has_error();
+    error_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// optional string verboseError = 14;
+inline bool QueryProfile::has_verboseerror() const {
+  return (_has_bits_[0] & 0x00002000u) != 0;
+}
+inline void QueryProfile::set_has_verboseerror() {
+  _has_bits_[0] |= 0x00002000u;
+}
+inline void QueryProfile::clear_has_verboseerror() {
+  _has_bits_[0] &= ~0x00002000u;
+}
+inline void QueryProfile::clear_verboseerror() {
+  if (verboseerror_ != &::google::protobuf::internal::kEmptyString) {
+    verboseerror_->clear();
+  }
+  clear_has_verboseerror();
+}
+inline const ::std::string& QueryProfile::verboseerror() const {
+  return *verboseerror_;
+}
+inline void QueryProfile::set_verboseerror(const ::std::string& value) {
+  set_has_verboseerror();
+  if (verboseerror_ == &::google::protobuf::internal::kEmptyString) {
+    verboseerror_ = new ::std::string;
+  }
+  verboseerror_->assign(value);
+}
+inline void QueryProfile::set_verboseerror(const char* value) {
+  set_has_verboseerror();
+  if (verboseerror_ == &::google::protobuf::internal::kEmptyString) {
+    verboseerror_ = new ::std::string;
+  }
+  verboseerror_->assign(value);
+}
+inline void QueryProfile::set_verboseerror(const char* value, size_t size) {
+  set_has_verboseerror();
+  if (verboseerror_ == &::google::protobuf::internal::kEmptyString) {
+    verboseerror_ = new ::std::string;
+  }
+  verboseerror_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* QueryProfile::mutable_verboseerror() {
+  set_has_verboseerror();
+  if (verboseerror_ == &::google::protobuf::internal::kEmptyString) {
+    verboseerror_ = new ::std::string;
+  }
+  return verboseerror_;
+}
+inline ::std::string* QueryProfile::release_verboseerror() {
+  clear_has_verboseerror();
+  if (verboseerror_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = verboseerror_;
+    verboseerror_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void QueryProfile::set_allocated_verboseerror(::std::string* verboseerror) {
+  if (verboseerror_ != &::google::protobuf::internal::kEmptyString) {
+    delete verboseerror_;
+  }
+  if (verboseerror) {
+    set_has_verboseerror();
+    verboseerror_ = verboseerror;
+  } else {
+    clear_has_verboseerror();
+    verboseerror_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// optional string error_id = 15;
+inline bool QueryProfile::has_error_id() const {
+  return (_has_bits_[0] & 0x00004000u) != 0;
+}
+inline void QueryProfile::set_has_error_id() {
+  _has_bits_[0] |= 0x00004000u;
+}
+inline void QueryProfile::clear_has_error_id() {
+  _has_bits_[0] &= ~0x00004000u;
+}
+inline void QueryProfile::clear_error_id() {
+  if (error_id_ != &::google::protobuf::internal::kEmptyString) {
+    error_id_->clear();
+  }
+  clear_has_error_id();
+}
+inline const ::std::string& QueryProfile::error_id() const {
+  return *error_id_;
+}
+inline void QueryProfile::set_error_id(const ::std::string& value) {
+  set_has_error_id();
+  if (error_id_ == &::google::protobuf::internal::kEmptyString) {
+    error_id_ = new ::std::string;
+  }
+  error_id_->assign(value);
+}
+inline void QueryProfile::set_error_id(const char* value) {
+  set_has_error_id();
+  if (error_id_ == &::google::protobuf::internal::kEmptyString) {
+    error_id_ = new ::std::string;
+  }
+  error_id_->assign(value);
+}
+inline void QueryProfile::set_error_id(const char* value, size_t size) {
+  set_has_error_id();
+  if (error_id_ == &::google::protobuf::internal::kEmptyString) {
+    error_id_ = new ::std::string;
+  }
+  error_id_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* QueryProfile::mutable_error_id() {
+  set_has_error_id();
+  if (error_id_ == &::google::protobuf::internal::kEmptyString) {
+    error_id_ = new ::std::string;
+  }
+  return error_id_;
+}
+inline ::std::string* QueryProfile::release_error_id() {
+  clear_has_error_id();
+  if (error_id_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = error_id_;
+    error_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void QueryProfile::set_allocated_error_id(::std::string* error_id) {
+  if (error_id_ != &::google::protobuf::internal::kEmptyString) {
+    delete error_id_;
+  }
+  if (error_id) {
+    set_has_error_id();
+    error_id_ = error_id;
+  } else {
+    clear_has_error_id();
+    error_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// optional string error_node = 16;
+inline bool QueryProfile::has_error_node() const {
+  return (_has_bits_[0] & 0x00008000u) != 0;
+}
+inline void QueryProfile::set_has_error_node() {
+  _has_bits_[0] |= 0x00008000u;
+}
+inline void QueryProfile::clear_has_error_node() {
+  _has_bits_[0] &= ~0x00008000u;
+}
+inline void QueryProfile::clear_error_node() {
+  if (error_node_ != &::google::protobuf::internal::kEmptyString) {
+    error_node_->clear();
+  }
+  clear_has_error_node();
+}
+inline const ::std::string& QueryProfile::error_node() const {
+  return *error_node_;
+}
+inline void QueryProfile::set_error_node(const ::std::string& value) {
+  set_has_error_node();
+  if (error_node_ == &::google::protobuf::internal::kEmptyString) {
+    error_node_ = new ::std::string;
+  }
+  error_node_->assign(value);
+}
+inline void QueryProfile::set_error_node(const char* value) {
+  set_has_error_node();
+  if (error_node_ == &::google::protobuf::internal::kEmptyString) {
+    error_node_ = new ::std::string;
+  }
+  error_node_->assign(value);
+}
+inline void QueryProfile::set_error_node(const char* value, size_t size) {
+  set_has_error_node();
+  if (error_node_ == &::google::protobuf::internal::kEmptyString) {
+    error_node_ = new ::std::string;
+  }
+  error_node_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* QueryProfile::mutable_error_node() {
+  set_has_error_node();
+  if (error_node_ == &::google::protobuf::internal::kEmptyString) {
+    error_node_ = new ::std::string;
+  }
+  return error_node_;
+}
+inline ::std::string* QueryProfile::release_error_node() {
+  clear_has_error_node();
+  if (error_node_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = error_node_;
+    error_node_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void QueryProfile::set_allocated_error_node(::std::string* error_node) {
+  if (error_node_ != &::google::protobuf::internal::kEmptyString) {
+    delete error_node_;
+  }
+  if (error_node) {
+    set_has_error_node();
+    error_node_ = error_node;
+  } else {
+    clear_has_error_node();
+    error_node_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
 // -------------------------------------------------------------------
 
 // MajorFragmentProfile
@@ -5083,6 +5595,50 @@ inline void MinorFragmentProfile::set_allocated_endpoint(::exec::DrillbitEndpoin
   }
 }
 
+// optional int64 last_update = 10;
+inline bool MinorFragmentProfile::has_last_update() const {
+  return (_has_bits_[0] & 0x00000200u) != 0;
+}
+inline void MinorFragmentProfile::set_has_last_update() {
+  _has_bits_[0] |= 0x00000200u;
+}
+inline void MinorFragmentProfile::clear_has_last_update() {
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline void MinorFragmentProfile::clear_last_update() {
+  last_update_ = GOOGLE_LONGLONG(0);
+  clear_has_last_update();
+}
+inline ::google::protobuf::int64 MinorFragmentProfile::last_update() const {
+  return last_update_;
+}
+inline void MinorFragmentProfile::set_last_update(::google::protobuf::int64 value) {
+  set_has_last_update();
+  last_update_ = value;
+}
+
+// optional int64 last_progress = 11;
+inline bool MinorFragmentProfile::has_last_progress() const {
+  return (_has_bits_[0] & 0x00000400u) != 0;
+}
+inline void MinorFragmentProfile::set_has_last_progress() {
+  _has_bits_[0] |= 0x00000400u;
+}
+inline void MinorFragmentProfile::clear_has_last_progress() {
+  _has_bits_[0] &= ~0x00000400u;
+}
+inline void MinorFragmentProfile::clear_last_progress() {
+  last_progress_ = GOOGLE_LONGLONG(0);
+  clear_has_last_progress();
+}
+inline ::google::protobuf::int64 MinorFragmentProfile::last_progress() const {
+  return last_progress_;
+}
+inline void MinorFragmentProfile::set_last_progress(::google::protobuf::int64 value) {
+  set_has_last_progress();
+  last_progress_ = value;
+}
+
 // -------------------------------------------------------------------
 
 // OperatorProfile
@@ -5420,6 +5976,10 @@ namespace google {
 namespace protobuf {
 
 template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::exec::shared::DrillPBError_ErrorType>() {
+  return ::exec::shared::DrillPBError_ErrorType_descriptor();
+}
+template <>
 inline const EnumDescriptor* GetEnumDescriptor< ::exec::shared::NamePart_Type>() {
   return ::exec::shared::NamePart_Type_descriptor();
 }


Mime
View raw message