drill-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From par...@apache.org
Subject [07/15] drill git commit: DRILL-4853: Update C++ protobuf source files
Date Tue, 01 Nov 2016 20:29:52 GMT
http://git-wip-us.apache.org/repos/asf/drill/blob/2558803e/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 8628a54..162c6e0 100644
--- a/contrib/native/client/src/protobuf/User.pb.h
+++ b/contrib/native/client/src/protobuf/User.pb.h
@@ -27,6 +27,9 @@
 #include <google/protobuf/unknown_field_set.h>
 #include "SchemaDef.pb.h"
 #include "UserBitShared.pb.h"
+#include "BitData.pb.h"
+#include "BitControl.pb.h"
+#include "ExecutionProtos.pb.h"
 // @@protoc_insertion_point(includes)
 
 namespace exec {
@@ -39,10 +42,31 @@ void protobuf_ShutdownFile_User_2eproto();
 
 class Property;
 class UserProperties;
+class RpcEndpointInfos;
 class UserToBitHandshake;
 class RequestResults;
-class RunQuery;
+class GetQueryPlanFragments;
+class QueryPlanFragments;
 class BitToUserHandshake;
+class LikeFilter;
+class GetCatalogsReq;
+class CatalogMetadata;
+class GetCatalogsResp;
+class GetSchemasReq;
+class SchemaMetadata;
+class GetSchemasResp;
+class GetTablesReq;
+class TableMetadata;
+class GetTablesResp;
+class GetColumnsReq;
+class ColumnMetadata;
+class GetColumnsResp;
+class CreatePreparedStatementReq;
+class ResultColumnMetadata;
+class PreparedStatementHandle;
+class PreparedStatement;
+class CreatePreparedStatementResp;
+class RunQuery;
 
 enum RpcType {
   HANDSHAKE = 0,
@@ -52,15 +76,27 @@ enum RpcType {
   CANCEL_QUERY = 4,
   REQUEST_RESULTS = 5,
   RESUME_PAUSED_QUERY = 11,
+  GET_QUERY_PLAN_FRAGMENTS = 12,
+  GET_CATALOGS = 14,
+  GET_SCHEMAS = 15,
+  GET_TABLES = 16,
+  GET_COLUMNS = 17,
+  CREATE_PREPARED_STATEMENT = 22,
   QUERY_DATA = 6,
   QUERY_HANDLE = 7,
+  QUERY_PLAN_FRAGMENTS = 13,
+  CATALOGS = 18,
+  SCHEMAS = 19,
+  TABLES = 20,
+  COLUMNS = 21,
+  PREPARED_STATEMENT = 23,
   REQ_META_FUNCTIONS = 8,
   RESP_FUNCTION_LIST = 9,
   QUERY_RESULT = 10
 };
 bool RpcType_IsValid(int value);
 const RpcType RpcType_MIN = HANDSHAKE;
-const RpcType RpcType_MAX = RESUME_PAUSED_QUERY;
+const RpcType RpcType_MAX = PREPARED_STATEMENT;
 const int RpcType_ARRAYSIZE = RpcType_MAX + 1;
 
 const ::google::protobuf::EnumDescriptor* RpcType_descriptor();
@@ -112,6 +148,69 @@ inline bool HandshakeStatus_Parse(
   return ::google::protobuf::internal::ParseNamedEnum<HandshakeStatus>(
     HandshakeStatus_descriptor(), name, value);
 }
+enum RequestStatus {
+  UNKNOWN_STATUS = 0,
+  OK = 1,
+  FAILED = 2,
+  TIMEOUT = 3
+};
+bool RequestStatus_IsValid(int value);
+const RequestStatus RequestStatus_MIN = UNKNOWN_STATUS;
+const RequestStatus RequestStatus_MAX = TIMEOUT;
+const int RequestStatus_ARRAYSIZE = RequestStatus_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* RequestStatus_descriptor();
+inline const ::std::string& RequestStatus_Name(RequestStatus value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    RequestStatus_descriptor(), value);
+}
+inline bool RequestStatus_Parse(
+    const ::std::string& name, RequestStatus* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<RequestStatus>(
+    RequestStatus_descriptor(), name, value);
+}
+enum ColumnSearchability {
+  UNKNOWN_SEARCHABILITY = 0,
+  NONE = 1,
+  CHAR = 2,
+  NUMBER = 3,
+  ALL = 4
+};
+bool ColumnSearchability_IsValid(int value);
+const ColumnSearchability ColumnSearchability_MIN = UNKNOWN_SEARCHABILITY;
+const ColumnSearchability ColumnSearchability_MAX = ALL;
+const int ColumnSearchability_ARRAYSIZE = ColumnSearchability_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* ColumnSearchability_descriptor();
+inline const ::std::string& ColumnSearchability_Name(ColumnSearchability value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    ColumnSearchability_descriptor(), value);
+}
+inline bool ColumnSearchability_Parse(
+    const ::std::string& name, ColumnSearchability* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<ColumnSearchability>(
+    ColumnSearchability_descriptor(), name, value);
+}
+enum ColumnUpdatability {
+  UNKNOWN_UPDATABILITY = 0,
+  READ_ONLY = 1,
+  WRITABLE = 2
+};
+bool ColumnUpdatability_IsValid(int value);
+const ColumnUpdatability ColumnUpdatability_MIN = UNKNOWN_UPDATABILITY;
+const ColumnUpdatability ColumnUpdatability_MAX = WRITABLE;
+const int ColumnUpdatability_ARRAYSIZE = ColumnUpdatability_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* ColumnUpdatability_descriptor();
+inline const ::std::string& ColumnUpdatability_Name(ColumnUpdatability value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    ColumnUpdatability_descriptor(), value);
+}
+inline bool ColumnUpdatability_Parse(
+    const ::std::string& name, ColumnUpdatability* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<ColumnUpdatability>(
+    ColumnUpdatability_descriptor(), name, value);
+}
 // ===================================================================
 
 class Property : public ::google::protobuf::Message {
@@ -301,6 +400,153 @@ class UserProperties : public ::google::protobuf::Message {
 };
 // -------------------------------------------------------------------
 
+class RpcEndpointInfos : public ::google::protobuf::Message {
+ public:
+  RpcEndpointInfos();
+  virtual ~RpcEndpointInfos();
+
+  RpcEndpointInfos(const RpcEndpointInfos& from);
+
+  inline RpcEndpointInfos& operator=(const RpcEndpointInfos& 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 RpcEndpointInfos& default_instance();
+
+  void Swap(RpcEndpointInfos* other);
+
+  // implements Message ----------------------------------------------
+
+  RpcEndpointInfos* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const RpcEndpointInfos& from);
+  void MergeFrom(const RpcEndpointInfos& 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 string name = 1;
+  inline bool has_name() const;
+  inline void clear_name();
+  static const int kNameFieldNumber = 1;
+  inline const ::std::string& name() const;
+  inline void set_name(const ::std::string& value);
+  inline void set_name(const char* value);
+  inline void set_name(const char* value, size_t size);
+  inline ::std::string* mutable_name();
+  inline ::std::string* release_name();
+  inline void set_allocated_name(::std::string* name);
+
+  // optional string version = 2;
+  inline bool has_version() const;
+  inline void clear_version();
+  static const int kVersionFieldNumber = 2;
+  inline const ::std::string& version() const;
+  inline void set_version(const ::std::string& value);
+  inline void set_version(const char* value);
+  inline void set_version(const char* value, size_t size);
+  inline ::std::string* mutable_version();
+  inline ::std::string* release_version();
+  inline void set_allocated_version(::std::string* version);
+
+  // optional uint32 majorVersion = 3;
+  inline bool has_majorversion() const;
+  inline void clear_majorversion();
+  static const int kMajorVersionFieldNumber = 3;
+  inline ::google::protobuf::uint32 majorversion() const;
+  inline void set_majorversion(::google::protobuf::uint32 value);
+
+  // optional uint32 minorVersion = 4;
+  inline bool has_minorversion() const;
+  inline void clear_minorversion();
+  static const int kMinorVersionFieldNumber = 4;
+  inline ::google::protobuf::uint32 minorversion() const;
+  inline void set_minorversion(::google::protobuf::uint32 value);
+
+  // optional uint32 patchVersion = 5;
+  inline bool has_patchversion() const;
+  inline void clear_patchversion();
+  static const int kPatchVersionFieldNumber = 5;
+  inline ::google::protobuf::uint32 patchversion() const;
+  inline void set_patchversion(::google::protobuf::uint32 value);
+
+  // optional string application = 6;
+  inline bool has_application() const;
+  inline void clear_application();
+  static const int kApplicationFieldNumber = 6;
+  inline const ::std::string& application() const;
+  inline void set_application(const ::std::string& value);
+  inline void set_application(const char* value);
+  inline void set_application(const char* value, size_t size);
+  inline ::std::string* mutable_application();
+  inline ::std::string* release_application();
+  inline void set_allocated_application(::std::string* application);
+
+  // @@protoc_insertion_point(class_scope:exec.user.RpcEndpointInfos)
+ private:
+  inline void set_has_name();
+  inline void clear_has_name();
+  inline void set_has_version();
+  inline void clear_has_version();
+  inline void set_has_majorversion();
+  inline void clear_has_majorversion();
+  inline void set_has_minorversion();
+  inline void clear_has_minorversion();
+  inline void set_has_patchversion();
+  inline void clear_has_patchversion();
+  inline void set_has_application();
+  inline void clear_has_application();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::std::string* name_;
+  ::std::string* version_;
+  ::google::protobuf::uint32 majorversion_;
+  ::google::protobuf::uint32 minorversion_;
+  ::std::string* application_;
+  ::google::protobuf::uint32 patchversion_;
+
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32];
+
+  friend void  protobuf_AddDesc_User_2eproto();
+  friend void protobuf_AssignDesc_User_2eproto();
+  friend void protobuf_ShutdownFile_User_2eproto();
+
+  void InitAsDefaultInstance();
+  static RpcEndpointInfos* default_instance_;
+};
+// -------------------------------------------------------------------
+
 class UserToBitHandshake : public ::google::protobuf::Message {
  public:
   UserToBitHandshake();
@@ -408,6 +654,15 @@ class UserToBitHandshake : public ::google::protobuf::Message {
   inline bool support_timeout() const;
   inline void set_support_timeout(bool value);
 
+  // optional .exec.user.RpcEndpointInfos client_infos = 8;
+  inline bool has_client_infos() const;
+  inline void clear_client_infos();
+  static const int kClientInfosFieldNumber = 8;
+  inline const ::exec::user::RpcEndpointInfos& client_infos() const;
+  inline ::exec::user::RpcEndpointInfos* mutable_client_infos();
+  inline ::exec::user::RpcEndpointInfos* release_client_infos();
+  inline void set_allocated_client_infos(::exec::user::RpcEndpointInfos* client_infos);
+
   // @@protoc_insertion_point(class_scope:exec.user.UserToBitHandshake)
  private:
   inline void set_has_channel();
@@ -424,6 +679,8 @@ class UserToBitHandshake : public ::google::protobuf::Message {
   inline void clear_has_support_complex_types();
   inline void set_has_support_timeout();
   inline void clear_has_support_timeout();
+  inline void set_has_client_infos();
+  inline void clear_has_client_infos();
 
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
@@ -431,12 +688,13 @@ class UserToBitHandshake : public ::google::protobuf::Message {
   ::google::protobuf::int32 rpc_version_;
   ::exec::shared::UserCredentials* credentials_;
   ::exec::user::UserProperties* properties_;
+  ::exec::user::RpcEndpointInfos* client_infos_;
   bool support_listening_;
   bool support_complex_types_;
   bool support_timeout_;
 
   mutable int _cached_size_;
-  ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32];
+  ::google::protobuf::uint32 _has_bits_[(8 + 31) / 32];
 
   friend void  protobuf_AddDesc_User_2eproto();
   friend void protobuf_AssignDesc_User_2eproto();
@@ -541,14 +799,14 @@ class RequestResults : public ::google::protobuf::Message {
 };
 // -------------------------------------------------------------------
 
-class RunQuery : public ::google::protobuf::Message {
+class GetQueryPlanFragments : public ::google::protobuf::Message {
  public:
-  RunQuery();
-  virtual ~RunQuery();
+  GetQueryPlanFragments();
+  virtual ~GetQueryPlanFragments();
 
-  RunQuery(const RunQuery& from);
+  GetQueryPlanFragments(const GetQueryPlanFragments& from);
 
-  inline RunQuery& operator=(const RunQuery& from) {
+  inline GetQueryPlanFragments& operator=(const GetQueryPlanFragments& from) {
     CopyFrom(from);
     return *this;
   }
@@ -562,17 +820,17 @@ class RunQuery : public ::google::protobuf::Message {
   }
 
   static const ::google::protobuf::Descriptor* descriptor();
-  static const RunQuery& default_instance();
+  static const GetQueryPlanFragments& default_instance();
 
-  void Swap(RunQuery* other);
+  void Swap(GetQueryPlanFragments* other);
 
   // implements Message ----------------------------------------------
 
-  RunQuery* New() const;
+  GetQueryPlanFragments* 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 GetQueryPlanFragments& from);
+  void MergeFrom(const GetQueryPlanFragments& from);
   void Clear();
   bool IsInitialized() const;
 
@@ -595,12 +853,17 @@ 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);
+  // required string query = 1;
+  inline bool has_query() const;
+  inline void clear_query();
+  static const int kQueryFieldNumber = 1;
+  inline const ::std::string& query() const;
+  inline void set_query(const ::std::string& value);
+  inline void set_query(const char* value);
+  inline void set_query(const char* value, size_t size);
+  inline ::std::string* mutable_query();
+  inline ::std::string* release_query();
+  inline void set_allocated_query(::std::string* query);
 
   // optional .exec.shared.QueryType type = 2;
   inline bool has_type() const;
@@ -609,32 +872,27 @@ class RunQuery : public ::google::protobuf::Message {
   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);
+  // optional bool split_plan = 3 [default = false];
+  inline bool has_split_plan() const;
+  inline void clear_split_plan();
+  static const int kSplitPlanFieldNumber = 3;
+  inline bool split_plan() const;
+  inline void set_split_plan(bool value);
 
-  // @@protoc_insertion_point(class_scope:exec.user.RunQuery)
+  // @@protoc_insertion_point(class_scope:exec.user.GetQueryPlanFragments)
  private:
-  inline void set_has_results_mode();
-  inline void clear_has_results_mode();
+  inline void set_has_query();
+  inline void clear_has_query();
   inline void set_has_type();
   inline void clear_has_type();
-  inline void set_has_plan();
-  inline void clear_has_plan();
+  inline void set_has_split_plan();
+  inline void clear_has_split_plan();
 
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
-  int results_mode_;
+  ::std::string* query_;
   int type_;
-  ::std::string* plan_;
+  bool split_plan_;
 
   mutable int _cached_size_;
   ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
@@ -644,7 +902,126 @@ class RunQuery : public ::google::protobuf::Message {
   friend void protobuf_ShutdownFile_User_2eproto();
 
   void InitAsDefaultInstance();
-  static RunQuery* default_instance_;
+  static GetQueryPlanFragments* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class QueryPlanFragments : public ::google::protobuf::Message {
+ public:
+  QueryPlanFragments();
+  virtual ~QueryPlanFragments();
+
+  QueryPlanFragments(const QueryPlanFragments& from);
+
+  inline QueryPlanFragments& operator=(const QueryPlanFragments& 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 QueryPlanFragments& default_instance();
+
+  void Swap(QueryPlanFragments* other);
+
+  // implements Message ----------------------------------------------
+
+  QueryPlanFragments* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const QueryPlanFragments& from);
+  void MergeFrom(const QueryPlanFragments& 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 .exec.shared.QueryResult.QueryState status = 1;
+  inline bool has_status() const;
+  inline void clear_status();
+  static const int kStatusFieldNumber = 1;
+  inline ::exec::shared::QueryResult_QueryState status() const;
+  inline void set_status(::exec::shared::QueryResult_QueryState value);
+
+  // optional .exec.shared.QueryId query_id = 2;
+  inline bool has_query_id() const;
+  inline void clear_query_id();
+  static const int kQueryIdFieldNumber = 2;
+  inline const ::exec::shared::QueryId& query_id() const;
+  inline ::exec::shared::QueryId* mutable_query_id();
+  inline ::exec::shared::QueryId* release_query_id();
+  inline void set_allocated_query_id(::exec::shared::QueryId* query_id);
+
+  // repeated .exec.bit.control.PlanFragment fragments = 3;
+  inline int fragments_size() const;
+  inline void clear_fragments();
+  static const int kFragmentsFieldNumber = 3;
+  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.shared.DrillPBError error = 4;
+  inline bool has_error() const;
+  inline void clear_error();
+  static const int kErrorFieldNumber = 4;
+  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.QueryPlanFragments)
+ private:
+  inline void set_has_status();
+  inline void clear_has_status();
+  inline void set_has_query_id();
+  inline void clear_has_query_id();
+  inline void set_has_error();
+  inline void clear_has_error();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::exec::shared::QueryId* query_id_;
+  ::google::protobuf::RepeatedPtrField< ::exec::bit::control::PlanFragment > fragments_;
+  ::exec::shared::DrillPBError* error_;
+  int status_;
+
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
+
+  friend void  protobuf_AddDesc_User_2eproto();
+  friend void protobuf_AssignDesc_User_2eproto();
+  friend void protobuf_ShutdownFile_User_2eproto();
+
+  void InitAsDefaultInstance();
+  static QueryPlanFragments* default_instance_;
 };
 // -------------------------------------------------------------------
 
@@ -740,6 +1117,15 @@ class BitToUserHandshake : public ::google::protobuf::Message {
   inline ::std::string* release_errormessage();
   inline void set_allocated_errormessage(::std::string* errormessage);
 
+  // optional .exec.user.RpcEndpointInfos server_infos = 6;
+  inline bool has_server_infos() const;
+  inline void clear_server_infos();
+  static const int kServerInfosFieldNumber = 6;
+  inline const ::exec::user::RpcEndpointInfos& server_infos() const;
+  inline ::exec::user::RpcEndpointInfos* mutable_server_infos();
+  inline ::exec::user::RpcEndpointInfos* release_server_infos();
+  inline void set_allocated_server_infos(::exec::user::RpcEndpointInfos* server_infos);
+
   // @@protoc_insertion_point(class_scope:exec.user.BitToUserHandshake)
  private:
   inline void set_has_rpc_version();
@@ -750,6 +1136,8 @@ class BitToUserHandshake : public ::google::protobuf::Message {
   inline void clear_has_errorid();
   inline void set_has_errormessage();
   inline void clear_has_errormessage();
+  inline void set_has_server_infos();
+  inline void clear_has_server_infos();
 
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
@@ -757,9 +1145,10 @@ class BitToUserHandshake : public ::google::protobuf::Message {
   int status_;
   ::std::string* errorid_;
   ::std::string* errormessage_;
+  ::exec::user::RpcEndpointInfos* server_infos_;
 
   mutable int _cached_size_;
-  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
+  ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];
 
   friend void  protobuf_AddDesc_User_2eproto();
   friend void protobuf_AssignDesc_User_2eproto();
@@ -768,435 +1157,7249 @@ class BitToUserHandshake : public ::google::protobuf::Message {
   void InitAsDefaultInstance();
   static BitToUserHandshake* default_instance_;
 };
-// ===================================================================
-
+// -------------------------------------------------------------------
 
-// ===================================================================
+class LikeFilter : public ::google::protobuf::Message {
+ public:
+  LikeFilter();
+  virtual ~LikeFilter();
 
-// Property
+  LikeFilter(const LikeFilter& 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;
+  inline LikeFilter& operator=(const LikeFilter& from) {
+    CopyFrom(from);
+    return *this;
   }
-  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;
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
   }
-  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 ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
   }
-}
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const LikeFilter& default_instance();
+
+  void Swap(LikeFilter* other);
+
+  // implements Message ----------------------------------------------
+
+  LikeFilter* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const LikeFilter& from);
+  void MergeFrom(const LikeFilter& 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 string pattern = 1;
+  inline bool has_pattern() const;
+  inline void clear_pattern();
+  static const int kPatternFieldNumber = 1;
+  inline const ::std::string& pattern() const;
+  inline void set_pattern(const ::std::string& value);
+  inline void set_pattern(const char* value);
+  inline void set_pattern(const char* value, size_t size);
+  inline ::std::string* mutable_pattern();
+  inline ::std::string* release_pattern();
+  inline void set_allocated_pattern(::std::string* pattern);
+
+  // optional string escape = 2;
+  inline bool has_escape() const;
+  inline void clear_escape();
+  static const int kEscapeFieldNumber = 2;
+  inline const ::std::string& escape() const;
+  inline void set_escape(const ::std::string& value);
+  inline void set_escape(const char* value);
+  inline void set_escape(const char* value, size_t size);
+  inline ::std::string* mutable_escape();
+  inline ::std::string* release_escape();
+  inline void set_allocated_escape(::std::string* escape);
+
+  // @@protoc_insertion_point(class_scope:exec.user.LikeFilter)
+ private:
+  inline void set_has_pattern();
+  inline void clear_has_pattern();
+  inline void set_has_escape();
+  inline void clear_has_escape();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::std::string* pattern_;
+  ::std::string* escape_;
+
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
+
+  friend void  protobuf_AddDesc_User_2eproto();
+  friend void protobuf_AssignDesc_User_2eproto();
+  friend void protobuf_ShutdownFile_User_2eproto();
+
+  void InitAsDefaultInstance();
+  static LikeFilter* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class GetCatalogsReq : public ::google::protobuf::Message {
+ public:
+  GetCatalogsReq();
+  virtual ~GetCatalogsReq();
+
+  GetCatalogsReq(const GetCatalogsReq& from);
+
+  inline GetCatalogsReq& operator=(const GetCatalogsReq& 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 GetCatalogsReq& default_instance();
+
+  void Swap(GetCatalogsReq* other);
+
+  // implements Message ----------------------------------------------
+
+  GetCatalogsReq* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetCatalogsReq& from);
+  void MergeFrom(const GetCatalogsReq& 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.LikeFilter catalog_name_filter = 1;
+  inline bool has_catalog_name_filter() const;
+  inline void clear_catalog_name_filter();
+  static const int kCatalogNameFilterFieldNumber = 1;
+  inline const ::exec::user::LikeFilter& catalog_name_filter() const;
+  inline ::exec::user::LikeFilter* mutable_catalog_name_filter();
+  inline ::exec::user::LikeFilter* release_catalog_name_filter();
+  inline void set_allocated_catalog_name_filter(::exec::user::LikeFilter* catalog_name_filter);
+
+  // @@protoc_insertion_point(class_scope:exec.user.GetCatalogsReq)
+ private:
+  inline void set_has_catalog_name_filter();
+  inline void clear_has_catalog_name_filter();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::exec::user::LikeFilter* catalog_name_filter_;
+
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
+
+  friend void  protobuf_AddDesc_User_2eproto();
+  friend void protobuf_AssignDesc_User_2eproto();
+  friend void protobuf_ShutdownFile_User_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetCatalogsReq* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class CatalogMetadata : public ::google::protobuf::Message {
+ public:
+  CatalogMetadata();
+  virtual ~CatalogMetadata();
+
+  CatalogMetadata(const CatalogMetadata& from);
+
+  inline CatalogMetadata& operator=(const CatalogMetadata& 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 CatalogMetadata& default_instance();
+
+  void Swap(CatalogMetadata* other);
+
+  // implements Message ----------------------------------------------
+
+  CatalogMetadata* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const CatalogMetadata& from);
+  void MergeFrom(const CatalogMetadata& 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 string catalog_name = 1;
+  inline bool has_catalog_name() const;
+  inline void clear_catalog_name();
+  static const int kCatalogNameFieldNumber = 1;
+  inline const ::std::string& catalog_name() const;
+  inline void set_catalog_name(const ::std::string& value);
+  inline void set_catalog_name(const char* value);
+  inline void set_catalog_name(const char* value, size_t size);
+  inline ::std::string* mutable_catalog_name();
+  inline ::std::string* release_catalog_name();
+  inline void set_allocated_catalog_name(::std::string* catalog_name);
+
+  // optional string description = 2;
+  inline bool has_description() const;
+  inline void clear_description();
+  static const int kDescriptionFieldNumber = 2;
+  inline const ::std::string& description() const;
+  inline void set_description(const ::std::string& value);
+  inline void set_description(const char* value);
+  inline void set_description(const char* value, size_t size);
+  inline ::std::string* mutable_description();
+  inline ::std::string* release_description();
+  inline void set_allocated_description(::std::string* description);
+
+  // optional string connect = 3;
+  inline bool has_connect() const;
+  inline void clear_connect();
+  static const int kConnectFieldNumber = 3;
+  inline const ::std::string& connect() const;
+  inline void set_connect(const ::std::string& value);
+  inline void set_connect(const char* value);
+  inline void set_connect(const char* value, size_t size);
+  inline ::std::string* mutable_connect();
+  inline ::std::string* release_connect();
+  inline void set_allocated_connect(::std::string* connect);
+
+  // @@protoc_insertion_point(class_scope:exec.user.CatalogMetadata)
+ private:
+  inline void set_has_catalog_name();
+  inline void clear_has_catalog_name();
+  inline void set_has_description();
+  inline void clear_has_description();
+  inline void set_has_connect();
+  inline void clear_has_connect();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::std::string* catalog_name_;
+  ::std::string* description_;
+  ::std::string* connect_;
+
+  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 CatalogMetadata* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class GetCatalogsResp : public ::google::protobuf::Message {
+ public:
+  GetCatalogsResp();
+  virtual ~GetCatalogsResp();
+
+  GetCatalogsResp(const GetCatalogsResp& from);
+
+  inline GetCatalogsResp& operator=(const GetCatalogsResp& 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 GetCatalogsResp& default_instance();
+
+  void Swap(GetCatalogsResp* other);
+
+  // implements Message ----------------------------------------------
+
+  GetCatalogsResp* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetCatalogsResp& from);
+  void MergeFrom(const GetCatalogsResp& 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);
+
+  // repeated .exec.user.CatalogMetadata catalogs = 2;
+  inline int catalogs_size() const;
+  inline void clear_catalogs();
+  static const int kCatalogsFieldNumber = 2;
+  inline const ::exec::user::CatalogMetadata& catalogs(int index) const;
+  inline ::exec::user::CatalogMetadata* mutable_catalogs(int index);
+  inline ::exec::user::CatalogMetadata* add_catalogs();
+  inline const ::google::protobuf::RepeatedPtrField< ::exec::user::CatalogMetadata >&
+      catalogs() const;
+  inline ::google::protobuf::RepeatedPtrField< ::exec::user::CatalogMetadata >*
+      mutable_catalogs();
+
+  // 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.GetCatalogsResp)
+ private:
+  inline void set_has_status();
+  inline void clear_has_status();
+  inline void set_has_error();
+  inline void clear_has_error();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::RepeatedPtrField< ::exec::user::CatalogMetadata > catalogs_;
+  ::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 GetCatalogsResp* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class GetSchemasReq : public ::google::protobuf::Message {
+ public:
+  GetSchemasReq();
+  virtual ~GetSchemasReq();
+
+  GetSchemasReq(const GetSchemasReq& from);
+
+  inline GetSchemasReq& operator=(const GetSchemasReq& 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 GetSchemasReq& default_instance();
+
+  void Swap(GetSchemasReq* other);
+
+  // implements Message ----------------------------------------------
+
+  GetSchemasReq* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetSchemasReq& from);
+  void MergeFrom(const GetSchemasReq& 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.LikeFilter catalog_name_filter = 1;
+  inline bool has_catalog_name_filter() const;
+  inline void clear_catalog_name_filter();
+  static const int kCatalogNameFilterFieldNumber = 1;
+  inline const ::exec::user::LikeFilter& catalog_name_filter() const;
+  inline ::exec::user::LikeFilter* mutable_catalog_name_filter();
+  inline ::exec::user::LikeFilter* release_catalog_name_filter();
+  inline void set_allocated_catalog_name_filter(::exec::user::LikeFilter* catalog_name_filter);
+
+  // optional .exec.user.LikeFilter schema_name_filter = 2;
+  inline bool has_schema_name_filter() const;
+  inline void clear_schema_name_filter();
+  static const int kSchemaNameFilterFieldNumber = 2;
+  inline const ::exec::user::LikeFilter& schema_name_filter() const;
+  inline ::exec::user::LikeFilter* mutable_schema_name_filter();
+  inline ::exec::user::LikeFilter* release_schema_name_filter();
+  inline void set_allocated_schema_name_filter(::exec::user::LikeFilter* schema_name_filter);
+
+  // @@protoc_insertion_point(class_scope:exec.user.GetSchemasReq)
+ private:
+  inline void set_has_catalog_name_filter();
+  inline void clear_has_catalog_name_filter();
+  inline void set_has_schema_name_filter();
+  inline void clear_has_schema_name_filter();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::exec::user::LikeFilter* catalog_name_filter_;
+  ::exec::user::LikeFilter* schema_name_filter_;
+
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
+
+  friend void  protobuf_AddDesc_User_2eproto();
+  friend void protobuf_AssignDesc_User_2eproto();
+  friend void protobuf_ShutdownFile_User_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetSchemasReq* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class SchemaMetadata : public ::google::protobuf::Message {
+ public:
+  SchemaMetadata();
+  virtual ~SchemaMetadata();
+
+  SchemaMetadata(const SchemaMetadata& from);
+
+  inline SchemaMetadata& operator=(const SchemaMetadata& 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 SchemaMetadata& default_instance();
+
+  void Swap(SchemaMetadata* other);
+
+  // implements Message ----------------------------------------------
+
+  SchemaMetadata* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SchemaMetadata& from);
+  void MergeFrom(const SchemaMetadata& 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 string catalog_name = 1;
+  inline bool has_catalog_name() const;
+  inline void clear_catalog_name();
+  static const int kCatalogNameFieldNumber = 1;
+  inline const ::std::string& catalog_name() const;
+  inline void set_catalog_name(const ::std::string& value);
+  inline void set_catalog_name(const char* value);
+  inline void set_catalog_name(const char* value, size_t size);
+  inline ::std::string* mutable_catalog_name();
+  inline ::std::string* release_catalog_name();
+  inline void set_allocated_catalog_name(::std::string* catalog_name);
+
+  // optional string schema_name = 2;
+  inline bool has_schema_name() const;
+  inline void clear_schema_name();
+  static const int kSchemaNameFieldNumber = 2;
+  inline const ::std::string& schema_name() const;
+  inline void set_schema_name(const ::std::string& value);
+  inline void set_schema_name(const char* value);
+  inline void set_schema_name(const char* value, size_t size);
+  inline ::std::string* mutable_schema_name();
+  inline ::std::string* release_schema_name();
+  inline void set_allocated_schema_name(::std::string* schema_name);
+
+  // optional string owner = 3;
+  inline bool has_owner() const;
+  inline void clear_owner();
+  static const int kOwnerFieldNumber = 3;
+  inline const ::std::string& owner() const;
+  inline void set_owner(const ::std::string& value);
+  inline void set_owner(const char* value);
+  inline void set_owner(const char* value, size_t size);
+  inline ::std::string* mutable_owner();
+  inline ::std::string* release_owner();
+  inline void set_allocated_owner(::std::string* owner);
+
+  // optional string type = 4;
+  inline bool has_type() const;
+  inline void clear_type();
+  static const int kTypeFieldNumber = 4;
+  inline const ::std::string& type() const;
+  inline void set_type(const ::std::string& value);
+  inline void set_type(const char* value);
+  inline void set_type(const char* value, size_t size);
+  inline ::std::string* mutable_type();
+  inline ::std::string* release_type();
+  inline void set_allocated_type(::std::string* type);
+
+  // optional string mutable = 5;
+  inline bool has_mutable_() const;
+  inline void clear_mutable_();
+  static const int kMutableFieldNumber = 5;
+  inline const ::std::string& mutable_() const;
+  inline void set_mutable_(const ::std::string& value);
+  inline void set_mutable_(const char* value);
+  inline void set_mutable_(const char* value, size_t size);
+  inline ::std::string* mutable_mutable_();
+  inline ::std::string* release_mutable_();
+  inline void set_allocated_mutable_(::std::string* mutable_);
+
+  // @@protoc_insertion_point(class_scope:exec.user.SchemaMetadata)
+ private:
+  inline void set_has_catalog_name();
+  inline void clear_has_catalog_name();
+  inline void set_has_schema_name();
+  inline void clear_has_schema_name();
+  inline void set_has_owner();
+  inline void clear_has_owner();
+  inline void set_has_type();
+  inline void clear_has_type();
+  inline void set_has_mutable_();
+  inline void clear_has_mutable_();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::std::string* catalog_name_;
+  ::std::string* schema_name_;
+  ::std::string* owner_;
+  ::std::string* type_;
+  ::std::string* mutable__;
+
+  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 SchemaMetadata* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class GetSchemasResp : public ::google::protobuf::Message {
+ public:
+  GetSchemasResp();
+  virtual ~GetSchemasResp();
+
+  GetSchemasResp(const GetSchemasResp& from);
+
+  inline GetSchemasResp& operator=(const GetSchemasResp& 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 GetSchemasResp& default_instance();
+
+  void Swap(GetSchemasResp* other);
+
+  // implements Message ----------------------------------------------
+
+  GetSchemasResp* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetSchemasResp& from);
+  void MergeFrom(const GetSchemasResp& 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);
+
+  // repeated .exec.user.SchemaMetadata schemas = 2;
+  inline int schemas_size() const;
+  inline void clear_schemas();
+  static const int kSchemasFieldNumber = 2;
+  inline const ::exec::user::SchemaMetadata& schemas(int index) const;
+  inline ::exec::user::SchemaMetadata* mutable_schemas(int index);
+  inline ::exec::user::SchemaMetadata* add_schemas();
+  inline const ::google::protobuf::RepeatedPtrField< ::exec::user::SchemaMetadata >&
+      schemas() const;
+  inline ::google::protobuf::RepeatedPtrField< ::exec::user::SchemaMetadata >*
+      mutable_schemas();
+
+  // 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.GetSchemasResp)
+ private:
+  inline void set_has_status();
+  inline void clear_has_status();
+  inline void set_has_error();
+  inline void clear_has_error();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::RepeatedPtrField< ::exec::user::SchemaMetadata > schemas_;
+  ::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 GetSchemasResp* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class GetTablesReq : public ::google::protobuf::Message {
+ public:
+  GetTablesReq();
+  virtual ~GetTablesReq();
+
+  GetTablesReq(const GetTablesReq& from);
+
+  inline GetTablesReq& operator=(const GetTablesReq& 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 GetTablesReq& default_instance();
+
+  void Swap(GetTablesReq* other);
+
+  // implements Message ----------------------------------------------
+
+  GetTablesReq* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetTablesReq& from);
+  void MergeFrom(const GetTablesReq& 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.LikeFilter catalog_name_filter = 1;
+  inline bool has_catalog_name_filter() const;
+  inline void clear_catalog_name_filter();
+  static const int kCatalogNameFilterFieldNumber = 1;
+  inline const ::exec::user::LikeFilter& catalog_name_filter() const;
+  inline ::exec::user::LikeFilter* mutable_catalog_name_filter();
+  inline ::exec::user::LikeFilter* release_catalog_name_filter();
+  inline void set_allocated_catalog_name_filter(::exec::user::LikeFilter* catalog_name_filter);
+
+  // optional .exec.user.LikeFilter schema_name_filter = 2;
+  inline bool has_schema_name_filter() const;
+  inline void clear_schema_name_filter();
+  static const int kSchemaNameFilterFieldNumber = 2;
+  inline const ::exec::user::LikeFilter& schema_name_filter() const;
+  inline ::exec::user::LikeFilter* mutable_schema_name_filter();
+  inline ::exec::user::LikeFilter* release_schema_name_filter();
+  inline void set_allocated_schema_name_filter(::exec::user::LikeFilter* schema_name_filter);
+
+  // optional .exec.user.LikeFilter table_name_filter = 3;
+  inline bool has_table_name_filter() const;
+  inline void clear_table_name_filter();
+  static const int kTableNameFilterFieldNumber = 3;
+  inline const ::exec::user::LikeFilter& table_name_filter() const;
+  inline ::exec::user::LikeFilter* mutable_table_name_filter();
+  inline ::exec::user::LikeFilter* release_table_name_filter();
+  inline void set_allocated_table_name_filter(::exec::user::LikeFilter* table_name_filter);
+
+  // repeated string table_type_filter = 4;
+  inline int table_type_filter_size() const;
+  inline void clear_table_type_filter();
+  static const int kTableTypeFilterFieldNumber = 4;
+  inline const ::std::string& table_type_filter(int index) const;
+  inline ::std::string* mutable_table_type_filter(int index);
+  inline void set_table_type_filter(int index, const ::std::string& value);
+  inline void set_table_type_filter(int index, const char* value);
+  inline void set_table_type_filter(int index, const char* value, size_t size);
+  inline ::std::string* add_table_type_filter();
+  inline void add_table_type_filter(const ::std::string& value);
+  inline void add_table_type_filter(const char* value);
+  inline void add_table_type_filter(const char* value, size_t size);
+  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& table_type_filter() const;
+  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_table_type_filter();
+
+  // @@protoc_insertion_point(class_scope:exec.user.GetTablesReq)
+ private:
+  inline void set_has_catalog_name_filter();
+  inline void clear_has_catalog_name_filter();
+  inline void set_has_schema_name_filter();
+  inline void clear_has_schema_name_filter();
+  inline void set_has_table_name_filter();
+  inline void clear_has_table_name_filter();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::exec::user::LikeFilter* catalog_name_filter_;
+  ::exec::user::LikeFilter* schema_name_filter_;
+  ::exec::user::LikeFilter* table_name_filter_;
+  ::google::protobuf::RepeatedPtrField< ::std::string> table_type_filter_;
+
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
+
+  friend void  protobuf_AddDesc_User_2eproto();
+  friend void protobuf_AssignDesc_User_2eproto();
+  friend void protobuf_ShutdownFile_User_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetTablesReq* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TableMetadata : public ::google::protobuf::Message {
+ public:
+  TableMetadata();
+  virtual ~TableMetadata();
+
+  TableMetadata(const TableMetadata& from);
+
+  inline TableMetadata& operator=(const TableMetadata& 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 TableMetadata& default_instance();
+
+  void Swap(TableMetadata* other);
+
+  // implements Message ----------------------------------------------
+
+  TableMetadata* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const TableMetadata& from);
+  void MergeFrom(const TableMetadata& 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 string catalog_name = 1;
+  inline bool has_catalog_name() const;
+  inline void clear_catalog_name();
+  static const int kCatalogNameFieldNumber = 1;
+  inline const ::std::string& catalog_name() const;
+  inline void set_catalog_name(const ::std::string& value);
+  inline void set_catalog_name(const char* value);
+  inline void set_catalog_name(const char* value, size_t size);
+  inline ::std::string* mutable_catalog_name();
+  inline ::std::string* release_catalog_name();
+  inline void set_allocated_catalog_name(::std::string* catalog_name);
+
+  // optional string schema_name = 2;
+  inline bool has_schema_name() const;
+  inline void clear_schema_name();
+  static const int kSchemaNameFieldNumber = 2;
+  inline const ::std::string& schema_name() const;
+  inline void set_schema_name(const ::std::string& value);
+  inline void set_schema_name(const char* value);
+  inline void set_schema_name(const char* value, size_t size);
+  inline ::std::string* mutable_schema_name();
+  inline ::std::string* release_schema_name();
+  inline void set_allocated_schema_name(::std::string* schema_name);
+
+  // optional string table_name = 3;
+  inline bool has_table_name() const;
+  inline void clear_table_name();
+  static const int kTableNameFieldNumber = 3;
+  inline const ::std::string& table_name() const;
+  inline void set_table_name(const ::std::string& value);
+  inline void set_table_name(const char* value);
+  inline void set_table_name(const char* value, size_t size);
+  inline ::std::string* mutable_table_name();
+  inline ::std::string* release_table_name();
+  inline void set_allocated_table_name(::std::string* table_name);
+
+  // optional string type = 4;
+  inline bool has_type() const;
+  inline void clear_type();
+  static const int kTypeFieldNumber = 4;
+  inline const ::std::string& type() const;
+  inline void set_type(const ::std::string& value);
+  inline void set_type(const char* value);
+  inline void set_type(const char* value, size_t size);
+  inline ::std::string* mutable_type();
+  inline ::std::string* release_type();
+  inline void set_allocated_type(::std::string* type);
+
+  // @@protoc_insertion_point(class_scope:exec.user.TableMetadata)
+ private:
+  inline void set_has_catalog_name();
+  inline void clear_has_catalog_name();
+  inline void set_has_schema_name();
+  inline void clear_has_schema_name();
+  inline void set_has_table_name();
+  inline void clear_has_table_name();
+  inline void set_has_type();
+  inline void clear_has_type();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::std::string* catalog_name_;
+  ::std::string* schema_name_;
+  ::std::string* table_name_;
+  ::std::string* type_;
+
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
+
+  friend void  protobuf_AddDesc_User_2eproto();
+  friend void protobuf_AssignDesc_User_2eproto();
+  friend void protobuf_ShutdownFile_User_2eproto();
+
+  void InitAsDefaultInstance();
+  static TableMetadata* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class GetTablesResp : public ::google::protobuf::Message {
+ public:
+  GetTablesResp();
+  virtual ~GetTablesResp();
+
+  GetTablesResp(const GetTablesResp& from);
+
+  inline GetTablesResp& operator=(const GetTablesResp& 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 GetTablesResp& default_instance();
+
+  void Swap(GetTablesResp* other);
+
+  // implements Message ----------------------------------------------
+
+  GetTablesResp* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetTablesResp& from);
+  void MergeFrom(const GetTablesResp& 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);
+
+  // repeated .exec.user.TableMetadata tables = 2;
+  inline int tables_size() const;
+  inline void clear_tables();
+  static const int kTablesFieldNumber = 2;
+  inline const ::exec::user::TableMetadata& tables(int index) const;
+  inline ::exec::user::TableMetadata* mutable_tables(int index);
+  inline ::exec::user::TableMetadata* add_tables();
+  inline const ::google::protobuf::RepeatedPtrField< ::exec::user::TableMetadata >&
+      tables() const;
+  inline ::google::protobuf::RepeatedPtrField< ::exec::user::TableMetadata >*
+      mutable_tables();
+
+  // 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.GetTablesResp)
+ private:
+  inline void set_has_status();
+  inline void clear_has_status();
+  inline void set_has_error();
+  inline void clear_has_error();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::RepeatedPtrField< ::exec::user::TableMetadata > tables_;
+  ::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 GetTablesResp* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class GetColumnsReq : public ::google::protobuf::Message {
+ public:
+  GetColumnsReq();
+  virtual ~GetColumnsReq();
+
+  GetColumnsReq(const GetColumnsReq& from);
+
+  inline GetColumnsReq& operator=(const GetColumnsReq& 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 GetColumnsReq& default_instance();
+
+  void Swap(GetColumnsReq* other);
+
+  // implements Message ----------------------------------------------
+
+  GetColumnsReq* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetColumnsReq& from);
+  void MergeFrom(const GetColumnsReq& 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.LikeFilter catalog_name_filter = 1;
+  inline bool has_catalog_name_filter() const;
+  inline void clear_catalog_name_filter();
+  static const int kCatalogNameFilterFieldNumber = 1;
+  inline const ::exec::user::LikeFilter& catalog_name_filter() const;
+  inline ::exec::user::LikeFilter* mutable_catalog_name_filter();
+  inline ::exec::user::LikeFilter* release_catalog_name_filter();
+  inline void set_allocated_catalog_name_filter(::exec::user::LikeFilter* catalog_name_filter);
+
+  // optional .exec.user.LikeFilter schema_name_filter = 2;
+  inline bool has_schema_name_filter() const;
+  inline void clear_schema_name_filter();
+  static const int kSchemaNameFilterFieldNumber = 2;
+  inline const ::exec::user::LikeFilter& schema_name_filter() const;
+  inline ::exec::user::LikeFilter* mutable_schema_name_filter();
+  inline ::exec::user::LikeFilter* release_schema_name_filter();
+  inline void set_allocated_schema_name_filter(::exec::user::LikeFilter* schema_name_filter);
+
+  // optional .exec.user.LikeFilter table_name_filter = 3;
+  inline bool has_table_name_filter() const;
+  inline void clear_table_name_filter();
+  static const int kTableNameFilterFieldNumber = 3;
+  inline const ::exec::user::LikeFilter& table_name_filter() const;
+  inline ::exec::user::LikeFilter* mutable_table_name_filter();
+  inline ::exec::user::LikeFilter* release_table_name_filter();
+  inline void set_allocated_table_name_filter(::exec::user::LikeFilter* table_name_filter);
+
+  // optional .exec.user.LikeFilter column_name_filter = 4;
+  inline bool has_column_name_filter() const;
+  inline void clear_column_name_filter();
+  static const int kColumnNameFilterFieldNumber = 4;
+  inline const ::exec::user::LikeFilter& column_name_filter() const;
+  inline ::exec::user::LikeFilter* mutable_column_name_filter();
+  inline ::exec::user::LikeFilter* release_column_name_filter();
+  inline void set_allocated_column_name_filter(::exec::user::LikeFilter* column_name_filter);
+
+  // @@protoc_insertion_point(class_scope:exec.user.GetColumnsReq)
+ private:
+  inline void set_has_catalog_name_filter();
+  inline void clear_has_catalog_name_filter();
+  inline void set_has_schema_name_filter();
+  inline void clear_has_schema_name_filter();
+  inline void set_has_table_name_filter();
+  inline void clear_has_table_name_filter();
+  inline void set_has_column_name_filter();
+  inline void clear_has_column_name_filter();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::exec::user::LikeFilter* catalog_name_filter_;
+  ::exec::user::LikeFilter* schema_name_filter_;
+  ::exec::user::LikeFilter* table_name_filter_;
+  ::exec::user::LikeFilter* column_name_filter_;
+
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
+
+  friend void  protobuf_AddDesc_User_2eproto();
+  friend void protobuf_AssignDesc_User_2eproto();
+  friend void protobuf_ShutdownFile_User_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetColumnsReq* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ColumnMetadata : public ::google::protobuf::Message {
+ public:
+  ColumnMetadata();
+  virtual ~ColumnMetadata();
+
+  ColumnMetadata(const ColumnMetadata& from);
+
+  inline ColumnMetadata& operator=(const ColumnMetadata& 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 ColumnMetadata& default_instance();
+
+  void Swap(ColumnMetadata* other);
+
+  // implements Message ----------------------------------------------
+
+  ColumnMetadata* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ColumnMetadata& from);
+  void MergeFrom(const ColumnMetadata& 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 string catalog_name = 1;
+  inline bool has_catalog_name() const;
+  inline void clear_catalog_name();
+  static const int kCatalogNameFieldNumber = 1;
+  inline const ::std::string& catalog_name() const;
+  inline void set_catalog_name(const ::std::string& value);
+  inline void set_catalog_name(const char* value);
+  inline void set_catalog_name(const char* value, size_t size);
+  inline ::std::string* mutable_catalog_name();
+  inline ::std::string* release_catalog_name();
+  inline void set_allocated_catalog_name(::std::string* catalog_name);
+
+  // optional string schema_name = 2;
+  inline bool has_schema_name() const;
+  inline void clear_schema_name();
+  static const int kSchemaNameFieldNumber = 2;
+  inline const ::std::string& schema_name() const;
+  inline void set_schema_name(const ::std::string& value);
+  inline void set_schema_name(const char* value);
+  inline void set_schema_name(const char* value, size_t size);
+  inline ::std::string* mutable_schema_name();
+  inline ::std::string* release_schema_name();
+  inline void set_allocated_schema_name(::std::string* schema_name);
+
+  // optional string table_name = 3;
+  inline bool has_table_name() const;
+  inline void clear_table_name();
+  static const int kTableNameFieldNumber = 3;
+  inline const ::std::string& table_name() const;
+  inline void set_table_name(const ::std::string& value);
+  inline void set_table_name(const char* value);
+  inline void set_table_name(const char* value, size_t size);
+  inline ::std::string* mutable_table_name();
+  inline ::std::string* release_table_name();
+  inline void set_allocated_table_name(::std::string* table_name);
+
+  // optional string column_name = 4;
+  inline bool has_column_name() const;
+  inline void clear_column_name();
+  static const int kColumnNameFieldNumber = 4;
+  inline const ::std::string& column_name() const;
+  inline void set_column_name(const ::std::string& value);
+  inline void set_column_name(const char* value);
+  inline void set_column_name(const char* value, size_t size);
+  inline ::std::string* mutable_column_name();
+  inline ::std::string* release_column_name();
+  inline void set_allocated_column_name(::std::string* column_name);
+
+  // optional int32 ordinal_position = 5;
+  inline bool has_ordinal_position() const;
+  inline void clear_ordinal_position();
+  static const int kOrdinalPositionFieldNumber = 5;
+  inline ::google::protobuf::int32 ordinal_position() const;
+  inline void set_ordinal_position(::google::protobuf::int32 value);
+
+  // optional string default_value = 6;
+  inline bool has_default_value() const;
+  inline void clear_default_value();
+  static const int kDefaultValueFieldNumber = 6;
+  inline const ::std::string& default_value() const;
+  inline void set_default_value(const ::std::string& value);
+  inline void set_default_value(const char* value);
+  inline void set_default_value(const char* value, size_t size);
+  inline ::std::string* mutable_default_value();
+  inline ::std::string* release_default_value();
+  inline void set_allocated_default_value(::std::string* default_value);
+
+  // optional bool is_nullable = 7;
+  inline bool has_is_nullable() const;
+  inline void clear_is_nullable();
+  static const int kIsNullableFieldNumber = 7;
+  inline bool is_nullable() const;
+  inline void set_is_nullable(bool value);
+
+  // optional string data_type = 8;
+  inline bool has_data_type() const;
+  inline void clear_data_type();
+  static const int kDataTypeFieldNumber = 8;
+  inline const ::std::string& data_type() const;
+  inline void set_data_type(const ::std::string& value);
+  inline void set_data_type(const char* value);
+  inline void set_data_type(const char* value, size_t size);
+  inline ::std::string* mutable_data_type();
+  inline ::std::string* release_data_type();
+  inline void set_allocated_data_type(::std::string* data_type);
+
+  // optional int32 char_max_length = 9;
+  inline bool has_char_max_length() const;
+  inline void clear_char_max_length();
+  static const int kCharMaxLengthFieldNumber = 9;
+  inline ::google::protobuf::int32 char_max_length() const;
+  inline void set_char_max_length(::google::protobuf::int32 value);
+
+  // optional int32 char_octet_length = 10;
+  inline bool has_char_octet_length() const;
+  inline void clear_char_octet_length();
+  static const int kCharOctetLengthFieldNumber = 10;
+  inline ::google::protobuf::int32 char_octet_length() const;
+  inline void set_char_octet_length(::google::protobuf::int32 value);
+
+  // optional int32 numeric_precision = 11;
+  inline bool has_numeric_precision() const;
+  inline void clear_numeric_precision();
+  static const int kNumericPrecisionFieldNumber = 11;
+  inline ::google::protobuf::int32 numeric_precision() const;
+  inline void set_numeric_precision(::google::protobuf::int32 value);
+
+  // optional int32 numeric_precision_radix = 12;
+  inline bool has_numeric_precision_radix() const;
+  inline void clear_numeric_precision_radix();
+  static const int kNumericPrecisionRadixFieldNumber = 12;
+  inline ::google::protobuf::int32 numeric_precision_radix() const;
+  inline void set_numeric_precision_radix(::google::protobuf::int32 value);
+
+  // optional int32 numeric_scale = 13;
+  inline bool has_numeric_scale() const;
+  inline void clear_numeric_scale();
+  static const int kNumericScaleFieldNumber = 13;
+  inline ::google::protobuf::int32 numeric_scale() const;
+  inline void set_numeric_scale(::google::protobuf::int32 value);
+
+  // optional int32 date_time_precision = 14;
+  inline bool has_date_time_precision() const;
+  inline void clear_date_time_precision();
+  static const int kDateTimePrecisionFieldNumber = 14;
+  inline ::google::protobuf::int32 date_time_precision() const;
+  inline void set_date_time_precision(::google::protobuf::int32 value);
+
+  // optional string interval_type = 15;
+  inline bool has_interval_type() const;
+  inline void clear_interval_type();
+  static const int kIntervalTypeFieldNumber = 15;
+  inline const ::std::string& interval_type() const;
+  inline void set_interval_type(const ::std::string& value);
+  inline void set_interval_type(const char* value);
+  inline void set_interval_type(const char* value, size_t size);
+  inline ::std::string* mutable_interval_type();
+  inline ::std::string* release_interval_type();
+  inline void set_allocated_interval_type(::std::string* interval_type);
+
+  // optional int32 interval_precision = 16;
+  inline bool has_interval_precision() const;
+  inline void clear_interval_precision();
+  static const int kIntervalPrecisionFieldNumber = 16;
+  inline ::google::protobuf::int32 interval_precision() const;
+  inline void set_interval_precision(::google::protobuf::int32 value);
+
+  // optional int32 column_size = 17;
+  inline bool has_column_size() const;
+  inline void clear_column_size();
+  static const int kColumnSizeFieldNumber = 17;
+  inline ::google::protobuf::int32 column_size() const;
+  inline void set_column_size(::google::protobuf::int32 value);
+
+  // @@protoc_insertion_point(class_scope:exec.user.ColumnMetadata)
+ private:
+  inline void set_has_catalog_name();
+  inline void clear_has_catalog_name();
+  inline void set_has_schema_name();
+  inline void clear_has_schema_name();
+  inline void set_has_table_name();
+  inline void clear_has_table_name();
+  inline void set_has_column_name();
+  inline void clear_has_column_name();
+  inline void set_has_ordinal_position();
+  inline void clear_has_ordinal_position();
+  inline void set_has_default_value();
+  inline void clear_has_default_value();
+  inline void set_has_is_nullable();
+  inline void clear_has_is_nullable();
+  inline void set_has_data_type();
+  inline void clear_has_data_type();
+  inline void set_has_char_max_length();
+  inline void clear_has_char_max_length();
+  inline void set_has_char_octet_length();
+  inline void clear_has_char_octet_length();
+  inline void set_has_numeric_precision();
+  inline void clear_has_numeric_precision();
+  inline void set_has_numeric_precision_radix();
+  inline void clear_has_numeric_precision_radix();
+  inline void set_has_numeric_scale();
+  inline void clear_has_numeric_scale();
+  inline void set_has_date_time_precision();
+  inline void clear_has_date_time_precision();
+  inline void set_has_interval_type();
+  inline void clear_has_interval_type();
+  inline void set_has_interval_precision();
+  inline void clear_has_interval_precision();
+  inline void set_has_column_size();
+  inline void clear_has_column_size();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::std::string* catalog_name_;
+  ::std::string* schema_name_;
+  ::std::string* table_name_;
+  ::std::string* column_name_;
+  ::std::string* default_value_;
+  ::google::protobuf::int32 ordinal_position_;
+  bool is_nullable_;
+  ::std::string* data_type_;
+  ::google::protobuf::int32 char_max_length_;
+  ::google::protobuf::int32 char_octet_length_;
+  ::google::protobuf::int32 numeric_precision_;
+  ::google::protobuf::int32 numeric_precision_radix_;
+  ::google::protobuf::int32 numeric_scale_;
+  ::google::protobuf::int32 date_time_precision_;
+  ::std::string* interval_type_;
+  ::google::protobuf::int32 interval_precision_;
+  ::google::protobuf::int32 column_size_;
+
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(17 + 31) / 32];
+
+  friend void  protobuf_AddDesc_User_2eproto();
+  friend void protobuf_AssignDesc_User_2eproto();
+  friend void protobuf_ShutdownFile_User_2eproto();
+
+  void InitAsDefaultInstance();
+  static ColumnMetadata* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class GetColumnsResp : public ::google::protobuf::Message {
+ public:
+  GetColumnsResp();
+  virtual ~GetColumnsResp();
+
+  GetColumnsResp(const GetColumnsResp& from);
+
+  inline GetColumnsResp& operator=(const GetColumnsResp& 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 GetColumnsResp& default_instance();
+
+  void Swap(GetColumnsResp* other);
+
+  // implements Message ----------------------------------------------
+
+  GetColumnsResp* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetColumnsResp& from);
+  void MergeFrom(const GetColumnsResp& 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);
+
+  // repeated .exec.user.ColumnMetadata columns = 2;
+  inline int columns_size() const;
+  inline void clear_columns();
+  static const int kColumnsFieldNumber = 2;
+  inline const ::exec::user::ColumnMetadata& columns(int index) const;
+  inline ::exec::user::ColumnMetadata* mutable_columns(int index);
+  inline ::exec::user::ColumnMetadata* add_columns();
+  inline const ::google::protobuf::RepeatedPtrField< ::exec::user::ColumnMetadata >&
+      columns() const;
+  inline ::google::protobuf::RepeatedPtrField< ::exec::user::ColumnMetadata >*
+      mutable_columns();
+
+  // 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.GetColumnsResp)
+ private:
+  inline void set_has_status();
+  inline void clear_has_status();
+  inline void set_has_error();
+  inline void clear_has_error();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::RepeatedPtrField< ::exec::user::ColumnMetadata > columns_;
+  ::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 GetColumnsResp* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class CreatePreparedStatementReq : public ::google::protobuf::Message {
+ public:
+  CreatePreparedStatementReq();
+  virtual ~CreatePreparedStatementReq();
+
+  CreatePreparedStatementReq(const CreatePreparedStatementReq& from);
+
+  inline CreatePreparedStatementReq& operator=(const CreatePreparedStatementReq& 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 CreatePreparedStatementReq& default_instance();
+
+  void Swap(CreatePreparedStatementReq* other);
+
+  // implements Message ----------------------------------------------
+
+  CreatePreparedStatementReq* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const CreatePreparedStatementReq& from);
+  void MergeFrom(const CreatePreparedStatementReq& 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 string sql_query = 1;
+  inline bool has_sql_query() const;
+  inline void clear_sql_query();
+  static const int kSqlQueryFieldNumber = 1;
+  inline const ::std::string& sql_query() const;
+  inline void set_sql_query(const ::std::string& value);
+  inline void set_sql_query(const char* value);
+  inline void set_sql_query(const char* value, size_t size);
+  inline ::std::string* mutable_sql_query();
+  inline ::std::string* release_sql_query();
+  inline void set_allocated_sql_query(::std::string* sql_query);
+
+  // @@protoc_insertion_point(class_scope:exec.user.CreatePreparedStatementReq)
+ private:
+  inline void set_has_sql_query();
+  inline void clear_has_sql_query();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::std::string* sql_query_;
+
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
+
+  friend void  protobuf_AddDesc_User_2eproto();
+  friend void protobuf_AssignDesc_User_2eproto();
+  friend void protobuf_ShutdownFile_User_2eproto();
+
+  void InitAsDefaultInstance();
+  static CreatePreparedStatementReq* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ResultColumnMetadata : public ::google::protobuf::Message {
+ public:
+  ResultColumnMetadata();
+  virtual ~ResultColumnMetadata();
+
+  ResultColumnMetadata(const ResultColumnMetadata& from);
+
+  inline ResultColumnMetadata& operator=(

<TRUNCATED>

Mime
View raw message