path: root/contrib/native/client/src/include/drill/protobuf/User.pb.h

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

#ifndef PROTOBUF_User_2eproto__INCLUDED
#define PROTOBUF_User_2eproto__INCLUDED

#include <string>

#include <google/protobuf/stubs/common.h>

#if GOOGLE_PROTOBUF_VERSION < 2005000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please update
#error your headers.
#endif
#if 2005000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include "SchemaDef.pb.h"
#include "UserBitShared.pb.h"
// @@protoc_insertion_point(includes)

namespace exec {
namespace user {

// Internal implementation detail -- do not call these.
void  protobuf_AddDesc_User_2eproto();
void protobuf_AssignDesc_User_2eproto();
void protobuf_ShutdownFile_User_2eproto();

class Property;
class UserProperties;
class UserToBitHandshake;
class RequestResults;
class RunQuery;
class BitToUserHandshake;
class NodeStatus;
class QueryResult;

enum QueryResult_QueryState {
  QueryResult_QueryState_PENDING = 0,
  QueryResult_QueryState_RUNNING = 1,
  QueryResult_QueryState_COMPLETED = 2,
  QueryResult_QueryState_CANCELED = 3,
  QueryResult_QueryState_FAILED = 4,
  QueryResult_QueryState_UNKNOWN_QUERY = 5
};
bool QueryResult_QueryState_IsValid(int value);
const QueryResult_QueryState QueryResult_QueryState_QueryState_MIN = QueryResult_QueryState_PENDING;
const QueryResult_QueryState QueryResult_QueryState_QueryState_MAX = QueryResult_QueryState_UNKNOWN_QUERY;
const int QueryResult_QueryState_QueryState_ARRAYSIZE = QueryResult_QueryState_QueryState_MAX + 1;

const ::google::protobuf::EnumDescriptor* QueryResult_QueryState_descriptor();
inline const ::std::string& QueryResult_QueryState_Name(QueryResult_QueryState value) {
  return ::google::protobuf::internal::NameOfEnum(
    QueryResult_QueryState_descriptor(), value);
}
inline bool QueryResult_QueryState_Parse(
    const ::std::string& name, QueryResult_QueryState* value) {
  return ::google::protobuf::internal::ParseNamedEnum<QueryResult_QueryState>(
    QueryResult_QueryState_descriptor(), name, value);
}
enum RpcType {
  HANDSHAKE = 0,
  ACK = 1,
  GOODBYE = 2,
  RUN_QUERY = 3,
  CANCEL_QUERY = 4,
  REQUEST_RESULTS = 5,
  QUERY_RESULT = 6,
  QUERY_HANDLE = 7,
  REQ_META_FUNCTIONS = 8,
  RESP_FUNCTION_LIST = 9
};
bool RpcType_IsValid(int value);
const RpcType RpcType_MIN = HANDSHAKE;
const RpcType RpcType_MAX = RESP_FUNCTION_LIST;
const int RpcType_ARRAYSIZE = RpcType_MAX + 1;

const ::google::protobuf::EnumDescriptor* RpcType_descriptor();
inline const ::std::string& RpcType_Name(RpcType value) {
  return ::google::protobuf::internal::NameOfEnum(
    RpcType_descriptor(), value);
}
inline bool RpcType_Parse(
    const ::std::string& name, RpcType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<RpcType>(
    RpcType_descriptor(), name, value);
}
enum QueryType {
  SQL = 1,
  LOGICAL = 2,
  PHYSICAL = 3
};
bool QueryType_IsValid(int value);
const QueryType QueryType_MIN = SQL;
const QueryType QueryType_MAX = PHYSICAL;
const int QueryType_ARRAYSIZE = QueryType_MAX + 1;

const ::google::protobuf::EnumDescriptor* QueryType_descriptor();
inline const ::std::string& QueryType_Name(QueryType value) {
  return ::google::protobuf::internal::NameOfEnum(
    QueryType_descriptor(), value);
}
inline bool QueryType_Parse(
    const ::std::string& name, QueryType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<QueryType>(
    QueryType_descriptor(), name, value);
}
enum QueryResultsMode {
  STREAM_FULL = 1
};
bool QueryResultsMode_IsValid(int value);
const QueryResultsMode QueryResultsMode_MIN = STREAM_FULL;
const QueryResultsMode QueryResultsMode_MAX = STREAM_FULL;
const int QueryResultsMode_ARRAYSIZE = QueryResultsMode_MAX + 1;

const ::google::protobuf::EnumDescriptor* QueryResultsMode_descriptor();
inline const ::std::string& QueryResultsMode_Name(QueryResultsMode value) {
  return ::google::protobuf::internal::NameOfEnum(
    QueryResultsMode_descriptor(), value);
}
inline bool QueryResultsMode_Parse(
    const ::std::string& name, QueryResultsMode* value) {
  return ::google::protobuf::internal::ParseNamedEnum<QueryResultsMode>(
    QueryResultsMode_descriptor(), name, value);
}
// ===================================================================

class Property : public ::google::protobuf::Message {
 public:
  Property();
  virtual ~Property();

  Property(const Property& from);

  inline Property& operator=(const Property& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const Property& default_instance();

  void Swap(Property* other);

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

  Property* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Property& from);
  void MergeFrom(const Property& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required string key = 1;
  inline bool has_key() const;
  inline void clear_key();
  static const int kKeyFieldNumber = 1;
  inline const ::std::string& key() const;
  inline void set_key(const ::std::string& value);
  inline void set_key(const char* value);
  inline void set_key(const char* value, size_t size);
  inline ::std::string* mutable_key();
  inline ::std::string* release_key();
  inline void set_allocated_key(::std::string* key);

  // required string value = 2;
  inline bool has_value() const;
  inline void clear_value();
  static const int kValueFieldNumber = 2;
  inline const ::std::string& value() const;
  inline void set_value(const ::std::string& value);
  inline void set_value(const char* value);
  inline void set_value(const char* value, size_t size);
  inline ::std::string* mutable_value();
  inline ::std::string* release_value();
  inline void set_allocated_value(::std::string* value);

  // @@protoc_insertion_point(class_scope:exec.user.Property)
 private:
  inline void set_has_key();
  inline void clear_has_key();
  inline void set_has_value();
  inline void clear_has_value();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* key_;
  ::std::string* value_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static Property* default_instance_;
};
// -------------------------------------------------------------------

class UserProperties : public ::google::protobuf::Message {
 public:
  UserProperties();
  virtual ~UserProperties();

