drill-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From j..@apache.org
Subject [06/27] drill git commit: DRILL-5301: Add C++ client support for Server metadata API
Date Thu, 02 Mar 2017 20:59:33 GMT
http://git-wip-us.apache.org/repos/asf/drill/blob/d3238b1b/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 d332c36..a8f8db4 100644
--- a/contrib/native/client/src/protobuf/User.pb.h
+++ b/contrib/native/client/src/protobuf/User.pb.h
@@ -26,6 +26,7 @@
 #include <google/protobuf/generated_enum_reflection.h>
 #include <google/protobuf/unknown_field_set.h>
 #include "SchemaDef.pb.h"
+#include "Types.pb.h"
 #include "UserBitShared.pb.h"
 #include "BitData.pb.h"
 #include "BitControl.pb.h"
@@ -66,6 +67,10 @@ class ResultColumnMetadata;
 class PreparedStatementHandle;
 class PreparedStatement;
 class CreatePreparedStatementResp;
+class GetServerMetaReq;
+class ConvertSupport;
+class GetServerMetaResp;
+class ServerMeta;
 class RunQuery;
 
 enum RpcType {
@@ -82,6 +87,7 @@ enum RpcType {
   GET_TABLES = 16,
   GET_COLUMNS = 17,
   CREATE_PREPARED_STATEMENT = 22,
+  GET_SERVER_META = 8,
   QUERY_DATA = 6,
   QUERY_HANDLE = 7,
   QUERY_PLAN_FRAGMENTS = 13,
@@ -90,8 +96,7 @@ enum RpcType {
   TABLES = 20,
   COLUMNS = 21,
   PREPARED_STATEMENT = 23,
-  REQ_META_FUNCTIONS = 8,
-  RESP_FUNCTION_LIST = 9,
+  SERVER_META = 9,
   QUERY_RESULT = 10,
   SASL_MESSAGE = 24
 };
@@ -232,6 +237,232 @@ inline bool ColumnUpdatability_Parse(
   return ::google::protobuf::internal::ParseNamedEnum<ColumnUpdatability>(
     ColumnUpdatability_descriptor(), name, value);
 }
+enum CollateSupport {
+  CS_UNKNOWN = 0,
+  CS_GROUP_BY = 1
+};
+bool CollateSupport_IsValid(int value);
+const CollateSupport CollateSupport_MIN = CS_UNKNOWN;
+const CollateSupport CollateSupport_MAX = CS_GROUP_BY;
+const int CollateSupport_ARRAYSIZE = CollateSupport_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* CollateSupport_descriptor();
+inline const ::std::string& CollateSupport_Name(CollateSupport value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    CollateSupport_descriptor(), value);
+}
+inline bool CollateSupport_Parse(
+    const ::std::string& name, CollateSupport* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<CollateSupport>(
+    CollateSupport_descriptor(), name, value);
+}
+enum CorrelationNamesSupport {
+  CN_NONE = 1,
+  CN_DIFFERENT_NAMES = 2,
+  CN_ANY = 3
+};
+bool CorrelationNamesSupport_IsValid(int value);
+const CorrelationNamesSupport CorrelationNamesSupport_MIN = CN_NONE;
+const CorrelationNamesSupport CorrelationNamesSupport_MAX = CN_ANY;
+const int CorrelationNamesSupport_ARRAYSIZE = CorrelationNamesSupport_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* CorrelationNamesSupport_descriptor();
+inline const ::std::string& CorrelationNamesSupport_Name(CorrelationNamesSupport value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    CorrelationNamesSupport_descriptor(), value);
+}
+inline bool CorrelationNamesSupport_Parse(
+    const ::std::string& name, CorrelationNamesSupport* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<CorrelationNamesSupport>(
+    CorrelationNamesSupport_descriptor(), name, value);
+}
+enum DateTimeLiteralsSupport {
+  DL_UNKNOWN = 0,
+  DL_DATE = 1,
+  DL_TIME = 2,
+  DL_TIMESTAMP = 3,
+  DL_INTERVAL_YEAR = 4,
+  DL_INTERVAL_MONTH = 5,
+  DL_INTERVAL_DAY = 6,
+  DL_INTERVAL_HOUR = 7,
+  DL_INTERVAL_MINUTE = 8,
+  DL_INTERVAL_SECOND = 9,
+  DL_INTERVAL_YEAR_TO_MONTH = 10,
+  DL_INTERVAL_DAY_TO_HOUR = 11,
+  DL_INTERVAL_DAY_TO_MINUTE = 12,
+  DL_INTERVAL_DAY_TO_SECOND = 13,
+  DL_INTERVAL_HOUR_TO_MINUTE = 14,
+  DL_INTERVAL_HOUR_TO_SECOND = 15,
+  DL_INTERVAL_MINUTE_TO_SECOND = 16
+};
+bool DateTimeLiteralsSupport_IsValid(int value);
+const DateTimeLiteralsSupport DateTimeLiteralsSupport_MIN = DL_UNKNOWN;
+const DateTimeLiteralsSupport DateTimeLiteralsSupport_MAX = DL_INTERVAL_MINUTE_TO_SECOND;
+const int DateTimeLiteralsSupport_ARRAYSIZE = DateTimeLiteralsSupport_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* DateTimeLiteralsSupport_descriptor();
+inline const ::std::string& DateTimeLiteralsSupport_Name(DateTimeLiteralsSupport value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    DateTimeLiteralsSupport_descriptor(), value);
+}
+inline bool DateTimeLiteralsSupport_Parse(
+    const ::std::string& name, DateTimeLiteralsSupport* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<DateTimeLiteralsSupport>(
+    DateTimeLiteralsSupport_descriptor(), name, value);
+}
+enum GroupBySupport {
+  GB_NONE = 1,
+  GB_SELECT_ONLY = 2,
+  GB_BEYOND_SELECT = 3,
+  GB_UNRELATED = 4
+};
+bool GroupBySupport_IsValid(int value);
+const GroupBySupport GroupBySupport_MIN = GB_NONE;
+const GroupBySupport GroupBySupport_MAX = GB_UNRELATED;
+const int GroupBySupport_ARRAYSIZE = GroupBySupport_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* GroupBySupport_descriptor();
+inline const ::std::string& GroupBySupport_Name(GroupBySupport value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    GroupBySupport_descriptor(), value);
+}
+inline bool GroupBySupport_Parse(
+    const ::std::string& name, GroupBySupport* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<GroupBySupport>(
+    GroupBySupport_descriptor(), name, value);
+}
+enum IdentifierCasing {
+  IC_UNKNOWN = 0,
+  IC_STORES_LOWER = 1,
+  IC_STORES_MIXED = 2,
+  IC_STORES_UPPER = 3,
+  IC_SUPPORTS_MIXED = 4
+};
+bool IdentifierCasing_IsValid(int value);
+const IdentifierCasing IdentifierCasing_MIN = IC_UNKNOWN;
+const IdentifierCasing IdentifierCasing_MAX = IC_SUPPORTS_MIXED;
+const int IdentifierCasing_ARRAYSIZE = IdentifierCasing_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* IdentifierCasing_descriptor();
+inline const ::std::string& IdentifierCasing_Name(IdentifierCasing value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    IdentifierCasing_descriptor(), value);
+}
+inline bool IdentifierCasing_Parse(
+    const ::std::string& name, IdentifierCasing* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<IdentifierCasing>(
+    IdentifierCasing_descriptor(), name, value);
+}
+enum NullCollation {
+  NC_UNKNOWN = 0,
+  NC_AT_START = 1,
+  NC_AT_END = 2,
+  NC_HIGH = 3,
+  NC_LOW = 4
+};
+bool NullCollation_IsValid(int value);
+const NullCollation NullCollation_MIN = NC_UNKNOWN;
+const NullCollation NullCollation_MAX = NC_LOW;
+const int NullCollation_ARRAYSIZE = NullCollation_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* NullCollation_descriptor();
+inline const ::std::string& NullCollation_Name(NullCollation value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    NullCollation_descriptor(), value);
+}
+inline bool NullCollation_Parse(
+    const ::std::string& name, NullCollation* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<NullCollation>(
+    NullCollation_descriptor(), name, value);
+}
+enum OrderBySupport {
+  OB_UNKNOWN = 0,
+  OB_UNRELATED = 1,
+  OB_EXPRESSION = 2
+};
+bool OrderBySupport_IsValid(int value);
+const OrderBySupport OrderBySupport_MIN = OB_UNKNOWN;
+const OrderBySupport OrderBySupport_MAX = OB_EXPRESSION;
+const int OrderBySupport_ARRAYSIZE = OrderBySupport_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* OrderBySupport_descriptor();
+inline const ::std::string& OrderBySupport_Name(OrderBySupport value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    OrderBySupport_descriptor(), value);
+}
+inline bool OrderBySupport_Parse(
+    const ::std::string& name, OrderBySupport* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<OrderBySupport>(
+    OrderBySupport_descriptor(), name, value);
+}
+enum OuterJoinSupport {
+  OJ_UNKNOWN = 0,
+  OJ_LEFT = 1,
+  OJ_RIGHT = 2,
+  OJ_FULL = 3,
+  OJ_NESTED = 4,
+  OJ_NOT_ORDERED = 5,
+  OJ_INNER = 6,
+  OJ_ALL_COMPARISON_OPS = 7
+};
+bool OuterJoinSupport_IsValid(int value);
+const OuterJoinSupport OuterJoinSupport_MIN = OJ_UNKNOWN;
+const OuterJoinSupport OuterJoinSupport_MAX = OJ_ALL_COMPARISON_OPS;
+const int OuterJoinSupport_ARRAYSIZE = OuterJoinSupport_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* OuterJoinSupport_descriptor();
+inline const ::std::string& OuterJoinSupport_Name(OuterJoinSupport value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    OuterJoinSupport_descriptor(), value);
+}
+inline bool OuterJoinSupport_Parse(
+    const ::std::string& name, OuterJoinSupport* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<OuterJoinSupport>(
+    OuterJoinSupport_descriptor(), name, value);
+}
+enum SubQuerySupport {
+  SQ_UNKNOWN = 0,
+  SQ_CORRELATED = 1,
+  SQ_IN_COMPARISON = 2,
+  SQ_IN_EXISTS = 3,
+  SQ_IN_INSERT = 4,
+  SQ_IN_QUANTIFIED = 5
+};
+bool SubQuerySupport_IsValid(int value);
+const SubQuerySupport SubQuerySupport_MIN = SQ_UNKNOWN;
+const SubQuerySupport SubQuerySupport_MAX = SQ_IN_QUANTIFIED;
+const int SubQuerySupport_ARRAYSIZE = SubQuerySupport_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* SubQuerySupport_descriptor();
+inline const ::std::string& SubQuerySupport_Name(SubQuerySupport value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    SubQuerySupport_descriptor(), value);
+}
+inline bool SubQuerySupport_Parse(
+    const ::std::string& name, SubQuerySupport* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<SubQuerySupport>(
+    SubQuerySupport_descriptor(), name, value);
+}
+enum UnionSupport {
+  U_UNKNOWN = 0,
+  U_UNION = 1,
+  U_UNION_ALL = 2
+};
+bool UnionSupport_IsValid(int value);
+const UnionSupport UnionSupport_MIN = U_UNKNOWN;
+const UnionSupport UnionSupport_MAX = U_UNION_ALL;
+const int UnionSupport_ARRAYSIZE = UnionSupport_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* UnionSupport_descriptor();
+inline const ::std::string& UnionSupport_Name(UnionSupport value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    UnionSupport_descriptor(), value);
+}
+inline bool UnionSupport_Parse(
+    const ::std::string& name, UnionSupport* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<UnionSupport>(
+    UnionSupport_descriptor(), name, value);
+}
 // ===================================================================
 
 class Property : public ::google::protobuf::Message {
@@ -3545,14 +3776,14 @@ class CreatePreparedStatementResp : public ::google::protobuf::Message {
 };
 // -------------------------------------------------------------------
 
-class RunQuery : public ::google::protobuf::Message {
+class GetServerMetaReq : public ::google::protobuf::Message {
  public:
-  RunQuery();
-  virtual ~RunQuery();
+  GetServerMetaReq();
+  virtual ~GetServerMetaReq();
 
-  RunQuery(const RunQuery& from);
+  GetServerMetaReq(const GetServerMetaReq& from);
 
-  inline RunQuery& operator=(const RunQuery& from) {
+  inline GetServerMetaReq& operator=(const GetServerMetaReq& from) {
     CopyFrom(from);
     return *this;
   }
@@ -3566,17 +3797,17 @@ class RunQuery : public ::google::protobuf::Message {
   }
 
   static const ::google::protobuf::Descriptor* descriptor();
-  static const RunQuery& default_instance();
+  static const GetServerMetaReq& default_instance();
 
-  void Swap(RunQuery* other);
+  void Swap(GetServerMetaReq* other);
 
   // implements Message ----------------------------------------------
 
-  RunQuery* New() const;
+  GetServerMetaReq* 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 CopyFrom(const GetServerMetaReq& from);
+  void MergeFrom(const GetServerMetaReq& from);
   void Clear();
   bool IsInitialized() const;
 
@@ -3599,1668 +3830,3985 @@ class RunQuery : public ::google::protobuf::Message {
 
   // 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);
+  // @@protoc_insertion_point(class_scope:exec.user.GetServerMetaReq)
+ private:
 
-  // optional .exec.shared.QueryType type = 2;
-  inline bool has_type() const;
-  inline void clear_type();
-  static const int kTypeFieldNumber = 2;
-  inline ::exec::shared::QueryType type() const;
-  inline void set_type(::exec::shared::QueryType value);
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
-  // 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);
 
-  // repeated .exec.bit.control.PlanFragment fragments = 4;
-  inline int fragments_size() const;
-  inline void clear_fragments();
-  static const int kFragmentsFieldNumber = 4;
-  inline const ::exec::bit::control::PlanFragment& fragments(int index) const;
-  inline ::exec::bit::control::PlanFragment* mutable_fragments(int index);
-  inline ::exec::bit::control::PlanFragment* add_fragments();
-  inline const ::google::protobuf::RepeatedPtrField< ::exec::bit::control::PlanFragment >&
-      fragments() const;
-  inline ::google::protobuf::RepeatedPtrField< ::exec::bit::control::PlanFragment >*
-      mutable_fragments();
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[1];
 
-  // optional .exec.user.PreparedStatementHandle prepared_statement_handle = 5;
-  inline bool has_prepared_statement_handle() const;
-  inline void clear_prepared_statement_handle();
-  static const int kPreparedStatementHandleFieldNumber = 5;
-  inline const ::exec::user::PreparedStatementHandle& prepared_statement_handle() const;
-  inline ::exec::user::PreparedStatementHandle* mutable_prepared_statement_handle();
-  inline ::exec::user::PreparedStatementHandle* release_prepared_statement_handle();
-  inline void set_allocated_prepared_statement_handle(::exec::user::PreparedStatementHandle* prepared_statement_handle);
+  friend void  protobuf_AddDesc_User_2eproto();
+  friend void protobuf_AssignDesc_User_2eproto();
+  friend void protobuf_ShutdownFile_User_2eproto();
 
-  // @@protoc_insertion_point(class_scope:exec.user.RunQuery)
+  void InitAsDefaultInstance();
+  static GetServerMetaReq* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ConvertSupport : public ::google::protobuf::Message {
+ public:
+  ConvertSupport();
+  virtual ~ConvertSupport();
+
+  ConvertSupport(const ConvertSupport& from);
+
+  inline ConvertSupport& operator=(const ConvertSupport& 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 ConvertSupport& default_instance();
+
+  void Swap(ConvertSupport* other);
+
+  // implements Message ----------------------------------------------
+
+  ConvertSupport* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ConvertSupport& from);
+  void MergeFrom(const ConvertSupport& 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 .common.MinorType from = 1;
+  inline bool has_from() const;
+  inline void clear_from();
+  static const int kFromFieldNumber = 1;
+  inline ::common::MinorType from() const;
+  inline void set_from(::common::MinorType value);
+
+  // required .common.MinorType to = 2;
+  inline bool has_to() const;
+  inline void clear_to();
+  static const int kToFieldNumber = 2;
+  inline ::common::MinorType to() const;
+  inline void set_to(::common::MinorType value);
+
+  // @@protoc_insertion_point(class_scope:exec.user.ConvertSupport)
  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();
-  inline void set_has_prepared_statement_handle();
-  inline void clear_has_prepared_statement_handle();
+  inline void set_has_from();
+  inline void clear_has_from();
+  inline void set_has_to();
+  inline void clear_has_to();
 
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
-  int results_mode_;
-  int type_;
-  ::std::string* plan_;
-  ::google::protobuf::RepeatedPtrField< ::exec::bit::control::PlanFragment > fragments_;
-  ::exec::user::PreparedStatementHandle* prepared_statement_handle_;
+  int from_;
+  int to_;
 
   mutable int _cached_size_;
-  ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];
+  ::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 RunQuery* default_instance_;
+  static ConvertSupport* default_instance_;
 };
-// ===================================================================
-
+// -------------------------------------------------------------------
 
-// ===================================================================
+class GetServerMetaResp : public ::google::protobuf::Message {
+ public:
+  GetServerMetaResp();
+  virtual ~GetServerMetaResp();
 
-// Property
+  GetServerMetaResp(const GetServerMetaResp& from);
 
-// 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_;
+  inline GetServerMetaResp& operator=(const GetServerMetaResp& from) {
+    CopyFrom(from);
+    return *this;
   }
-  if (key) {
-    set_has_key();
-    key_ = key;
-  } else {
-    clear_has_key();
-    key_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
   }
-}
 
-// 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();
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
   }
-  clear_has_value();
-}
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GetServerMetaResp& default_instance();
+
+  void Swap(GetServerMetaResp* other);
+
+  // implements Message ----------------------------------------------
+
+  GetServerMetaResp* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetServerMetaResp& from);
+  void MergeFrom(const GetServerMetaResp& 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.RequestStatus status = 1;
+  inline bool has_status() const;
+  inline void clear_status();
+  static const int kStatusFieldNumber = 1;
+  inline ::exec::user::RequestStatus status() const;
+  inline void set_status(::exec::user::RequestStatus value);
+
+  // optional .exec.user.ServerMeta server_meta = 2;
+  inline bool has_server_meta() const;
+  inline void clear_server_meta();
+  static const int kServerMetaFieldNumber = 2;
+  inline const ::exec::user::ServerMeta& server_meta() const;
+  inline ::exec::user::ServerMeta* mutable_server_meta();
+  inline ::exec::user::ServerMeta* release_server_meta();
+  inline void set_allocated_server_meta(::exec::user::ServerMeta* server_meta);
+
+  // optional .exec.shared.DrillPBError error = 3;
+  inline bool has_error() const;
+  inline void clear_error();
+  static const int kErrorFieldNumber = 3;
+  inline const ::exec::shared::DrillPBError& error() const;
+  inline ::exec::shared::DrillPBError* mutable_error();
+  inline ::exec::shared::DrillPBError* release_error();
+  inline void set_allocated_error(::exec::shared::DrillPBError* error);
+
+  // @@protoc_insertion_point(class_scope:exec.user.GetServerMetaResp)
+ private:
+  inline void set_has_status();
+  inline void clear_has_status();
+  inline void set_has_server_meta();
+  inline void clear_has_server_meta();
+  inline void set_has_error();
+  inline void clear_has_error();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::exec::user::ServerMeta* server_meta_;
+  ::exec::shared::DrillPBError* error_;
+  int status_;
+
+  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 GetServerMetaResp* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ServerMeta : public ::google::protobuf::Message {
+ public:
+  ServerMeta();
+  virtual ~ServerMeta();
+
+  ServerMeta(const ServerMeta& from);
+
+  inline ServerMeta& operator=(const ServerMeta& 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 ServerMeta& default_instance();
+
+  void Swap(ServerMeta* other);
+
+  // implements Message ----------------------------------------------
+
+  ServerMeta* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ServerMeta& from);
+  void MergeFrom(const ServerMeta& 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 bool all_tables_selectable = 1;
+  inline bool has_all_tables_selectable() const;
+  inline void clear_all_tables_selectable();
+  static const int kAllTablesSelectableFieldNumber = 1;
+  inline bool all_tables_selectable() const;
+  inline void set_all_tables_selectable(bool value);
+
+  // optional bool blob_included_in_max_row_size = 2;
+  inline bool has_blob_included_in_max_row_size() const;
+  inline void clear_blob_included_in_max_row_size();
+  static const int kBlobIncludedInMaxRowSizeFieldNumber = 2;
+  inline bool blob_included_in_max_row_size() const;
+  inline void set_blob_included_in_max_row_size(bool value);
+
+  // optional bool catalog_at_start = 3;
+  inline bool has_catalog_at_start() const;
+  inline void clear_catalog_at_start();
+  static const int kCatalogAtStartFieldNumber = 3;
+  inline bool catalog_at_start() const;
+  inline void set_catalog_at_start(bool value);
+
+  // optional string catalog_separator = 4;
+  inline bool has_catalog_separator() const;
+  inline void clear_catalog_separator();
+  static const int kCatalogSeparatorFieldNumber = 4;
+  inline const ::std::string& catalog_separator() const;
+  inline void set_catalog_separator(const ::std::string& value);
+  inline void set_catalog_separator(const char* value);
+  inline void set_catalog_separator(const char* value, size_t size);
+  inline ::std::string* mutable_catalog_separator();
+  inline ::std::string* release_catalog_separator();
+  inline void set_allocated_catalog_separator(::std::string* catalog_separator);
+
+  // optional string catalog_term = 5;
+  inline bool has_catalog_term() const;
+  inline void clear_catalog_term();
+  static const int kCatalogTermFieldNumber = 5;
+  inline const ::std::string& catalog_term() const;
+  inline void set_catalog_term(const ::std::string& value);
+  inline void set_catalog_term(const char* value);
+  inline void set_catalog_term(const char* value, size_t size);
+  inline ::std::string* mutable_catalog_term();
+  inline ::std::string* release_catalog_term();
+  inline void set_allocated_catalog_term(::std::string* catalog_term);
+
+  // repeated .exec.user.CollateSupport collate_support = 6;
+  inline int collate_support_size() const;
+  inline void clear_collate_support();
+  static const int kCollateSupportFieldNumber = 6;
+  inline ::exec::user::CollateSupport collate_support(int index) const;
+  inline void set_collate_support(int index, ::exec::user::CollateSupport value);
+  inline void add_collate_support(::exec::user::CollateSupport value);
+  inline const ::google::protobuf::RepeatedField<int>& collate_support() const;
+  inline ::google::protobuf::RepeatedField<int>* mutable_collate_support();
+
+  // optional bool column_aliasing_supported = 7;
+  inline bool has_column_aliasing_supported() const;
+  inline void clear_column_aliasing_supported();
+  static const int kColumnAliasingSupportedFieldNumber = 7;
+  inline bool column_aliasing_supported() const;
+  inline void set_column_aliasing_supported(bool value);
+
+  // repeated .exec.user.ConvertSupport convert_support = 8;
+  inline int convert_support_size() const;
+  inline void clear_convert_support();
+  static const int kConvertSupportFieldNumber = 8;
+  inline const ::exec::user::ConvertSupport& convert_support(int index) const;
+  inline ::exec::user::ConvertSupport* mutable_convert_support(int index);
+  inline ::exec::user::ConvertSupport* add_convert_support();
+  inline const ::google::protobuf::RepeatedPtrField< ::exec::user::ConvertSupport >&
+      convert_support() const;
+  inline ::google::protobuf::RepeatedPtrField< ::exec::user::ConvertSupport >*
+      mutable_convert_support();
+
+  // optional .exec.user.CorrelationNamesSupport correlation_names_support = 9;
+  inline bool has_correlation_names_support() const;
+  inline void clear_correlation_names_support();
+  static const int kCorrelationNamesSupportFieldNumber = 9;
+  inline ::exec::user::CorrelationNamesSupport correlation_names_support() const;
+  inline void set_correlation_names_support(::exec::user::CorrelationNamesSupport value);
+
+  // repeated string date_time_functions = 10;
+  inline int date_time_functions_size() const;
+  inline void clear_date_time_functions();
+  static const int kDateTimeFunctionsFieldNumber = 10;
+  inline const ::std::string& date_time_functions(int index) const;
+  inline ::std::string* mutable_date_time_functions(int index);
+  inline void set_date_time_functions(int index, const ::std::string& value);
+  inline void set_date_time_functions(int index, const char* value);
+  inline void set_date_time_functions(int index, const char* value, size_t size);
+  inline ::std::string* add_date_time_functions();
+  inline void add_date_time_functions(const ::std::string& value);
+  inline void add_date_time_functions(const char* value);
+  inline void add_date_time_functions(const char* value, size_t size);
+  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& date_time_functions() const;
+  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_date_time_functions();
+
+  // repeated .exec.user.DateTimeLiteralsSupport date_time_literals_support = 11;
+  inline int date_time_literals_support_size() const;
+  inline void clear_date_time_literals_support();
+  static const int kDateTimeLiteralsSupportFieldNumber = 11;
+  inline ::exec::user::DateTimeLiteralsSupport date_time_literals_support(int index) const;
+  inline void set_date_time_literals_support(int index, ::exec::user::DateTimeLiteralsSupport value);
+  inline void add_date_time_literals_support(::exec::user::DateTimeLiteralsSupport value);
+  inline const ::google::protobuf::RepeatedField<int>& date_time_literals_support() const;
+  inline ::google::protobuf::RepeatedField<int>* mutable_date_time_literals_support();
+
+  // optional .exec.user.GroupBySupport group_by_support = 12;
+  inline bool has_group_by_support() const;
+  inline void clear_group_by_support();
+  static const int kGroupBySupportFieldNumber = 12;
+  inline ::exec::user::GroupBySupport group_by_support() const;
+  inline void set_group_by_support(::exec::user::GroupBySupport value);
+
+  // optional .exec.user.IdentifierCasing identifier_casing = 13;
+  inline bool has_identifier_casing() const;
+  inline void clear_identifier_casing();
+  static const int kIdentifierCasingFieldNumber = 13;
+  inline ::exec::user::IdentifierCasing identifier_casing() const;
+  inline void set_identifier_casing(::exec::user::IdentifierCasing value);
+
+  // optional string identifier_quote_string = 14;
+  inline bool has_identifier_quote_string() const;
+  inline void clear_identifier_quote_string();
+  static const int kIdentifierQuoteStringFieldNumber = 14;
+  inline const ::std::string& identifier_quote_string() const;
+  inline void set_identifier_quote_string(const ::std::string& value);
+  inline void set_identifier_quote_string(const char* value);
+  inline void set_identifier_quote_string(const char* value, size_t size);
+  inline ::std::string* mutable_identifier_quote_string();
+  inline ::std::string* release_identifier_quote_string();
+  inline void set_allocated_identifier_quote_string(::std::string* identifier_quote_string);
+
+  // optional bool like_escape_clause_supported = 15;
+  inline bool has_like_escape_clause_supported() const;
+  inline void clear_like_escape_clause_supported();
+  static const int kLikeEscapeClauseSupportedFieldNumber = 15;
+  inline bool like_escape_clause_supported() const;
+  inline void set_like_escape_clause_supported(bool value);
+
+  // optional uint32 max_binary_literal_length = 16;
+  inline bool has_max_binary_literal_length() const;
+  inline void clear_max_binary_literal_length();
+  static const int kMaxBinaryLiteralLengthFieldNumber = 16;
+  inline ::google::protobuf::uint32 max_binary_literal_length() const;
+  inline void set_max_binary_literal_length(::google::protobuf::uint32 value);
+
+  // optional uint32 max_catalog_name_length = 17;
+  inline bool has_max_catalog_name_length() const;
+  inline void clear_max_catalog_name_length();
+  static const int kMaxCatalogNameLengthFieldNumber = 17;
+  inline ::google::protobuf::uint32 max_catalog_name_length() const;
+  inline void set_max_catalog_name_length(::google::protobuf::uint32 value);
+
+  // optional uint32 max_char_literal_length = 18;
+  inline bool has_max_char_literal_length() const;
+  inline void clear_max_char_literal_length();
+  static const int kMaxCharLiteralLengthFieldNumber = 18;
+  inline ::google::protobuf::uint32 max_char_literal_length() const;
+  inline void set_max_char_literal_length(::google::protobuf::uint32 value);
+
+  // optional uint32 max_column_name_length = 19;
+  inline bool has_max_column_name_length() const;
+  inline void clear_max_column_name_length();
+  static const int kMaxColumnNameLengthFieldNumber = 19;
+  inline ::google::protobuf::uint32 max_column_name_length() const;
+  inline void set_max_column_name_length(::google::protobuf::uint32 value);
+
+  // optional uint32 max_columns_in_group_by = 20;
+  inline bool has_max_columns_in_group_by() const;
+  inline void clear_max_columns_in_group_by();
+  static const int kMaxColumnsInGroupByFieldNumber = 20;
+  inline ::google::protobuf::uint32 max_columns_in_group_by() const;
+  inline void set_max_columns_in_group_by(::google::protobuf::uint32 value);
+
+  // optional uint32 max_columns_in_order_by = 21;
+  inline bool has_max_columns_in_order_by() const;
+  inline void clear_max_columns_in_order_by();
+  static const int kMaxColumnsInOrderByFieldNumber = 21;
+  inline ::google::protobuf::uint32 max_columns_in_order_by() const;
+  inline void set_max_columns_in_order_by(::google::protobuf::uint32 value);
+
+  // optional uint32 max_columns_in_select = 22;
+  inline bool has_max_columns_in_select() const;
+  inline void clear_max_columns_in_select();
+  static const int kMaxColumnsInSelectFieldNumber = 22;
+  inline ::google::protobuf::uint32 max_columns_in_select() const;
+  inline void set_max_columns_in_select(::google::protobuf::uint32 value);
+
+  // optional uint32 max_cursor_name_length = 23;
+  inline bool has_max_cursor_name_length() const;
+  inline void clear_max_cursor_name_length();
+  static const int kMaxCursorNameLengthFieldNumber = 23;
+  inline ::google::protobuf::uint32 max_cursor_name_length() const;
+  inline void set_max_cursor_name_length(::google::protobuf::uint32 value);
+
+  // optional uint32 max_logical_lob_size = 24;
+  inline bool has_max_logical_lob_size() const;
+  inline void clear_max_logical_lob_size();
+  static const int kMaxLogicalLobSizeFieldNumber = 24;
+  inline ::google::protobuf::uint32 max_logical_lob_size() const;
+  inline void set_max_logical_lob_size(::google::protobuf::uint32 value);
+
+  // optional uint32 max_row_size = 25;
+  inline bool has_max_row_size() const;
+  inline void clear_max_row_size();
+  static const int kMaxRowSizeFieldNumber = 25;
+  inline ::google::protobuf::uint32 max_row_size() const;
+  inline void set_max_row_size(::google::protobuf::uint32 value);
+
+  // optional uint32 max_schema_name_length = 26;
+  inline bool has_max_schema_name_length() const;
+  inline void clear_max_schema_name_length();
+  static const int kMaxSchemaNameLengthFieldNumber = 26;
+  inline ::google::protobuf::uint32 max_schema_name_length() const;
+  inline void set_max_schema_name_length(::google::protobuf::uint32 value);
+
+  // optional uint32 max_statement_length = 27;
+  inline bool has_max_statement_length() const;
+  inline void clear_max_statement_length();
+  static const int kMaxStatementLengthFieldNumber = 27;
+  inline ::google::protobuf::uint32 max_statement_length() const;
+  inline void set_max_statement_length(::google::protobuf::uint32 value);
+
+  // optional uint32 max_statements = 28;
+  inline bool has_max_statements() const;
+  inline void clear_max_statements();
+  static const int kMaxStatementsFieldNumber = 28;
+  inline ::google::protobuf::uint32 max_statements() const;
+  inline void set_max_statements(::google::protobuf::uint32 value);
+
+  // optional uint32 max_table_name_length = 29;
+  inline bool has_max_table_name_length() const;
+  inline void clear_max_table_name_length();
+  static const int kMaxTableNameLengthFieldNumber = 29;
+  inline ::google::protobuf::uint32 max_table_name_length() const;
+  inline void set_max_table_name_length(::google::protobuf::uint32 value);
+
+  // optional uint32 max_tables_in_select = 30;
+  inline bool has_max_tables_in_select() const;
+  inline void clear_max_tables_in_select();
+  static const int kMaxTablesInSelectFieldNumber = 30;
+  inline ::google::protobuf::uint32 max_tables_in_select() const;
+  inline void set_max_tables_in_select(::google::protobuf::uint32 value);
+
+  // optional uint32 max_user_name_length = 31;
+  inline bool has_max_user_name_length() const;
+  inline void clear_max_user_name_length();
+  static const int kMaxUserNameLengthFieldNumber = 31;
+  inline ::google::protobuf::uint32 max_user_name_length() const;
+  inline void set_max_user_name_length(::google::protobuf::uint32 value);
+
+  // optional .exec.user.NullCollation null_collation = 32;
+  inline bool has_null_collation() const;
+  inline void clear_null_collation();
+  static const int kNullCollationFieldNumber = 32;
+  inline ::exec::user::NullCollation null_collation() const;
+  inline void set_null_collation(::exec::user::NullCollation value);
+
+  // optional bool null_plus_non_null_equals_null = 33;
+  inline bool has_null_plus_non_null_equals_null() const;
+  inline void clear_null_plus_non_null_equals_null();
+  static const int kNullPlusNonNullEqualsNullFieldNumber = 33;
+  inline bool null_plus_non_null_equals_null() const;
+  inline void set_null_plus_non_null_equals_null(bool value);
+
+  // repeated string numeric_functions = 34;
+  inline int numeric_functions_size() const;
+  inline void clear_numeric_functions();
+  static const int kNumericFunctionsFieldNumber = 34;
+  inline const ::std::string& numeric_functions(int index) const;
+  inline ::std::string* mutable_numeric_functions(int index);
+  inline void set_numeric_functions(int index, const ::std::string& value);
+  inline void set_numeric_functions(int index, const char* value);
+  inline void set_numeric_functions(int index, const char* value, size_t size);
+  inline ::std::string* add_numeric_functions();
+  inline void add_numeric_functions(const ::std::string& value);
+  inline void add_numeric_functions(const char* value);
+  inline void add_numeric_functions(const char* value, size_t size);
+  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& numeric_functions() const;
+  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_numeric_functions();
+
+  // repeated .exec.user.OrderBySupport order_by_support = 35;
+  inline int order_by_support_size() const;
+  inline void clear_order_by_support();
+  static const int kOrderBySupportFieldNumber = 35;
+  inline ::exec::user::OrderBySupport order_by_support(int index) const;
+  inline void set_order_by_support(int index, ::exec::user::OrderBySupport value);
+  inline void add_order_by_support(::exec::user::OrderBySupport value);
+  inline const ::google::protobuf::RepeatedField<int>& order_by_support() const;
+  inline ::google::protobuf::RepeatedField<int>* mutable_order_by_support();
+
+  // repeated .exec.user.OuterJoinSupport outer_join_support = 36;
+  inline int outer_join_support_size() const;
+  inline void clear_outer_join_support();
+  static const int kOuterJoinSupportFieldNumber = 36;
+  inline ::exec::user::OuterJoinSupport outer_join_support(int index) const;
+  inline void set_outer_join_support(int index, ::exec::user::OuterJoinSupport value);
+  inline void add_outer_join_support(::exec::user::OuterJoinSupport value);
+  inline const ::google::protobuf::RepeatedField<int>& outer_join_support() const;
+  inline ::google::protobuf::RepeatedField<int>* mutable_outer_join_support();
+
+  // optional .exec.user.IdentifierCasing quoted_identifier_casing = 37;
+  inline bool has_quoted_identifier_casing() const;
+  inline void clear_quoted_identifier_casing();
+  static const int kQuotedIdentifierCasingFieldNumber = 37;
+  inline ::exec::user::IdentifierCasing quoted_identifier_casing() const;
+  inline void set_quoted_identifier_casing(::exec::user::IdentifierCasing value);
+
+  // optional bool read_only = 38;
+  inline bool has_read_only() const;
+  inline void clear_read_only();
+  static const int kReadOnlyFieldNumber = 38;
+  inline bool read_only() const;
+  inline void set_read_only(bool value);
+
+  // optional string schema_term = 39;
+  inline bool has_schema_term() const;
+  inline void clear_schema_term();
+  static const int kSchemaTermFieldNumber = 39;
+  inline const ::std::string& schema_term() const;
+  inline void set_schema_term(const ::std::string& value);
+  inline void set_schema_term(const char* value);
+  inline void set_schema_term(const char* value, size_t size);
+  inline ::std::string* mutable_schema_term();
+  inline ::std::string* release_schema_term();
+  inline void set_allocated_schema_term(::std::string* schema_term);
+
+  // optional string search_escape_string = 40;
+  inline bool has_search_escape_string() const;
+  inline void clear_search_escape_string();
+  static const int kSearchEscapeStringFieldNumber = 40;
+  inline const ::std::string& search_escape_string() const;
+  inline void set_search_escape_string(const ::std::string& value);
+  inline void set_search_escape_string(const char* value);
+  inline void set_search_escape_string(const char* value, size_t size);
+  inline ::std::string* mutable_search_escape_string();
+  inline ::std::string* release_search_escape_string();
+  inline void set_allocated_search_escape_string(::std::string* search_escape_string);
+
+  // optional bool select_for_update_supported = 41;
+  inline bool has_select_for_update_supported() const;
+  inline void clear_select_for_update_supported();
+  static const int kSelectForUpdateSupportedFieldNumber = 41;
+  inline bool select_for_update_supported() const;
+  inline void set_select_for_update_supported(bool value);
+
+  // optional string special_characters = 42;
+  inline bool has_special_characters() const;
+  inline void clear_special_characters();
+  static const int kSpecialCharactersFieldNumber = 42;
+  inline const ::std::string& special_characters() const;
+  inline void set_special_characters(const ::std::string& value);
+  inline void set_special_characters(const char* value);
+  inline void set_special_characters(const char* value, size_t size);
+  inline ::std::string* mutable_special_characters();
+  inline ::std::string* release_special_characters();
+  inline void set_allocated_special_characters(::std::string* special_characters);
+
+  // repeated string sql_keywords = 43;
+  inline int sql_keywords_size() const;
+  inline void clear_sql_keywords();
+  static const int kSqlKeywordsFieldNumber = 43;
+  inline const ::std::string& sql_keywords(int index) const;
+  inline ::std::string* mutable_sql_keywords(int index);
+  inline void set_sql_keywords(int index, const ::std::string& value);
+  inline void set_sql_keywords(int index, const char* value);
+  inline void set_sql_keywords(int index, const char* value, size_t size);
+  inline ::std::string* add_sql_keywords();
+  inline void add_sql_keywords(const ::std::string& value);
+  inline void add_sql_keywords(const char* value);
+  inline void add_sql_keywords(const char* value, size_t size);
+  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& sql_keywords() const;
+  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_sql_keywords();
+
+  // repeated string string_functions = 44;
+  inline int string_functions_size() const;
+  inline void clear_string_functions();
+  static const int kStringFunctionsFieldNumber = 44;
+  inline const ::std::string& string_functions(int index) const;
+  inline ::std::string* mutable_string_functions(int index);
+  inline void set_string_functions(int index, const ::std::string& value);
+  inline void set_string_functions(int index, const char* value);
+  inline void set_string_functions(int index, const char* value, size_t size);
+  inline ::std::string* add_string_functions();
+  inline void add_string_functions(const ::std::string& value);
+  inline void add_string_functions(const char* value);
+  inline void add_string_functions(const char* value, size_t size);
+  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& string_functions() const;
+  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_string_functions();
+
+  // repeated .exec.user.SubQuerySupport subquery_support = 45;
+  inline int subquery_support_size() const;
+  inline void clear_subquery_support();
+  static const int kSubquerySupportFieldNumber = 45;
+  inline ::exec::user::SubQuerySupport subquery_support(int index) const;
+  inline void set_subquery_support(int index, ::exec::user::SubQuerySupport value);
+  inline void add_subquery_support(::exec::user::SubQuerySupport value);
+  inline const ::google::protobuf::RepeatedField<int>& subquery_support() const;
+  inline ::google::protobuf::RepeatedField<int>* mutable_subquery_support();
+
+  // repeated string system_functions = 46;
+  inline int system_functions_size() const;
+  inline void clear_system_functions();
+  static const int kSystemFunctionsFieldNumber = 46;
+  inline const ::std::string& system_functions(int index) const;
+  inline ::std::string* mutable_system_functions(int index);
+  inline void set_system_functions(int index, const ::std::string& value);
+  inline void set_system_functions(int index, const char* value);
+  inline void set_system_functions(int index, const char* value, size_t size);
+  inline ::std::string* add_system_functions();
+  inline void add_system_functions(const ::std::string& value);
+  inline void add_system_functions(const char* value);
+  inline void add_system_functions(const char* value, size_t size);
+  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& system_functions() const;
+  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_system_functions();
+
+  // optional string table_term = 47;
+  inline bool has_table_term() const;
+  inline void clear_table_term();
+  static const int kTableTermFieldNumber = 47;
+  inline const ::std::string& table_term() const;
+  inline void set_table_term(const ::std::string& value);
+  inline void set_table_term(const char* value);
+  inline void set_table_term(const char* value, size_t size);
+  inline ::std::string* mutable_table_term();
+  inline ::std::string* release_table_term();
+  inline void set_allocated_table_term(::std::string* table_term);
+
+  // optional bool transaction_supported = 48;
+  inline bool has_transaction_supported() const;
+  inline void clear_transaction_supported();
+  static const int kTransactionSupportedFieldNumber = 48;
+  inline bool transaction_supported() const;
+  inline void set_transaction_supported(bool value);
+
+  // repeated .exec.user.UnionSupport union_support = 49;
+  inline int union_support_size() const;
+  inline void clear_union_support();
+  static const int kUnionSupportFieldNumber = 49;
+  inline ::exec::user::UnionSupport union_support(int index) const;
+  inline void set_union_support(int index, ::exec::user::UnionSupport value);
+  inline void add_union_support(::exec::user::UnionSupport value);
+  inline const ::google::protobuf::RepeatedField<int>& union_support() const;
+  inline ::google::protobuf::RepeatedField<int>* mutable_union_support();
+
+  // @@protoc_insertion_point(class_scope:exec.user.ServerMeta)
+ private:
+  inline void set_has_all_tables_selectable();
+  inline void clear_has_all_tables_selectable();
+  inline void set_has_blob_included_in_max_row_size();
+  inline void clear_has_blob_included_in_max_row_size();
+  inline void set_has_catalog_at_start();
+  inline void clear_has_catalog_at_start();
+  inline void set_has_catalog_separator();
+  inline void clear_has_catalog_separator();
+  inline void set_has_catalog_term();
+  inline void clear_has_catalog_term();
+  inline void set_has_column_aliasing_supported();
+  inline void clear_has_column_aliasing_supported();
+  inline void set_has_correlation_names_support();
+  inline void clear_has_correlation_names_support();
+  inline void set_has_group_by_support();
+  inline void clear_has_group_by_support();
+  inline void set_has_identifier_casing();
+  inline void clear_has_identifier_casing();
+  inline void set_has_identifier_quote_string();
+  inline void clear_has_identifier_quote_string();
+  inline void set_has_like_escape_clause_supported();
+  inline void clear_has_like_escape_clause_supported();
+  inline void set_has_max_binary_literal_length();
+  inline void clear_has_max_binary_literal_length();
+  inline void set_has_max_catalog_name_length();
+  inline void clear_has_max_catalog_name_length();
+  inline void set_has_max_char_literal_length();
+  inline void clear_has_max_char_literal_length();
+  inline void set_has_max_column_name_length();
+  inline void clear_has_max_column_name_length();
+  inline void set_has_max_columns_in_group_by();
+  inline void clear_has_max_columns_in_group_by();
+  inline void set_has_max_columns_in_order_by();
+  inline void clear_has_max_columns_in_order_by();
+  inline void set_has_max_columns_in_select();
+  inline void clear_has_max_columns_in_select();
+  inline void set_has_max_cursor_name_length();
+  inline void clear_has_max_cursor_name_length();
+  inline void set_has_max_logical_lob_size();
+  inline void clear_has_max_logical_lob_size();
+  inline void set_has_max_row_size();
+  inline void clear_has_max_row_size();
+  inline void set_has_max_schema_name_length();
+  inline void clear_has_max_schema_name_length();
+  inline void set_has_max_statement_length();
+  inline void clear_has_max_statement_length();
+  inline void set_has_max_statements();
+  inline void clear_has_max_statements();
+  inline void set_has_max_table_name_length();
+  inline void clear_has_max_table_name_length();
+  inline void set_has_max_tables_in_select();
+  inline void clear_has_max_tables_in_select();
+  inline void set_has_max_user_name_length();
+  inline void clear_has_max_user_name_length();
+  inline void set_has_null_collation();
+  inline void clear_has_null_collation();
+  inline void set_has_null_plus_non_null_equals_null();
+  inline void clear_has_null_plus_non_null_equals_null();
+  inline void set_has_quoted_identifier_casing();
+  inline void clear_has_quoted_identifier_casing();
+  inline void set_has_read_only();
+  inline void clear_has_read_only();
+  inline void set_has_schema_term();
+  inline void clear_has_schema_term();
+  inline void set_has_search_escape_string();
+  inline void clear_has_search_escape_string();
+  inline void set_has_select_for_update_supported();
+  inline void clear_has_select_for_update_supported();
+  inline void set_has_special_characters();
+  inline void clear_has_special_characters();
+  inline void set_has_table_term();
+  inline void clear_has_table_term();
+  inline void set_has_transaction_supported();
+  inline void clear_has_transaction_supported();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::std::string* catalog_separator_;
+  bool all_tables_selectable_;
+  bool blob_included_in_max_row_size_;
+  bool catalog_at_start_;
+  bool column_aliasing_supported_;
+  int correlation_names_support_;
+  ::std::string* catalog_term_;
+  ::google::protobuf::RepeatedField<int> collate_support_;
+  ::google::protobuf::RepeatedPtrField< ::exec::user::ConvertSupport > convert_support_;
+  ::google::protobuf::RepeatedPtrField< ::std::string> date_time_functions_;
+  ::google::protobuf::RepeatedField<int> date_time_literals_support_;
+  int group_by_support_;
+  int identifier_casing_;
+  ::std::string* identifier_quote_string_;
+  ::google::protobuf::uint32 max_binary_literal_length_;
+  ::google::protobuf::uint32 max_catalog_name_length_;
+  ::google::protobuf::uint32 max_char_literal_length_;
+  ::google::protobuf::uint32 max_column_name_length_;
+  ::google::protobuf::uint32 max_columns_in_group_by_;
+  ::google::protobuf::uint32 max_columns_in_order_by_;
+  ::google::protobuf::uint32 max_columns_in_select_;
+  ::google::protobuf::uint32 max_cursor_name_length_;
+  ::google::protobuf::uint32 max_logical_lob_size_;
+  ::google::protobuf::uint32 max_row_size_;
+  ::google::protobuf::uint32 max_schema_name_length_;
+  ::google::protobuf::uint32 max_statement_length_;
+  ::google::protobuf::uint32 max_statements_;
+  ::google::protobuf::uint32 max_table_name_length_;
+  ::google::protobuf::uint32 max_tables_in_select_;
+  ::google::protobuf::uint32 max_user_name_length_;
+  bool like_escape_clause_supported_;
+  bool null_plus_non_null_equals_null_;
+  bool read_only_;
+  bool select_for_update_supported_;
+  int null_collation_;
+  ::google::protobuf::RepeatedPtrField< ::std::string> numeric_functions_;
+  ::google::protobuf::RepeatedField<int> order_by_support_;
+  ::google::protobuf::RepeatedField<int> outer_join_support_;
+  ::std::string* schema_term_;
+  ::std::string* search_escape_string_;
+  ::std::string* special_characters_;
+  int quoted_identifier_casing_;
+  bool transaction_supported_;
+  ::google::protobuf::RepeatedPtrField< ::std::string> sql_keywords_;
+  ::google::protobuf::RepeatedPtrField< ::std::string> string_functions_;
+  ::google::protobuf::RepeatedField<int> subquery_support_;
+  ::google::protobuf::RepeatedPtrField< ::std::string> system_functions_;
+  ::std::string* table_term_;
+  ::google::protobuf::RepeatedField<int> union_support_;
+
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(49 + 31) / 32];
+
+  friend void  protobuf_AddDesc_User_2eproto();
+  friend void protobuf_AssignDesc_User_2eproto();
+  friend void protobuf_ShutdownFile_User_2eproto();
+
+  void InitAsDefaultInstance();
+  static ServerMeta* 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.shared.QueryType type = 2;
+  inline bool has_type() const;
+  inline void clear_type();
+  static const int kTypeFieldNumber = 2;
+  inline ::exec::shared::QueryType type() const;
+  inline void set_type(::exec::shared::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);
+
+  // repeated .exec.bit.control.PlanFragment fragments = 4;
+  inline int fragments_size() const;
+  inline void clear_fragments();
+  static const int kFragmentsFieldNumber = 4;
+  inline const ::exec::bit::control::PlanFragment& fragments(int index) const;
+  inline ::exec::bit::control::PlanFragment* mutable_fragments(int index);
+  inline ::exec::bit::control::PlanFragment* add_fragments();
+  inline const ::google::protobuf::RepeatedPtrField< ::exec::bit::control::PlanFragment >&
+      fragments() const;
+  inline ::google::protobuf::RepeatedPtrField< ::exec::bit::control::PlanFragment >*
+      mutable_fragments();
+
+  // optional .exec.user.PreparedStatementHandle prepared_statement_handle = 5;
+  inline bool has_prepared_statement_handle() const;
+  inline void clear_prepared_statement_handle();
+  static const int kPreparedStatementHandleFieldNumber = 5;
+  inline const ::exec::user::PreparedStatementHandle& prepared_statement_handle() const;
+  inline ::exec::user::PreparedStatementHandle* mutable_prepared_statement_handle();
+  inline ::exec::user::PreparedStatementHandle* release_prepared_statement_handle();
+  inline void set_allocated_prepared_statement_handle(::exec::user::PreparedStatementHandle* prepared_statement_handle);
+
+  // @@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();
+  inline void set_has_prepared_statement_handle();
+  inline void clear_has_prepared_statement_handle();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  int results_mode_;
+  int type_;
+  ::std::string* plan_;
+  ::google::protobuf::RepeatedPtrField< ::exec::bit::control::PlanFragment > fragments_;
+  ::exec::user::PreparedStatementHandle* prepared_statement_handle_;
+
+  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 RunQuery* 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;
+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_;
+}
+
+// -------------------------------------------------------------------
+
+// RpcEndpointInfos
+
+// optional string name = 1;
+inline bool RpcEndpointInfos::has_name() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void RpcEndpointInfos::set_has_name() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void RpcEndpointInfos::clear_has_name() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void RpcEndpointInfos::clear_name() {
+  if (name_ != &::google::protobuf::internal::kEmptyString) {
+    name_->clear();
+  }
+  clear_has_name();
+}
+inline const ::std::string& RpcEndpointInfos::name() const {
+  return *name_;
+}
+inline void RpcEndpointInfos::set_name(const ::std::string& value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::kEmptyString) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+}
+inline void RpcEndpointInfos::set_name(const char* value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::kEmptyString) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+}
+inline void RpcEndpointInfos::set_name(const char* value, size_t size) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::kEmptyString) {
+    name_ = new ::std::string;
+  }
+  name_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* RpcEndpointInfos::mutable_name() {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::kEmptyString) {
+    name_ = new ::std::string;
+  }
+  return name_;
+}
+inline ::std::string* RpcEndpointInfos::release_name() {
+  clear_has_name();
+  if (name_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = name_;
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void RpcEndpointInfos::set_allocated_name(::std::string* name) {
+  if (name_ != &::google::protobuf::internal::kEmptyString) {
+    delete name_;
+  }
+  if (name) {
+    set_has_name();
+    name_ = name;
+  } else {
+    clear_has_name();
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// optional string version = 2;
+inline bool RpcEndpointInfos::has_version() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void RpcEndpointInfos::set_has_version() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void RpcEndpointInfos::clear_has_version() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void RpcEndpointInfos::clear_version() {
+  if (version_ != &::google::protobuf::internal::kEmptyString) {
+    version_->clear();
+  }
+  clear_has_version();
+}
+inline const ::std::string& RpcEndpointInfos::version() const {
+  return *version_;
+}
+inline void RpcEndpointInfos::set_version(const ::std::string& value) {
+  set_has_version();
+  if (version_ == &::google::protobuf::internal::kEmptyString) {
+    version_ = new ::std::string;
+  }
+  version_->assign(value);
+}
+inline void RpcEndpointInfos::set_version(const char* value) {
+  set_has_version();
+  if (version_ == &::google::protobuf::internal::kEmptyString) {
+    version_ = new ::std::string;
+  }
+  version_->assign(value);
+}
+inline void RpcEndpointInfos::set_version(const char* value, size_t size) {
+  set_has_version();
+  if (version_ == &::google::protobuf::internal::kEmptyString) {
+    version_ = new ::std::string;
+  }
+  version_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* RpcEndpointInfos::mutable_version() {
+  set_has_version();
+  if (version_ == &::google::protobuf::internal::kEmptyString) {
+    version_ = new ::std::string;
+  }
+  return version_;
+}
+inline ::std::string* RpcEndpointInfos::release_version() {
+  clear_has_version();
+  if (version_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = version_;
+    version_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void RpcEndpointInfos::set_allocated_version(::std::string* version) {
+  if (version_ != &::google::protobuf::internal::kEmptyString) {
+    delete version_;
+  }
+  if (version) {
+    set_has_version();
+    version_ = version;
+  } else {
+    clear_has_version();
+    version_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// optional uint32 majorVersion = 3;
+inline bool RpcEndpointInfos::has_majorversion() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void RpcEndpointInfos::set_has_majorversion() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void RpcEndpointInfos::clear_has_majorversion() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void RpcEndpointInfos::clear_majorversion() {
+  majorversion_ = 0u;
+  clear_has_majorversion();
+}
+inline ::google::protobuf::uint32 RpcEndpointInfos::majorversion() const {
+  return majorversion_;
+}
+inline void RpcEndpointInfos::set_majorversion(::google::protobuf::uint32 value) {
+  set_has_majorversion();
+  majorversion_ = value;
+}
+
+// optional uint32 minorVersion = 4;
+inline bool RpcEndpointInfos::has_minorversion() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void RpcEndpointInfos::set_has_minorversion() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void RpcEndpointInfos::clear_has_minorversion() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void RpcEndpointInfos::clear_minorversion() {
+  minorversion_ = 0u;
+  clear_has_minorversion();
+}
+inline ::google::protobuf::uint32 RpcEndpointInfos::minorversion() const {
+  return minorversion_;
+}
+inline void RpcEndpointInfos::set_minorversion(::google::protobuf::uint32 value) {
+  set_has_minorversion();
+  minorversion_ = value;
+}
+
+// optional uint32 patchVersion = 5;
+inline bool RpcEndpointInfos::has_patchversion() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void RpcEndpointInfos::set_has_patchversion() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void RpcEndpointInfos::clear_has_patchversion() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void RpcEndpointInfos::clear_patchversion() {
+  patchversion_ = 0u;
+  clear_has_patchversion();
+}
+inline ::google::protobuf::uint32 RpcEndpointInfos::patchversion() const {
+  return patchversion_;
+}
+inline void RpcEndpointInfos::set_patchversion(::google::protobuf::uint32 value) {
+  set_has_patchversion();
+  patchversion_ = value;
+}
+
+// optional string application = 6;
+inline bool RpcEndpointInfos::has_application() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void RpcEndpointInfos::set_has_application() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void RpcEndpointInfos::clear_has_application() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void RpcEndpointInfos::clear_application() {
+  if (application_ != &::google::protobuf::internal::kEmptyString) {
+    application_->clear();
+  }
+  clear_has_application();
+}
+inline const ::std::string& RpcEndpointInfos::application() const {
+  return *application_;
+}
+inline void RpcEndpointInfos::set_application(const ::std::string& value) {
+  set_has_application();
+  if (application_ == &::google::protobuf::internal::kEmptyString) {
+    application_ = new ::std::string;
+  }
+  application_->assign(value);
+}
+inline void RpcEndpointInfos::set_application(const char* value) {
+  set_has_application();
+  if (application_ == &::google::protobuf::internal::kEmptyString) {
+    application_ = new ::std::string;
+  }
+  application_->assign(value);
+}
+inline void RpcEndpointInfos::set_application(const char* value, size_t size) {
+  set_has_application();
+  if (application_ == &::google::protobuf::internal::kEmptyString) {
+    application_ = new ::std::string;
+  }
+  application_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* RpcEndpointInfos::mutable_application() {
+  set_has_application();
+  if (application_ == &::google::protobuf::internal::kEmptyString) {
+    application_ = new ::std::string;
+  }
+  return application_;
+}
+inline ::std::string* RpcEndpointInfos::release_application() {
+  clear_has_application();
+  if (application_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = application_;
+    application_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void RpcEndpointInfos::set_allocated_application(::std::string* application) {
+  if (application_ != &::google::protobuf::internal::kEmptyString) {
+    delete application_;
+  }
+  if (application) {
+    set_has_application();
+    application_ = application;
+  } else {
+    clear_has_application();
+    application_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// optional uint32 buildNumber = 7;
+inline bool RpcEndpointInfos::has_buildnumber() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void RpcEndpointInfos::set_has_buildnumber() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void RpcEndpointInfos::clear_has_buildnumber() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void RpcEndpointInfos::clear_buildnumber() {
+  buildnumber_ = 0u;
+  clear_has_buildnumber();
+}
+inline ::google::protobuf::uint32 RpcEndpointInfos::buildnumber() const {
+  return buildnumber_;
+}
+inline void RpcEndpointInfos::set_buildnumber(::google::protobuf::uint32 value) {
+  set_has_buildnumber();
+  buildnumber_ = value;
+}
+
+// optional string versionQualifier = 8;
+inline bool RpcEndpointInfos::has_versionqualifier() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void RpcEndpointInfos::set_has_versionqualifier() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void RpcEndpointInfos::clear_has_versionqualifier() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void RpcEndpointInfos::clear_versionqualifier() {
+  if (versionqualifier_ != &::google::protobuf::internal::kEmptyString) {
+    versionqualifier_->clear();
+  }
+  clear_has_versionqualifier();
+}
+inline const ::std::string& RpcEndpointInfos::versionqualifier() const {
+  return *versionqualifier_;
+}
+inline void RpcEndpointInfos::set_versionqualifier(const ::std::string& value) {
+  set_has_versionqualifier();
+  if (versionqualifier_ == &::google::protobuf::internal::kEmptyString) {
+    versionqualifier_ = new ::std::string;
+  }
+  versionqualifier_->assign(value);
+}
+inline void RpcEndpointInfos::set_versionqualifier(const char* value) {
+  set_has_versionqualifier();
+  if (versionqualifier_ == &::google::protobuf::internal::kEmptyString) {
+    versionqualifier_ = new ::std::string;
+  }
+  versionqualifier_->assign(value);
+}
+inline void RpcEndpointInfos::set_versionqualifier(const char* value, size_t size) {
+  set_has_versionqualifier();
+  if (versionqualifier_ == &::google::protobuf::internal::kEmptyString) {
+    versionqualifier_ = new ::std::string;
+  }
+  versionqualifier_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* RpcEndpointInfos::mutable_versionqualifier() {
+  set_has_versionqualifier();
+  if (versionqualifier_ == &::google::protobuf::internal::kEmptyString) {
+    versionqualifier_ = new ::std::string;
+  }
+  return versionqualifier_;
+}
+inline ::std::string* RpcEndpointInfos::release_versionqualifier() {
+  clear_has_versionqualifier();
+  if (versionqualifier_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = versionqualifier_;
+    versionqualifier_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void RpcEndpointInfos::set_allocated_versionqualifier(::std::string* versionqualifier) {
+  if (versionqualifier_ != &::google::protobuf::internal::kEmptyString) {
+    delete versionqualifier_;
+  }
+  if (versionqualifier) {
+    set_has_versionqualifier();
+    versionqualifier_ = versionqualifier;
+  } else {
+    clear_has_versionqualifier();
+    versionqualifier_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// -------------------------------------------------------------------
+
+// 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();
+  }
+}
+
+// optional bool support_complex_types = 6 [default = false];
+inline bool UserToBitHandshake::has_support_complex_types() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void UserToBitHandshake::set_has_support_complex_types() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void UserToBitHandshake::clear_has_support_complex_types() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void UserToBitHandshake::clear_support_complex_types() {
+  support_complex_types_ = false;
+  clear_has_support_complex_types();
+}
+inline bool UserToBitHandshake::support_complex_types() const {
+  return support_complex_types_;
+}
+inline void UserToBitHandshake::set_support_complex_types(bool value) {
+  set_has_support_complex_types();
+  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;
+}
+
+// optional .exec.user.RpcEndpointInfos client_infos = 8;
+inline bool UserToBitHandshake::has_client_infos() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void UserToBitHandshake::set_has_client_infos() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void UserToBitHandshake::clear_has_client_infos() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void UserToBitHandshake::clear_client_infos() {
+  if (client_infos_ != NULL) client_infos_->::exec::user::RpcEndpointInfos::Clear();
+  clear_has_client_infos();
+}
+inline const ::exec::user::RpcEndpointInfos& UserToBitHandshake::client_infos() const {
+  return client_infos_ != NULL ? *client_infos_ : *default_instance_->client_infos_;
+}
+inline ::exec::user::RpcEndpointInfos* UserToBitHandshake::mutable_client_infos() {
+  set_has_client_infos();
+  if (client_infos_ == NULL) client_infos_ = new ::exec::user::RpcEndpointInfos;
+  return client_infos_;
+}
+inline ::exec::user::RpcEndpointInfos* UserToBitHandshake::release_client_infos() {
+  clear_has_client_infos();
+  ::exec::user::RpcEndpointInfos* temp = client_infos_;
+  client_infos_ = NULL;
+  return temp;
+}
+inline void UserToBitHandshake::set_allocated_client_infos(::exec::user::RpcEndpointInfos* client_infos) {
+  delete client_infos_;
+  client_infos_ = client_infos;
+  if (client_infos) {
+    set_has_client_infos();
+  } else {
+    clear_has_client_infos();
+  }
+}
+
+// optional .exec.user.SaslSupport sasl_support = 9;
+inline bool UserToBitHandshake::has_sasl_support() const {
+  return (_has_bits_[0] & 0x00000100u) != 0;
+}
+inline void UserToBitHandshake::set_has_sasl_support() {
+  _has_bits_[0] |= 0x00000100u;
+}
+inline void UserToBitHandshake::clear_has_sasl_support() {
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline void UserToBitHandshake::clear_sasl_support() {
+  sasl_support_ = 0;
+  clear_has_sasl_support();
+}
+inline ::exec::user::SaslSupport UserToBitHandshake::sasl_support() const {
+  return static_cast< ::exec::user::SaslSupport >(sasl_support_);
+}
+inline void UserToBitHandshake::set_sasl_support(::exec::user::SaslSupport value) {
+  assert(::exec::user::SaslSupport_IsValid(value));
+  set_has_sasl_support();
+  sasl_support_ = value;
+}
+
+// -------------------------------------------------------------------
+
+// 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::maximu

<TRUNCATED>

Mime
View raw message