You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@drill.apache.org by jn...@apache.org on 2017/03/02 20:59:33 UTC
[06/27] drill git commit: DRILL-5301: Add C++ client support for
Server metadata API
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>