  UserProperties(const UserProperties& from);

  inline UserProperties& operator=(const UserProperties& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const UserProperties& default_instance();

  void Swap(UserProperties* other);

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

  UserProperties* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const UserProperties& from);
  void MergeFrom(const UserProperties& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated .exec.user.Property properties = 1;
  inline int properties_size() const;
  inline void clear_properties();
  static const int kPropertiesFieldNumber = 1;
  inline const ::exec::user::Property& properties(int index) const;
  inline ::exec::user::Property* mutable_properties(int index);
  inline ::exec::user::Property* add_properties();
  inline const ::google::protobuf::RepeatedPtrField< ::exec::user::Property >&
      properties() const;
  inline ::google::protobuf::RepeatedPtrField< ::exec::user::Property >*
      mutable_properties();

  // @@protoc_insertion_point(class_scope:exec.user.UserProperties)
 private:

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::RepeatedPtrField< ::exec::user::Property > properties_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static UserProperties* default_instance_;
};
// -------------------------------------------------------------------

class UserToBitHandshake : public ::google::protobuf::Message {
 public:
  UserToBitHandshake();
  virtual ~UserToBitHandshake();

  UserToBitHandshake(const UserToBitHandshake& from);

  inline UserToBitHandshake& operator=(const UserToBitHandshake& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const UserToBitHandshake& default_instance();

  void Swap(UserToBitHandshake* other);

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

  UserToBitHandshake* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const UserToBitHandshake& from);
  void MergeFrom(const UserToBitHandshake& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .exec.shared.RpcChannel channel = 1 [default = USER];
  inline bool has_channel() const;
  inline void clear_channel();
  static const int kChannelFieldNumber = 1;
  inline ::exec::shared::RpcChannel channel() const;
  inline void set_channel(::exec::shared::RpcChannel value);

  // optional bool support_listening = 2;
  inline bool has_support_listening() const;
  inline void clear_support_listening();
  static const int kSupportListeningFieldNumber = 2;
  inline bool support_listening() const;
  inline void set_support_listening(bool value);

  // optional int32 rpc_version = 3;
  inline bool has_rpc_version() const;
  inline void clear_rpc_version();
  static const int kRpcVersionFieldNumber = 3;
  inline ::google::protobuf::int32 rpc_version() const;
  inline void set_rpc_version(::google::protobuf::int32 value);

  // optional .exec.shared.UserCredentials credentials = 4;
  inline bool has_credentials() const;
  inline void clear_credentials();
  static const int kCredentialsFieldNumber = 4;
  inline const ::exec::shared::UserCredentials& credentials() const;
  inline ::exec::shared::UserCredentials* mutable_credentials();
  inline ::exec::shared::UserCredentials* release_credentials();
  inline void set_allocated_credentials(::exec::shared::UserCredentials* credentials);

  // optional .exec.user.UserProperties properties = 5;
  inline bool has_properties() const;
  inline void clear_properties();
  static const int kPropertiesFieldNumber = 5;
  inline const ::exec::user::UserProperties& properties() const;
  inline ::exec::user::UserProperties* mutable_properties();
  inline ::exec::user::UserProperties* release_properties();
  inline void set_allocated_properties(::exec::user::UserProperties* properties);

  // @@protoc_insertion_point(class_scope:exec.user.UserToBitHandshake)
 private:
  inline void set_has_channel();
  inline void clear_has_channel();
  inline void set_has_support_listening();
  inline void clear_has_support_listening();
  inline void set_has_rpc_version();
  inline void clear_has_rpc_version();
  inline void set_has_credentials();
  inline void clear_has_credentials();
  inline void set_has_properties();
  inline void clear_has_properties();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  int channel_;
  bool support_listening_;
  ::exec::shared::UserCredentials* credentials_;
  ::exec::user::UserProperties* properties_;
  ::google::protobuf::int32 rpc_version_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static UserToBitHandshake* default_instance_;
};
// -------------------------------------------------------------------

class RequestResults : public ::google::protobuf::Message {
 public:
  RequestResults();
  virtual ~RequestResults();

  RequestResults(const RequestResults& from);

  inline RequestResults& operator=(const RequestResults& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const RequestResults& default_instance();

  void Swap(RequestResults* other);

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

  RequestResults* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const RequestResults& from);
  void MergeFrom(const RequestResults& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .exec.shared.QueryId query_id = 1;
  inline bool has_query_id() const;
  inline void clear_query_id();
  static const int kQueryIdFieldNumber = 1;
  inline const ::exec::shared::QueryId& query_id() const;
  inline ::exec::shared::QueryId* mutable_query_id();
  inline ::exec::shared::QueryId* release_query_id();
  inline void set_allocated_query_id(::exec::shared::QueryId* query_id);

  // optional int32 maximum_responses = 2;
  inline bool has_maximum_responses() const;
  inline void clear_maximum_responses();
  static const int kMaximumResponsesFieldNumber = 2;
  inline ::google::protobuf::int32 maximum_responses() const;
  inline void set_maximum_responses(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:exec.user.RequestResults)
 private:
  inline void set_has_query_id();
  inline void clear_has_query_id();
  inline void set_has_maximum_responses();
  inline void clear_has_maximum_responses();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::exec::shared::QueryId* query_id_;
  ::google::protobuf::int32 maximum_responses_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static RequestResults* default_instance_;
};
// -------------------------------------------------------------------

class RunQuery : public ::google::protobuf::Message {
 public:
  RunQuery();
  virtual ~RunQuery();

