diff options
Diffstat (limited to 'contrib/native/client/src/protobuf/UserBitShared.pb.h')
| -rw-r--r-- | contrib/native/client/src/protobuf/UserBitShared.pb.h | 614 |
1 files changed, 587 insertions, 27 deletions
diff --git a/contrib/native/client/src/protobuf/UserBitShared.pb.h b/contrib/native/client/src/protobuf/UserBitShared.pb.h index e2f5fd0fa..b7073ff90 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(); } |