  RunQuery(const RunQuery& from);

  inline RunQuery& operator=(const RunQuery& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const RunQuery& default_instance();

  void Swap(RunQuery* other);

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

  RunQuery* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const RunQuery& from);
  void MergeFrom(const RunQuery& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .exec.user.QueryResultsMode results_mode = 1;
  inline bool has_results_mode() const;
  inline void clear_results_mode();
  static const int kResultsModeFieldNumber = 1;
  inline ::exec::user::QueryResultsMode results_mode() const;
  inline void set_results_mode(::exec::user::QueryResultsMode value);

  // optional .exec.user.QueryType type = 2;
  inline bool has_type() const;
  inline void clear_type();
  static const int kTypeFieldNumber = 2;
  inline ::exec::user::QueryType type() const;
  inline void set_type(::exec::user::QueryType value);

  // optional string plan = 3;
  inline bool has_plan() const;
  inline void clear_plan();
  static const int kPlanFieldNumber = 3;
  inline const ::std::string& plan() const;
  inline void set_plan(const ::std::string& value);
  inline void set_plan(const char* value);
  inline void set_plan(const char* value, size_t size);
  inline ::std::string* mutable_plan();
  inline ::std::string* release_plan();
  inline void set_allocated_plan(::std::string* plan);

  // @@protoc_insertion_point(class_scope:exec.user.RunQuery)
 private:
  inline void set_has_results_mode();
  inline void clear_has_results_mode();
  inline void set_has_type();
  inline void clear_has_type();
  inline void set_has_plan();
  inline void clear_has_plan();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  int results_mode_;
  int type_;
  ::std::string* plan_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static RunQuery* default_instance_;
};
// -------------------------------------------------------------------

class BitToUserHandshake : public ::google::protobuf::Message {
 public:
  BitToUserHandshake();
  virtual ~BitToUserHandshake();

  BitToUserHandshake(const BitToUserHandshake& from);

  inline BitToUserHandshake& operator=(const BitToUserHandshake& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const BitToUserHandshake& default_instance();

  void Swap(BitToUserHandshake* other);

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

  BitToUserHandshake* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const BitToUserHandshake& from);
  void MergeFrom(const BitToUserHandshake& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional int32 rpc_version = 2;
  inline bool has_rpc_version() const;
  inline void clear_rpc_version();
  static const int kRpcVersionFieldNumber = 2;
  inline ::google::protobuf::int32 rpc_version() const;
  inline void set_rpc_version(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:exec.user.BitToUserHandshake)
 private:
  inline void set_has_rpc_version();
  inline void clear_has_rpc_version();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::int32 rpc_version_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static BitToUserHandshake* default_instance_;
};
// -------------------------------------------------------------------

class NodeStatus : public ::google::protobuf::Message {
 public:
  NodeStatus();
  virtual ~NodeStatus();

  NodeStatus(const NodeStatus& from);

  inline NodeStatus& operator=(const NodeStatus& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const NodeStatus& default_instance();

  void Swap(NodeStatus* other);

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

  NodeStatus* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const NodeStatus& from);
  void MergeFrom(const NodeStatus& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional int32 node_id = 1;
  inline bool has_node_id() const;
  inline void clear_node_id();
  static const int kNodeIdFieldNumber = 1;
  inline ::google::protobuf::int32 node_id() const;
  inline void set_node_id(::google::protobuf::int32 value);

  // optional int64 memory_footprint = 2;
  inline bool has_memory_footprint() const;
  inline void clear_memory_footprint();
  static const int kMemoryFootprintFieldNumber = 2;
  inline ::google::protobuf::int64 memory_footprint() const;
  inline void set_memory_footprint(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:exec.user.NodeStatus)
 private:
  inline void set_has_node_id();
  inline void clear_has_node_id();
  inline void set_has_memory_footprint();
  inline void clear_has_memory_footprint();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::int64 memory_footprint_;
  ::google::protobuf::int32 node_id_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static NodeStatus* default_instance_;
};
// -------------------------------------------------------------------

class QueryResult : public ::google::protobuf::Message {
 public:
  QueryResult();
  virtual ~QueryResult();

  QueryResult(const QueryResult& from);

  inline QueryResult& operator=(const QueryResult& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const QueryResult& default_instance();

  void Swap(QueryResult* other);

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

  QueryResult* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const QueryResult& from);
  void MergeFrom(const QueryResult& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  typedef QueryResult_QueryState QueryState;
  static const QueryState PENDING = QueryResult_QueryState_PENDING;
  static const QueryState RUNNING = QueryResult_QueryState_RUNNING;
  static const QueryState COMPLETED = QueryResult_QueryState_COMPLETED;
  static const QueryState CANCELED = QueryResult_QueryState_CANCELED;
  static const QueryState FAILED = QueryResult_QueryState_FAILED;
  static const QueryState UNKNOWN_QUERY = QueryResult_QueryState_UNKNOWN_QUERY;
  static inline bool QueryState_IsValid(int value) {
    return QueryResult_QueryState_IsValid(value);
  }
  static const QueryState QueryState_MIN =
    QueryResult_QueryState_QueryState_MIN;
  static const QueryState QueryState_MAX =
    QueryResult_QueryState_QueryState_MAX;
  static const int QueryState_ARRAYSIZE =
    QueryResult_QueryState_QueryState_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  QueryState_descriptor() {
    return QueryResult_QueryState_descriptor();
  }
  static inline const ::std::string& QueryState_Name(QueryState value) {
    return QueryResult_QueryState_Name(value);
  }
  static inline bool QueryState_Parse(const ::std::string& name,
      QueryState* value) {
    return QueryResult_QueryState_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  // optional .exec.user.QueryResult.QueryState query_state = 1;
  inline bool has_query_state() const;
  inline void clear_query_state();
  static const int kQueryStateFieldNumber = 1;
  inline ::exec::user::QueryResult_QueryState query_state() const;
  inline void set_query_state(::exec::user::QueryResult_QueryState value);

  // optional .exec.shared.QueryId query_id = 2;
  inline bool has_query_id() const;
  inline void clear_query_id();
  static const int kQueryIdFieldNumber = 2;
  inline const ::exec::shared::QueryId& query_id() const;
  inline ::exec::shared::QueryId* mutable_query_id();
  inline ::exec::shared::QueryId* release_query_id();
  inline void set_allocated_query_id(::exec::shared::QueryId* query_id);

  // optional bool is_last_chunk = 3;
  inline bool has_is_last_chunk() const;
  inline void clear_is_last_chunk();
  static const int kIsLastChunkFieldNumber = 3;
  inline bool is_last_chunk() const;
  inline void set_is_last_chunk(bool value);

  // optional int32 row_count = 4;
  inline bool has_row_count() const;
  inline void clear_row_count();
  static const int kRowCountFieldNumber = 4;
  inline ::google::protobuf::int32 row_count() const;
  inline void set_row_count(::google::protobuf::int32 value);

  // optional int64 records_scan = 5;
  inline bool has_records_scan() const;
  inline void clear_records_scan();
  static const int kRecordsScanFieldNumber = 5;
  inline ::google::protobuf::int64 records_scan() const;
  inline void set_records_scan(::google::protobuf::int64 value);

  // optional int64 records_error = 6;
  inline bool has_records_error() const;
  inline void clear_records_error();
  static const int kRecordsErrorFieldNumber = 6;
  inline ::google::protobuf::int64 records_error() const;
  inline void set_records_error(::google::protobuf::int64 value);

  // optional int64 submission_time = 7;
  inline bool has_submission_time() const;
  inline void clear_submission_time();
  static const int kSubmissionTimeFieldNumber = 7;
  inline ::google::protobuf::int64 submission_time() const;
  inline void set_submission_time(::google::protobuf::int64 value);

  // repeated .exec.user.NodeStatus node_status = 8;
  inline int node_status_size() const;
  inline void clear_node_status();
  static const int kNodeStatusFieldNumber = 8;
  inline const ::exec::user::NodeStatus& node_status(int index) const;
  inline ::exec::user::NodeStatus* mutable_node_status(int index);
  inline ::exec::user::NodeStatus* add_node_status();
  inline const ::google::protobuf::RepeatedPtrField< ::exec::user::NodeStatus >&
      node_status() const;
  inline ::google::protobuf::RepeatedPtrField< ::exec::user::NodeStatus >*
      mutable_node_status();

  // repeated .exec.shared.DrillPBError error = 9;
  inline int error_size() const;
  inline void clear_error();
  static const int kErrorFieldNumber = 9;
  inline const ::exec::shared::DrillPBError& error(int index) const;
  inline ::exec::shared::DrillPBError* mutable_error(int index);
  inline ::exec::shared::DrillPBError* add_error();
  inline const ::google::protobuf::RepeatedPtrField< ::exec::shared::DrillPBError >&
      error() const;
  inline ::google::protobuf::RepeatedPtrField< ::exec::shared::DrillPBError >*
      mutable_error();

  // optional .exec.shared.RecordBatchDef def = 10;
  inline bool has_def() const;
  inline void clear_def();
  static const int kDefFieldNumber = 10;
  inline const ::exec::shared::RecordBatchDef& def() const;
  inline ::exec::shared::RecordBatchDef* mutable_def();
  inline ::exec::shared::RecordBatchDef* release_def();
  inline void set_allocated_def(::exec::shared::RecordBatchDef* def);

  // optional bool schema_changed = 11;
  inline bool has_schema_changed() const;
  inline void clear_schema_changed();
  static const int kSchemaChangedFieldNumber = 11;
  inline bool schema_changed() const;
  inline void set_schema_changed(bool value);

  // @@protoc_insertion_point(class_scope:exec.user.QueryResult)
 private:
  inline void set_has_query_state();
  inline void clear_has_query_state();
  inline void set_has_query_id();
  inline void clear_has_query_id();
  inline void set_has_is_last_chunk();
  inline void clear_has_is_last_chunk();
  inline void set_has_row_count();
  inline void clear_has_row_count();
  inline void set_has_records_scan();
  inline void clear_has_records_scan();
  inline void set_has_records_error();
  inline void clear_has_records_error();
  inline void set_has_submission_time();
  inline void clear_has_submission_time();
  inline void set_has_def();
  inline void clear_has_def();
  inline void set_has_schema_changed();
  inline void clear_has_schema_changed();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::exec::shared::QueryId* query_id_;
  int query_state_;
  ::google::protobuf::int32 row_count_;
  ::google::protobuf::int64 records_scan_;
  ::google::protobuf::int64 records_error_;
  ::google::protobuf::int64 submission_time_;
  ::google::protobuf::RepeatedPtrField< ::exec::user::NodeStatus > node_status_;
  ::google::protobuf::RepeatedPtrField< ::exec::shared::DrillPBError > error_;
  ::exec::shared::RecordBatchDef* def_;
  bool is_last_chunk_;
  bool schema_changed_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(11 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static QueryResult* default_instance_;
};
// ===================================================================


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

// Property

// required string key = 1;
inline bool Property::has_key() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Property::set_has_key() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Property::clear_has_key() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Property::clear_key() {
  if (key_ != &::google::protobuf::internal::kEmptyString) {
    key_->clear();
  }
  clear_has_key();
}
inline const ::std::string& Property::key() const {
  return *key_;
}
inline void Property::set_key(const ::std::string& value) {
  set_has_key();
  if (key_ == &::google::protobuf::internal::kEmptyString) {
    key_ = new ::std::string;
  }
  key_->assign(value);
}
inline void Property::set_key(const char* value) {
  set_has_key();
  if (key_ == &::google::protobuf::internal::kEmptyString) {
    key_ = new ::std::string;
  }
  key_->assign(value);
}
inline void Property::set_key(const char* value, size_t size) {
  set_has_key();
  if (key_ == &::google::protobuf::internal::kEmptyString) {
    key_ = new ::std::string;
  }
  key_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Property::mutable_key() {
  set_has_key();
  if (key_ == &::google::protobuf::internal::kEmptyString) {
    key_ = new ::std::string;
  }
  return key_;
}
inline ::std::string* Property::release_key() {
  clear_has_key();
  if (key_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = key_;
    key_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void Property::set_allocated_key(::std::string* key) {
  if (key_ != &::google::protobuf::internal::kEmptyString) {
    delete key_;
  }
  if (key) {
    set_has_key();
    key_ = key;
  } else {
    clear_has_key();
    key_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// required string value = 2;
inline bool Property::has_value() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Property::set_has_value() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Property::clear_has_value() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Property::clear_value() {
  if (value_ != &::google::protobuf::internal::kEmptyString) {
    value_->clear();
  }
  clear_has_value();
}
inline const ::std::string& Property::value() const {
  return *value_;
}
inline void Property::set_value(const ::std::string& value) {
  set_has_value();
  if (value_ == &::google::protobuf::internal::kEmptyString) {
    value_ = new ::std::string;
  }
  value_->assign(value);
}
inline void Property::set_value(const char* value) {
  set_has_value();
  if (value_ == &::google::protobuf::internal::kEmptyString) {
    value_ = new ::std::string;
  }
  value_->assign(value);
}
inline void Property::set_value(const char* value, size_t size) {
  set_has_value();
  if (value_ == &::google::protobuf::internal::kEmptyString) {
    value_ = new ::std::string;
  }
  value_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Property::mutable_value() {
  set_has_value();
  if (value_ == &::google::protobuf::internal::kEmptyString) {
    value_ = new ::std::string;
  }
  return value_;
}
inline ::std::string* Property::release_value() {
  clear_has_value();
  if (value_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = value_;
    value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void Property::set_allocated_value(::std::string* value) {
  if (value_ != &::google::protobuf::internal::kEmptyString) {
    delete value_;
  }
  if (value) {
    set_has_value();
    value_ = value;
  } else {
    clear_has_value();
    value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

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

// UserProperties

// repeated .exec.user.Property properties = 1;
inline int UserProperties::properties_size() const {
  return properties_.size();
}
inline void UserProperties::clear_properties() {
  properties_.Clear();
}
inline const ::exec::user::Property& UserProperties::properties(int index) const {
  return properties_.Get(index);
}
inline ::exec::user::Property* UserProperties::mutable_properties(int index) {
  return properties_.Mutable(index);
}
inline ::exec::user::Property* UserProperties::add_properties() {
  return properties_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::exec::user::Property >&
UserProperties::properties() const {
  return properties_;
}
inline ::google::protobuf::RepeatedPtrField< ::exec::user::Property >*
UserProperties::mutable_properties() {
  return &properties_;
}

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

// UserToBitHandshake

// optional .exec.shared.RpcChannel channel = 1 [default = USER];
inline bool UserToBitHandshake::has_channel() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void UserToBitHandshake::set_has_channel() {
  _has_bits_[0] |= 0x00000001u;
}
inline void UserToBitHandshake::clear_has_channel() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void UserToBitHandshake::clear_channel() {
  channel_ = 2;
  clear_has_channel();
}
inline ::exec::shared::RpcChannel UserToBitHandshake::channel() const {
  return static_cast< ::exec::shared::RpcChannel >(channel_);
}
inline void UserToBitHandshake::set_channel(::exec::shared::RpcChannel value) {
  assert(::exec::shared::RpcChannel_IsValid(value));
  set_has_channel();
  channel_ = value;
}

// optional bool support_listening = 2;
inline bool UserToBitHandshake::has_support_listening() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void UserToBitHandshake::set_has_support_listening() {
  _has_bits_[0] |= 0x00000002u;
}
inline void UserToBitHandshake::clear_has_support_listening() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void UserToBitHandshake::clear_support_listening() {
  support_listening_ = false;
  clear_has_support_listening();
}
inline bool UserToBitHandshake::support_listening() const {
  return support_listening_;
}
inline void UserToBitHandshake::set_support_listening(bool value) {
  set_has_support_listening();
  support_listening_ = value;
}

// optional int32 rpc_version = 3;
inline bool UserToBitHandshake::has_rpc_version() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void UserToBitHandshake::set_has_rpc_version() {
  _has_bits_[0] |= 0x00000004u;
}
inline void UserToBitHandshake::clear_has_rpc_version() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void UserToBitHandshake::clear_rpc_version() {
  rpc_version_ = 0;
  clear_has_rpc_version();
}
inline ::google::protobuf::int32 UserToBitHandshake::rpc_version() const {
  return rpc_version_;
}
inline void UserToBitHandshake::set_rpc_version(::google::protobuf::int32 value) {
  set_has_rpc_version();
  rpc_version_ = value;
}

// optional .exec.shared.UserCredentials credentials = 4;
inline bool UserToBitHandshake::has_credentials() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void UserToBitHandshake::set_has_credentials() {
  _has_bits_[0] |= 0x00000008u;
}
inline void UserToBitHandshake::clear_has_credentials() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void UserToBitHandshake::clear_credentials() {
  if (credentials_ != NULL) credentials_->::exec::shared::UserCredentials::Clear();
  clear_has_credentials();
}
inline const ::exec::shared::UserCredentials& UserToBitHandshake::credentials() const {
  return credentials_ != NULL ? *credentials_ : *default_instance_->credentials_;
}
inline ::exec::shared::UserCredentials* UserToBitHandshake::mutable_credentials() {
  set_has_credentials();
  if (credentials_ == NULL) credentials_ = new ::exec::shared::UserCredentials;
  return credentials_;
}
inline ::exec::shared::UserCredentials* UserToBitHandshake::release_credentials() {
  clear_has_credentials();
  ::exec::shared::UserCredentials* temp = credentials_;
  credentials_ = NULL;
  return temp;
}
inline void UserToBitHandshake::set_allocated_credentials(::exec::shared::UserCredentials* credentials) {
  delete credentials_;
  credentials_ = credentials;
  if (credentials) {
    set_has_credentials();
  } else {
    clear_has_credentials();
  }
}

// optional .exec.user.UserProperties properties = 5;
inline bool UserToBitHandshake::has_properties() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void UserToBitHandshake::set_has_properties() {
  _has_bits_[0] |= 0x00000010u;
}
inline void UserToBitHandshake::clear_has_properties() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void UserToBitHandshake::clear_properties() {
  if (properties_ != NULL) properties_->::exec::user::UserProperties::Clear();
  clear_has_properties();
}
inline const ::exec::user::UserProperties& UserToBitHandshake::properties() const {
  return properties_ != NULL ? *properties_ : *default_instance_->properties_;
}
inline ::exec::user::UserProperties* UserToBitHandshake::mutable_properties() {
  set_has_properties();
  if (properties_ == NULL) properties_ = new ::exec::user::UserProperties;
  return properties_;
}
inline ::exec::user::UserProperties* UserToBitHandshake::release_properties() {
  clear_has_properties();
  ::exec::user::UserProperties* temp = properties_;
  properties_ = NULL;
  return temp;
}
inline void UserToBitHandshake::set_allocated_properties(::exec::user::UserProperties* properties) {
  delete properties_;
  properties_ = properties;
  if (properties) {
    set_has_properties();
  } else {
    clear_has_properties();
  }
}

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

// RequestResults

// optional .exec.shared.QueryId query_id = 1;
inline bool RequestResults::has_query_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void RequestResults::set_has_query_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void RequestResults::clear_has_query_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void RequestResults::clear_query_id() {
  if (query_id_ != NULL) query_id_->::exec::shared::QueryId::Clear();
  clear_has_query_id();
}
inline const ::exec::shared::QueryId& RequestResults::query_id() const {
  return query_id_ != NULL ? *query_id_ : *default_instance_->query_id_;
}
inline ::exec::shared::QueryId* RequestResults::mutable_query_id() {
  set_has_query_id();
  if (query_id_ == NULL) query_id_ = new ::exec::shared::QueryId;
  return query_id_;
}
inline ::exec::shared::QueryId* RequestResults::release_query_id() {
  clear_has_query_id();
  ::exec::shared::QueryId* temp = query_id_;
  query_id_ = NULL;
  return temp;
}
inline void RequestResults::set_allocated_query_id(::exec::shared::QueryId* query_id) {
  delete query_id_;
  query_id_ = query_id;
  if (query_id) {
    set_has_query_id();
  } else {
    clear_has_query_id();
  }
}

// optional int32 maximum_responses = 2;
inline bool RequestResults::has_maximum_responses() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void RequestResults::set_has_maximum_responses() {
  _has_bits_[0] |= 0x00000002u;
}
inline void RequestResults::clear_has_maximum_responses() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void RequestResults::clear_maximum_responses() {
  maximum_responses_ = 0;
  clear_has_maximum_responses();
}
inline ::google::protobuf::int32 RequestResults::maximum_responses() const {
  return maximum_responses_;
}
inline void RequestResults::set_maximum_responses(::google::protobuf::int32 value) {
  set_has_maximum_responses();
  maximum_responses_ = value;
}

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

// RunQuery

// optional .exec.user.QueryResultsMode results_mode = 1;
inline bool RunQuery::has_results_mode() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void RunQuery::set_has_results_mode() {
  _has_bits_[0] |= 0x00000001u;
}
inline void RunQuery::clear_has_results_mode() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void RunQuery::clear_results_mode() {
  results_mode_ = 1;
  clear_has_results_mode();
}
inline ::exec::user::QueryResultsMode RunQuery::results_mode() const {
  return static_cast< ::exec::user::QueryResultsMode >(results_mode_);
}
inline void RunQuery::set_results_mode(::exec::user::QueryResultsMode value) {
  assert(::exec::user::QueryResultsMode_IsValid(value));
  set_has_results_mode();
  results_mode_ = value;
}

// optional .exec.user.QueryType type = 2;
inline bool RunQuery::has_type() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void RunQuery::set_has_type() {
  _has_bits_[0] |= 0x00000002u;
}
inline void RunQuery::clear_has_type() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void RunQuery::clear_type() {
  type_ = 1;
  clear_has_type();
}
inline ::exec::user::QueryType RunQuery::type() const {
  return static_cast< ::exec::user::QueryType >(type_);
}
inline void RunQuery::set_type(::exec::user::QueryType value) {
  assert(::exec::user::QueryType_IsValid(value));
  set_has_type();
  type_ = value;
}

// optional string plan = 3;
inline bool RunQuery::has_plan() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void RunQuery::set_has_plan() {
  _has_bits_[0] |= 0x00000004u;
}
inline void RunQuery::clear_has_plan() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void RunQuery::clear_plan() {
  if (plan_ != &::google::protobuf::internal::kEmptyString) {
    plan_->clear();
  }
  clear_has_plan();
}
inline const ::std::string& RunQuery::plan() const {
  return *plan_;
}
inline void RunQuery::set_plan(const ::std::string& value) {
  set_has_plan();
  if (plan_ == &::google::protobuf::internal::kEmptyString) {
    plan_ = new ::std::string;
  }
  plan_->assign(value);
}
inline void RunQuery::set_plan(const char* value) {
  set_has_plan();
  if (plan_ == &::google::protobuf::internal::kEmptyString) {
    plan_ = new ::std::string;
  }
  plan_->assign(value);
}
inline void RunQuery::set_plan(const char* value, size_t size) {
  set_has_plan();
  if (plan_ == &::google::protobuf::internal::kEmptyString) {
    plan_ = new ::std::string;
  }
  plan_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* RunQuery::mutable_plan() {
  set_has_plan();
  if (plan_ == &::google::protobuf::internal::kEmptyString) {
    plan_ = new ::std::string;
  }
  return plan_;
}
inline ::std::string* RunQuery::release_plan() {
  clear_has_plan();
  if (plan_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = plan_;
    plan_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void RunQuery::set_allocated_plan(::std::string* plan) {
  if (plan_ != &::google::protobuf::internal::kEmptyString) {
    delete plan_;
  }
  if (plan) {
    set_has_plan();
    plan_ = plan;
  } else {
    clear_has_plan();
    plan_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

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

// BitToUserHandshake

// optional int32 rpc_version = 2;
inline bool BitToUserHandshake::has_rpc_version() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void BitToUserHandshake::set_has_rpc_version() {
  _has_bits_[0] |= 0x00000001u;
}
inline void BitToUserHandshake::clear_has_rpc_version() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void BitToUserHandshake::clear_rpc_version() {
  rpc_version_ = 0;
  clear_has_rpc_version();
}
inline ::google::protobuf::int32 BitToUserHandshake::rpc_version() const {
  return rpc_version_;
}
inline void BitToUserHandshake::set_rpc_version(::google::protobuf::int32 value) {
  set_has_rpc_version();
  rpc_version_ = value;
}

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

// NodeStatus

// optional int32 node_id = 1;
inline bool NodeStatus::has_node_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void NodeStatus::set_has_node_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void NodeStatus::clear_has_node_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void NodeStatus::clear_node_id() {
  node_id_ = 0;
  clear_has_node_id();
}
inline ::google::protobuf::int32 NodeStatus::node_id() const {
  return node_id_;
}
inline void NodeStatus::set_node_id(::google::protobuf::int32 value) {
  set_has_node_id();
  node_id_ = value;
}

// optional int64 memory_footprint = 2;
inline bool NodeStatus::has_memory_footprint() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void NodeStatus::set_has_memory_footprint() {
  _has_bits_[0] |= 0x00000002u;
}
inline void NodeStatus::clear_has_memory_footprint() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void NodeStatus::clear_memory_footprint() {
  memory_footprint_ = GOOGLE_LONGLONG(0);
  clear_has_memory_footprint();
}
inline ::google::protobuf::int64 NodeStatus::memory_footprint() const {
  return memory_footprint_;
}
inline void NodeStatus::set_memory_footprint(::google::protobuf::int64 value) {
  set_has_memory_footprint();
  memory_footprint_ = value;
}

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

// QueryResult

// optional .exec.user.QueryResult.QueryState query_state = 1;
inline bool QueryResult::has_query_state() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void QueryResult::set_has_query_state() {
  _has_bits_[0] |= 0x00000001u;
}
inline void QueryResult::clear_has_query_state() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void QueryResult::clear_query_state() {
  query_state_ = 0;
  clear_has_query_state();
}
inline ::exec::user::QueryResult_QueryState QueryResult::query_state() const {
  return static_cast< ::exec::user::QueryResult_QueryState >(query_state_);
}
inline void QueryResult::set_query_state(::exec::user::QueryResult_QueryState value) {
  assert(::exec::user::QueryResult_QueryState_IsValid(value));
  set_has_query_state();
  query_state_ = value;
}

// optional .exec.shared.QueryId query_id = 2;
inline bool QueryResult::has_query_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void QueryResult::set_has_query_id() {
  _has_bits_[0] |= 0x00000002u;
}
inline void QueryResult::clear_has_query_id() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void QueryResult::clear_query_id() {
  if (query_id_ != NULL) query_id_->::exec::shared::QueryId::Clear();
  clear_has_query_id();
}
inline const ::exec::shared::QueryId& QueryResult::query_id() const {
  return query_id_ != NULL ? *query_id_ : *default_instance_->query_id_;
}
inline ::exec::shared::QueryId* QueryResult::mutable_query_id() {
  set_has_query_id();
  if (query_id_ == NULL) query_id_ = new ::exec::shared::QueryId;
  return query_id_;
}
inline ::exec::shared::QueryId* QueryResult::release_query_id() {
  clear_has_query_id();
  ::exec::shared::QueryId* temp = query_id_;
  query_id_ = NULL;
  return temp;
}
inline void QueryResult::set_allocated_query_id(::exec::shared::QueryId* query_id) {
  delete query_id_;
  query_id_ = query_id;
  if (query_id) {
    set_has_query_id();
  } else {
    clear_has_query_id();
  }
}

// optional bool is_last_chunk = 3;
inline bool QueryResult::has_is_last_chunk() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void QueryResult::set_has_is_last_chunk() {
  _has_bits_[0] |= 0x00000004u;
}
inline void QueryResult::clear_has_is_last_chunk() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void QueryResult::clear_is_last_chunk() {
  is_last_chunk_ = false;
  clear_has_is_last_chunk();
}
inline bool QueryResult::is_last_chunk() const {
  return is_last_chunk_;
}
inline void QueryResult::set_is_last_chunk(bool value) {
  set_has_is_last_chunk();
  is_last_chunk_ = value;
}

// optional int32 row_count = 4;
inline bool QueryResult::has_row_count() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void QueryResult::set_has_row_count() {
  _has_bits_[0] |= 0x00000008u;
}
inline void QueryResult::clear_has_row_count() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void QueryResult::clear_row_count() {
  row_count_ = 0;
  clear_has_row_count();
}
inline ::google::protobuf::int32 QueryResult::row_count() const {
  return row_count_;
}
inline void QueryResult::set_row_count(::google::protobuf::int32 value) {
  set_has_row_count();
  row_count_ = value;
}

// optional int64 records_scan = 5;
inline bool QueryResult::has_records_scan() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void QueryResult::set_has_records_scan() {
  _has_bits_[0] |= 0x00000010u;
}
inline void QueryResult::clear_has_records_scan() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void QueryResult::clear_records_scan() {
  records_scan_ = GOOGLE_LONGLONG(0);
  clear_has_records_scan();
}
inline ::google::protobuf::int64 QueryResult::records_scan() const {
  return records_scan_;
}
inline void QueryResult::set_records_scan(::google::protobuf::int64 value) {
  set_has_records_scan();
  records_scan_ = value;
}

// optional int64 records_error = 6;
inline bool QueryResult::has_records_error() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void QueryResult::set_has_records_error() {
  _has_bits_[0] |= 0x00000020u;
}
inline void QueryResult::clear_has_records_error() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void QueryResult::clear_records_error() {
  records_error_ = GOOGLE_LONGLONG(0);
  clear_has_records_error();
}
inline ::google::protobuf::int64 QueryResult::records_error() const {
  return records_error_;
}
inline void QueryResult::set_records_error(::google::protobuf::int64 value) {
  set_has_records_error();
  records_error_ = value;
}

// optional int64 submission_time = 7;
inline bool QueryResult::has_submission_time() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void QueryResult::set_has_submission_time() {
  _has_bits_[0] |= 0x00000040u;
}
inline void QueryResult::clear_has_submission_time() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void QueryResult::clear_submission_time() {
  submission_time_ = GOOGLE_LONGLONG(0);
  clear_has_submission_time();
}
inline ::google::protobuf::int64 QueryResult::submission_time() const {
  return submission_time_;
}
inline void QueryResult::set_submission_time(::google::protobuf::int64 value) {
  set_has_submission_time();
  submission_time_ = value;
}

// repeated .exec.user.NodeStatus node_status = 8;
inline int QueryResult::node_status_size() const {
  return node_status_.size();
}
inline void QueryResult::clear_node_status() {
  node_status_.Clear();
}
inline const ::exec::user::NodeStatus& QueryResult::node_status(int index) const {
  return node_status_.Get(index);
}
inline ::exec::user::NodeStatus* QueryResult::mutable_node_status(int index) {
  return node_status_.Mutable(index);
}
inline ::exec::user::NodeStatus* QueryResult::add_node_status() {
  return node_status_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::exec::user::NodeStatus >&
QueryResult::node_status() const {
  return node_status_;
}
inline ::google::protobuf::RepeatedPtrField< ::exec::user::NodeStatus >*
QueryResult::mutable_node_status() {
  return &node_status_;
}

// repeated .exec.shared.DrillPBError error = 9;
inline int QueryResult::error_size() const {
  return error_.size();
}
inline void QueryResult::clear_error() {
  error_.Clear();
}
inline const ::exec::shared::DrillPBError& QueryResult::error(int index) const {
  return error_.Get(index);
}
inline ::exec::shared::DrillPBError* QueryResult::mutable_error(int index) {
  return error_.Mutable(index);
}
inline ::exec::shared::DrillPBError* QueryResult::add_error() {
  return error_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::exec::shared::DrillPBError >&
QueryResult::error() const {
  return error_;
}
inline ::google::protobuf::RepeatedPtrField< ::exec::shared::DrillPBError >*
QueryResult::mutable_error() {
  return &error_;
}

// optional .exec.shared.RecordBatchDef def = 10;
inline bool QueryResult::has_def() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void QueryResult::set_has_def() {
  _has_bits_[0] |= 0x00000200u;
}
inline void QueryResult::clear_has_def() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void QueryResult::clear_def() {
  if (def_ != NULL) def_->::exec::shared::RecordBatchDef::Clear();
  clear_has_def();
}
inline const ::exec::shared::RecordBatchDef& QueryResult::def() const {
  return def_ != NULL ? *def_ : *default_instance_->def_;
}
inline ::exec::shared::RecordBatchDef* QueryResult::mutable_def() {
  set_has_def();
  if (def_ == NULL) def_ = new ::exec::shared::RecordBatchDef;
  return def_;
}
inline ::exec::shared::RecordBatchDef* QueryResult::release_def() {
  clear_has_def();
  ::exec::shared::RecordBatchDef* temp = def_;
  def_ = NULL;
  return temp;
}
inline void QueryResult::set_allocated_def(::exec::shared::RecordBatchDef* def) {
  delete def_;
  def_ = def;
  if (def) {
    set_has_def();
  } else {
    clear_has_def();
  }
}

// optional bool schema_changed = 11;
inline bool QueryResult::has_schema_changed() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void QueryResult::set_has_schema_changed() {
  _has_bits_[0] |= 0x00000400u;
}
inline void QueryResult::clear_has_schema_changed() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void QueryResult::clear_schema_changed() {
  schema_changed_ = false;
  clear_has_schema_changed();
}
inline bool QueryResult::schema_changed() const {
  return schema_changed_;
}
inline void QueryResult::set_schema_changed(bool value) {
  set_has_schema_changed();
  schema_changed_ = value;
}


// @@protoc_insertion_point(namespace_scope)

}  // namespace user
}  // namespace exec

#ifndef SWIG
namespace google {
namespace protobuf {

template <>
inline const EnumDescriptor* GetEnumDescriptor< ::exec::user::QueryResult_QueryState>() {
  return ::exec::user::QueryResult_QueryState_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::exec::user::RpcType>() {
  return ::exec::user::RpcType_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::exec::user::QueryType>() {
  return ::exec::user::QueryType_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::exec::user::QueryResultsMode>() {
  return ::exec::user::QueryResultsMode_descriptor();
}

}  // namespace google
}  // namespace protobuf
#endif  // SWIG

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_User_2eproto__INCLUDED