DRILL-4853: Update C++ protobuf source files

Add support for prepared statements and metadata querying

7 files changed, 17675 insertions, 297 deletions

diff --git a/contrib/native/client/src/protobuf/CMakeLists.txt b/contrib/native/client/src/protobuf/CMakeLists.txt
index 474d2f63f..edae72f09 100644
--- a/contrib/native/client/src/protobuf/CMakeLists.txt
+++ b/contrib/native/client/src/protobuf/CMakeLists.txt
@@ -92,7 +92,7 @@ add_custom_target(fixProtobufs
     COMMAND ${PROJECT_SOURCE_DIR}/scripts/fixProtodefs.sh ${SRCDIR} ${TARGDIR} ${FNAME}
     )
 
-add_custom_target(genProtobufs DEPENDS ${GenProtoSources})
+add_custom_target(genProtobufs DEPENDS ${GenProtoSources} fixProtobufs)
 
 # copy protobuf CPP files to destinations in the source tree
 add_custom_target(cpProtobufs
diff --git a/contrib/native/client/src/protobuf/ExecutionProtos.pb.cc b/contrib/native/client/src/protobuf/ExecutionProtos.pb.cc
index a36bd9faf..26690f398 100644
--- a/contrib/native/client/src/protobuf/ExecutionProtos.pb.cc
+++ b/contrib/native/client/src/protobuf/ExecutionProtos.pb.cc
@@ -24,6 +24,9 @@ namespace {
 const ::google::protobuf::Descriptor* FragmentHandle_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   FragmentHandle_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ServerPreparedStatementState_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ServerPreparedStatementState_reflection_ = NULL;
 
 }  // namespace
 
@@ -35,10 +38,11 @@ void protobuf_AssignDesc_ExecutionProtos_2eproto() {
       "ExecutionProtos.proto");
   GOOGLE_CHECK(file != NULL);
   FragmentHandle_descriptor_ = file->message_type(0);
-  static const int FragmentHandle_offsets_[3] = {
+  static const int FragmentHandle_offsets_[4] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FragmentHandle, query_id_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FragmentHandle, major_fragment_id_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FragmentHandle, minor_fragment_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FragmentHandle, parent_query_id_),
   };
   FragmentHandle_reflection_ =
     new ::google::protobuf::internal::GeneratedMessageReflection(
@@ -51,6 +55,21 @@ void protobuf_AssignDesc_ExecutionProtos_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(FragmentHandle));
+  ServerPreparedStatementState_descriptor_ = file->message_type(1);
+  static const int ServerPreparedStatementState_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerPreparedStatementState, sql_query_),
+  };
+  ServerPreparedStatementState_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ServerPreparedStatementState_descriptor_,
+      ServerPreparedStatementState::default_instance_,
+      ServerPreparedStatementState_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerPreparedStatementState, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerPreparedStatementState, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ServerPreparedStatementState));
 }
 
 namespace {
@@ -65,6 +84,8 @@ void protobuf_RegisterTypes(const ::std::string&) {
   protobuf_AssignDescriptorsOnce();
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     FragmentHandle_descriptor_, &FragmentHandle::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ServerPreparedStatementState_descriptor_, &ServerPreparedStatementState::default_instance());
 }
 
 }  // namespace
@@ -72,6 +93,8 @@ void protobuf_RegisterTypes(const ::std::string&) {
 void protobuf_ShutdownFile_ExecutionProtos_2eproto() {
   delete FragmentHandle::default_instance_;
   delete FragmentHandle_reflection_;
+  delete ServerPreparedStatementState::default_instance_;
+  delete ServerPreparedStatementState_reflection_;
 }
 
 void protobuf_AddDesc_ExecutionProtos_2eproto() {
@@ -84,15 +107,20 @@ void protobuf_AddDesc_ExecutionProtos_2eproto() {
   ::exec::shared::protobuf_AddDesc_UserBitShared_2eproto();
   ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
     "\n\025ExecutionProtos.proto\022\010exec.bit\032\022Coord"
-    "ination.proto\032\023UserBitShared.proto\"n\n\016Fr"
-    "agmentHandle\022&\n\010query_id\030\001 \001(\0132\024.exec.sh"
-    "ared.QueryId\022\031\n\021major_fragment_id\030\002 \001(\005\022"
-    "\031\n\021minor_fragment_id\030\003 \001(\005B+\n\033org.apache"
-    ".drill.exec.protoB\nExecProtosH\001", 231);
+    "ination.proto\032\023UserBitShared.proto\"\235\001\n\016F"
+    "ragmentHandle\022&\n\010query_id\030\001 \001(\0132\024.exec.s"
+    "hared.QueryId\022\031\n\021major_fragment_id\030\002 \001(\005"
+    "\022\031\n\021minor_fragment_id\030\003 \001(\005\022-\n\017parent_qu"
+    "ery_id\030\004 \001(\0132\024.exec.shared.QueryId\"1\n\034Se"
+    "rverPreparedStatementState\022\021\n\tsql_query\030"
+    "\001 \001(\tB+\n\033org.apache.drill.exec.protoB\nEx"
+    "ecProtosH\001", 330);
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
     "ExecutionProtos.proto", &protobuf_RegisterTypes);
   FragmentHandle::default_instance_ = new FragmentHandle();
+  ServerPreparedStatementState::default_instance_ = new ServerPreparedStatementState();
   FragmentHandle::default_instance_->InitAsDefaultInstance();
+  ServerPreparedStatementState::default_instance_->InitAsDefaultInstance();
   ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_ExecutionProtos_2eproto);
 }
 
@@ -109,6 +137,7 @@ struct StaticDescriptorInitializer_ExecutionProtos_2eproto {
 const int FragmentHandle::kQueryIdFieldNumber;
 const int FragmentHandle::kMajorFragmentIdFieldNumber;
 const int FragmentHandle::kMinorFragmentIdFieldNumber;
+const int FragmentHandle::kParentQueryIdFieldNumber;
 #endif  // !_MSC_VER
 
 FragmentHandle::FragmentHandle()
@@ -118,6 +147,7 @@ FragmentHandle::FragmentHandle()
 
 void FragmentHandle::InitAsDefaultInstance() {
   query_id_ = const_cast< ::exec::shared::QueryId*>(&::exec::shared::QueryId::default_instance());
+  parent_query_id_ = const_cast< ::exec::shared::QueryId*>(&::exec::shared::QueryId::default_instance());
 }
 
 FragmentHandle::FragmentHandle(const FragmentHandle& from)
@@ -131,6 +161,7 @@ void FragmentHandle::SharedCtor() {
   query_id_ = NULL;
   major_fragment_id_ = 0;
   minor_fragment_id_ = 0;
+  parent_query_id_ = NULL;
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
@@ -141,6 +172,7 @@ FragmentHandle::~FragmentHandle() {
 void FragmentHandle::SharedDtor() {
   if (this != default_instance_) {
     delete query_id_;
+    delete parent_query_id_;
   }
 }
 
@@ -172,6 +204,9 @@ void FragmentHandle::Clear() {
     }
     major_fragment_id_ = 0;
     minor_fragment_id_ = 0;
+    if (has_parent_query_id()) {
+      if (parent_query_id_ != NULL) parent_query_id_->::exec::shared::QueryId::Clear();
+    }
   }
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
   mutable_unknown_fields()->Clear();
@@ -224,6 +259,20 @@ bool FragmentHandle::MergePartialFromCodedStream(
         } else {
           goto handle_uninterpreted;
         }
+        if (input->ExpectTag(34)) goto parse_parent_query_id;
+        break;
+      }
+
+      // optional .exec.shared.QueryId parent_query_id = 4;
+      case 4: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_parent_query_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_parent_query_id()));
+        } else {
+          goto handle_uninterpreted;
+        }
         if (input->ExpectAtEnd()) return true;
         break;
       }
@@ -262,6 +311,12 @@ void FragmentHandle::SerializeWithCachedSizes(
     ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->minor_fragment_id(), output);
   }
 
+  // optional .exec.shared.QueryId parent_query_id = 4;
+  if (has_parent_query_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->parent_query_id(), output);
+  }
+
   if (!unknown_fields().empty()) {
     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
         unknown_fields(), output);
@@ -287,6 +342,13 @@ void FragmentHandle::SerializeWithCachedSizes(
     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->minor_fragment_id(), target);
   }
 
+  // optional .exec.shared.QueryId parent_query_id = 4;
+  if (has_parent_query_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->parent_query_id(), target);
+  }
+
   if (!unknown_fields().empty()) {
     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
         unknown_fields(), target);
@@ -319,6 +381,13 @@ int FragmentHandle::ByteSize() const {
           this->minor_fragment_id());
     }
 
+    // optional .exec.shared.QueryId parent_query_id = 4;
+    if (has_parent_query_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->parent_query_id());
+    }
+
   }
   if (!unknown_fields().empty()) {
     total_size +=
@@ -355,6 +424,9 @@ void FragmentHandle::MergeFrom(const FragmentHandle& from) {
     if (from.has_minor_fragment_id()) {
       set_minor_fragment_id(from.minor_fragment_id());
     }
+    if (from.has_parent_query_id()) {
+      mutable_parent_query_id()->::exec::shared::QueryId::MergeFrom(from.parent_query_id());
+    }
   }
   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 }
@@ -381,6 +453,7 @@ void FragmentHandle::Swap(FragmentHandle* other) {
     std::swap(query_id_, other->query_id_);
     std::swap(major_fragment_id_, other->major_fragment_id_);
     std::swap(minor_fragment_id_, other->minor_fragment_id_);
+    std::swap(parent_query_id_, other->parent_query_id_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
     std::swap(_cached_size_, other->_cached_size_);
@@ -396,6 +469,231 @@ void FragmentHandle::Swap(FragmentHandle* other) {
 }
 
 
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ServerPreparedStatementState::kSqlQueryFieldNumber;
+#endif  // !_MSC_VER
+
+ServerPreparedStatementState::ServerPreparedStatementState()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void ServerPreparedStatementState::InitAsDefaultInstance() {
+}
+
+ServerPreparedStatementState::ServerPreparedStatementState(const ServerPreparedStatementState& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void ServerPreparedStatementState::SharedCtor() {
+  _cached_size_ = 0;
+  sql_query_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ServerPreparedStatementState::~ServerPreparedStatementState() {
+  SharedDtor();
+}
+
+void ServerPreparedStatementState::SharedDtor() {
+  if (sql_query_ != &::google::protobuf::internal::kEmptyString) {
+    delete sql_query_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void ServerPreparedStatementState::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ServerPreparedStatementState::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ServerPreparedStatementState_descriptor_;
+}
+
+const ServerPreparedStatementState& ServerPreparedStatementState::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_ExecutionProtos_2eproto();
+  return *default_instance_;
+}
+
+ServerPreparedStatementState* ServerPreparedStatementState::default_instance_ = NULL;
+
+ServerPreparedStatementState* ServerPreparedStatementState::New() const {
+  return new ServerPreparedStatementState;
+}
+
+void ServerPreparedStatementState::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (has_sql_query()) {
+      if (sql_query_ != &::google::protobuf::internal::kEmptyString) {
+        sql_query_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ServerPreparedStatementState::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string sql_query = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_sql_query()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->sql_query().data(), this->sql_query().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void ServerPreparedStatementState::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // optional string sql_query = 1;
+  if (has_sql_query()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->sql_query().data(), this->sql_query().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      1, this->sql_query(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* ServerPreparedStatementState::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // optional string sql_query = 1;
+  if (has_sql_query()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->sql_query().data(), this->sql_query().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->sql_query(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int ServerPreparedStatementState::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string sql_query = 1;
+    if (has_sql_query()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->sql_query());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ServerPreparedStatementState::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ServerPreparedStatementState* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ServerPreparedStatementState*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ServerPreparedStatementState::MergeFrom(const ServerPreparedStatementState& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_sql_query()) {
+      set_sql_query(from.sql_query());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ServerPreparedStatementState::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ServerPreparedStatementState::CopyFrom(const ServerPreparedStatementState& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ServerPreparedStatementState::IsInitialized() const {
+
+  return true;
+}
+
+void ServerPreparedStatementState::Swap(ServerPreparedStatementState* other) {
+  if (other != this) {
+    std::swap(sql_query_, other->sql_query_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ServerPreparedStatementState::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ServerPreparedStatementState_descriptor_;
+  metadata.reflection = ServerPreparedStatementState_reflection_;
+  return metadata;
+}
+
+
 // @@protoc_insertion_point(namespace_scope)
 
 }  // namespace bit
diff --git a/contrib/native/client/src/protobuf/ExecutionProtos.pb.h b/contrib/native/client/src/protobuf/ExecutionProtos.pb.h
index a602c1f9b..86cddb9dd 100644
--- a/contrib/native/client/src/protobuf/ExecutionProtos.pb.h
+++ b/contrib/native/client/src/protobuf/ExecutionProtos.pb.h
@@ -37,6 +37,7 @@ void protobuf_AssignDesc_ExecutionProtos_2eproto();
 void protobuf_ShutdownFile_ExecutionProtos_2eproto();
 
 class FragmentHandle;
+class ServerPreparedStatementState;
 
 // ===================================================================
 
@@ -117,6 +118,15 @@ class FragmentHandle : public ::google::protobuf::Message {
   inline ::google::protobuf::int32 minor_fragment_id() const;
   inline void set_minor_fragment_id(::google::protobuf::int32 value);
 
+  // optional .exec.shared.QueryId parent_query_id = 4;
+  inline bool has_parent_query_id() const;
+  inline void clear_parent_query_id();
+  static const int kParentQueryIdFieldNumber = 4;
+  inline const ::exec::shared::QueryId& parent_query_id() const;
+  inline ::exec::shared::QueryId* mutable_parent_query_id();
+  inline ::exec::shared::QueryId* release_parent_query_id();
+  inline void set_allocated_parent_query_id(::exec::shared::QueryId* parent_query_id);
+
   // @@protoc_insertion_point(class_scope:exec.bit.FragmentHandle)
  private:
   inline void set_has_query_id();
@@ -125,15 +135,18 @@ class FragmentHandle : public ::google::protobuf::Message {
   inline void clear_has_major_fragment_id();
   inline void set_has_minor_fragment_id();
   inline void clear_has_minor_fragment_id();
+  inline void set_has_parent_query_id();
+  inline void clear_has_parent_query_id();
 
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
   ::exec::shared::QueryId* query_id_;
   ::google::protobuf::int32 major_fragment_id_;
   ::google::protobuf::int32 minor_fragment_id_;
+  ::exec::shared::QueryId* parent_query_id_;
 
   mutable int _cached_size_;
-  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
+  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
 
   friend void  protobuf_AddDesc_ExecutionProtos_2eproto();
   friend void protobuf_AssignDesc_ExecutionProtos_2eproto();
@@ -142,6 +155,93 @@ class FragmentHandle : public ::google::protobuf::Message {
   void InitAsDefaultInstance();
   static FragmentHandle* default_instance_;
 };
+// -------------------------------------------------------------------
+
+class ServerPreparedStatementState : public ::google::protobuf::Message {
+ public:
+  ServerPreparedStatementState();
+  virtual ~ServerPreparedStatementState();
+
+  ServerPreparedStatementState(const ServerPreparedStatementState& from);
+
+  inline ServerPreparedStatementState& operator=(const ServerPreparedStatementState& 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 ServerPreparedStatementState& default_instance();
+
+  void Swap(ServerPreparedStatementState* other);
+
+  // implements Message ----------------------------------------------
+
+  ServerPreparedStatementState* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ServerPreparedStatementState& from);
+  void MergeFrom(const ServerPreparedStatementState& 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.bit.ServerPreparedStatementState)
+ 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_ExecutionProtos_2eproto();
+  friend void protobuf_AssignDesc_ExecutionProtos_2eproto();
+  friend void protobuf_ShutdownFile_ExecutionProtos_2eproto();
+
+  void InitAsDefaultInstance();
+  static ServerPreparedStatementState* default_instance_;
+};
 // ===================================================================
 
 
@@ -231,6 +331,118 @@ inline void FragmentHandle::set_minor_fragment_id(::google::protobuf::int32 valu
   minor_fragment_id_ = value;
 }
 
+// optional .exec.shared.QueryId parent_query_id = 4;
+inline bool FragmentHandle::has_parent_query_id() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void FragmentHandle::set_has_parent_query_id() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void FragmentHandle::clear_has_parent_query_id() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void FragmentHandle::clear_parent_query_id() {
+  if (parent_query_id_ != NULL) parent_query_id_->::exec::shared::QueryId::Clear();
+  clear_has_parent_query_id();
+}
+inline const ::exec::shared::QueryId& FragmentHandle::parent_query_id() const {
+  return parent_query_id_ != NULL ? *parent_query_id_ : *default_instance_->parent_query_id_;
+}
+inline ::exec::shared::QueryId* FragmentHandle::mutable_parent_query_id() {
+  set_has_parent_query_id();
+  if (parent_query_id_ == NULL) parent_query_id_ = new ::exec::shared::QueryId;
+  return parent_query_id_;
+}
+inline ::exec::shared::QueryId* FragmentHandle::release_parent_query_id() {
+  clear_has_parent_query_id();
+  ::exec::shared::QueryId* temp = parent_query_id_;
+  parent_query_id_ = NULL;
+  return temp;
+}
+inline void FragmentHandle::set_allocated_parent_query_id(::exec::shared::QueryId* parent_query_id) {
+  delete parent_query_id_;
+  parent_query_id_ = parent_query_id;
+  if (parent_query_id) {
+    set_has_parent_query_id();
+  } else {
+    clear_has_parent_query_id();
+  }
+}
+
+// -------------------------------------------------------------------
+
+// ServerPreparedStatementState
+
+// optional string sql_query = 1;
+inline bool ServerPreparedStatementState::has_sql_query() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ServerPreparedStatementState::set_has_sql_query() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ServerPreparedStatementState::clear_has_sql_query() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ServerPreparedStatementState::clear_sql_query() {
+  if (sql_query_ != &::google::protobuf::internal::kEmptyString) {
+    sql_query_->clear();
+  }
+  clear_has_sql_query();
+}
+inline const ::std::string& ServerPreparedStatementState::sql_query() const {
+  return *sql_query_;
+}
+inline void ServerPreparedStatementState::set_sql_query(const ::std::string& value) {
+  set_has_sql_query();
+  if (sql_query_ == &::google::protobuf::internal::kEmptyString) {
+    sql_query_ = new ::std::string;
+  }
+  sql_query_->assign(value);
+}
+inline void ServerPreparedStatementState::set_sql_query(const char* value) {
+  set_has_sql_query();
+  if (sql_query_ == &::google::protobuf::internal::kEmptyString) {
+    sql_query_ = new ::std::string;
+  }
+  sql_query_->assign(value);
+}
+inline void ServerPreparedStatementState::set_sql_query(const char* value, size_t size) {
+  set_has_sql_query();
+  if (sql_query_ == &::google::protobuf::internal::kEmptyString) {
+    sql_query_ = new ::std::string;
+  }
+  sql_query_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* ServerPreparedStatementState::mutable_sql_query() {
+  set_has_sql_query();
+  if (sql_query_ == &::google::protobuf::internal::kEmptyString) {
+    sql_query_ = new ::std::string;
+  }
+  return sql_query_;
+}
+inline ::std::string* ServerPreparedStatementState::release_sql_query() {
+  clear_has_sql_query();
+  if (sql_query_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = sql_query_;
+    sql_query_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void ServerPreparedStatementState::set_allocated_sql_query(::std::string* sql_query) {
+  if (sql_query_ != &::google::protobuf::internal::kEmptyString) {
+    delete sql_query_;
+  }
+  if (sql_query) {
+    set_has_sql_query();
+    sql_query_ = sql_query;
+  } else {
+    clear_has_sql_query();
+    sql_query_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
 
 // @@protoc_insertion_point(namespace_scope)
 
diff --git a/contrib/native/client/src/protobuf/User.pb.cc b/contrib/native/client/src/protobuf/User.pb.cc
index 212ad6ad2..4b0bf1026 100644
--- a/contrib/native/client/src/protobuf/User.pb.cc
+++ b/contrib/native/client/src/protobuf/User.pb.cc
@@ -27,21 +27,87 @@ const ::google::protobuf::internal::GeneratedMessageReflection*
 const ::google::protobuf::Descriptor* UserProperties_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   UserProperties_reflection_ = NULL;
+const ::google::protobuf::Descriptor* RpcEndpointInfos_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  RpcEndpointInfos_reflection_ = NULL;
 const ::google::protobuf::Descriptor* UserToBitHandshake_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   UserToBitHandshake_reflection_ = NULL;
 const ::google::protobuf::Descriptor* RequestResults_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   RequestResults_reflection_ = NULL;
-const ::google::protobuf::Descriptor* RunQuery_descriptor_ = NULL;
+const ::google::protobuf::Descriptor* GetQueryPlanFragments_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
-  RunQuery_reflection_ = NULL;
+  GetQueryPlanFragments_reflection_ = NULL;
+const ::google::protobuf::Descriptor* QueryPlanFragments_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  QueryPlanFragments_reflection_ = NULL;
 const ::google::protobuf::Descriptor* BitToUserHandshake_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   BitToUserHandshake_reflection_ = NULL;
+const ::google::protobuf::Descriptor* LikeFilter_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  LikeFilter_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetCatalogsReq_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetCatalogsReq_reflection_ = NULL;
+const ::google::protobuf::Descriptor* CatalogMetadata_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  CatalogMetadata_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetCatalogsResp_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetCatalogsResp_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetSchemasReq_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetSchemasReq_reflection_ = NULL;
+const ::google::protobuf::Descriptor* SchemaMetadata_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SchemaMetadata_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetSchemasResp_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetSchemasResp_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetTablesReq_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetTablesReq_reflection_ = NULL;
+const ::google::protobuf::Descriptor* TableMetadata_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  TableMetadata_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetTablesResp_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetTablesResp_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetColumnsReq_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetColumnsReq_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ColumnMetadata_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ColumnMetadata_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetColumnsResp_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetColumnsResp_reflection_ = NULL;
+const ::google::protobuf::Descriptor* CreatePreparedStatementReq_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  CreatePreparedStatementReq_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ResultColumnMetadata_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ResultColumnMetadata_reflection_ = NULL;
+const ::google::protobuf::Descriptor* PreparedStatementHandle_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  PreparedStatementHandle_reflection_ = NULL;
+const ::google::protobuf::Descriptor* PreparedStatement_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  PreparedStatement_reflection_ = NULL;
+const ::google::protobuf::Descriptor* CreatePreparedStatementResp_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  CreatePreparedStatementResp_reflection_ = NULL;
+const ::google::protobuf::Descriptor* RunQuery_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  RunQuery_reflection_ = NULL;
 const ::google::protobuf::EnumDescriptor* RpcType_descriptor_ = NULL;
 const ::google::protobuf::EnumDescriptor* QueryResultsMode_descriptor_ = NULL;
 const ::google::protobuf::EnumDescriptor* HandshakeStatus_descriptor_ = NULL;
+const ::google::protobuf::EnumDescriptor* RequestStatus_descriptor_ = NULL;
+const ::google::protobuf::EnumDescriptor* ColumnSearchability_descriptor_ = NULL;
+const ::google::protobuf::EnumDescriptor* ColumnUpdatability_descriptor_ = NULL;
 
 }  // namespace
 
@@ -83,8 +149,28 @@ void protobuf_AssignDesc_User_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(UserProperties));
-  UserToBitHandshake_descriptor_ = file->message_type(2);
-  static const int UserToBitHandshake_offsets_[7] = {
+  RpcEndpointInfos_descriptor_ = file->message_type(2);
+  static const int RpcEndpointInfos_offsets_[6] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RpcEndpointInfos, name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RpcEndpointInfos, version_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RpcEndpointInfos, majorversion_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RpcEndpointInfos, minorversion_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RpcEndpointInfos, patchversion_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RpcEndpointInfos, application_),
+  };
+  RpcEndpointInfos_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      RpcEndpointInfos_descriptor_,
+      RpcEndpointInfos::default_instance_,
+      RpcEndpointInfos_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RpcEndpointInfos, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RpcEndpointInfos, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(RpcEndpointInfos));
+  UserToBitHandshake_descriptor_ = file->message_type(3);
+  static const int UserToBitHandshake_offsets_[8] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserToBitHandshake, channel_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserToBitHandshake, support_listening_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserToBitHandshake, rpc_version_),
@@ -92,6 +178,7 @@ void protobuf_AssignDesc_User_2eproto() {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserToBitHandshake, properties_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserToBitHandshake, support_complex_types_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserToBitHandshake, support_timeout_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserToBitHandshake, client_infos_),
   };
   UserToBitHandshake_reflection_ =
     new ::google::protobuf::internal::GeneratedMessageReflection(
@@ -104,7 +191,7 @@ void protobuf_AssignDesc_User_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(UserToBitHandshake));
-  RequestResults_descriptor_ = file->message_type(3);
+  RequestResults_descriptor_ = file->message_type(4);
   static const int RequestResults_offsets_[2] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RequestResults, query_id_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RequestResults, maximum_responses_),
@@ -120,29 +207,48 @@ void protobuf_AssignDesc_User_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(RequestResults));
-  RunQuery_descriptor_ = file->message_type(4);
-  static const int RunQuery_offsets_[3] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RunQuery, results_mode_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RunQuery, type_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RunQuery, plan_),
+  GetQueryPlanFragments_descriptor_ = file->message_type(5);
+  static const int GetQueryPlanFragments_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetQueryPlanFragments, query_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetQueryPlanFragments, type_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetQueryPlanFragments, split_plan_),
   };
-  RunQuery_reflection_ =
+  GetQueryPlanFragments_reflection_ =
     new ::google::protobuf::internal::GeneratedMessageReflection(
-      RunQuery_descriptor_,
-      RunQuery::default_instance_,
-      RunQuery_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RunQuery, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RunQuery, _unknown_fields_),
+      GetQueryPlanFragments_descriptor_,
+      GetQueryPlanFragments::default_instance_,
+      GetQueryPlanFragments_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetQueryPlanFragments, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetQueryPlanFragments, _unknown_fields_),
       -1,
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(RunQuery));
-  BitToUserHandshake_descriptor_ = file->message_type(5);
-  static const int BitToUserHandshake_offsets_[4] = {
+      sizeof(GetQueryPlanFragments));
+  QueryPlanFragments_descriptor_ = file->message_type(6);
+  static const int QueryPlanFragments_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryPlanFragments, status_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryPlanFragments, query_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryPlanFragments, fragments_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryPlanFragments, error_),
+  };
+  QueryPlanFragments_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      QueryPlanFragments_descriptor_,
+      QueryPlanFragments::default_instance_,
+      QueryPlanFragments_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryPlanFragments, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryPlanFragments, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(QueryPlanFragments));
+  BitToUserHandshake_descriptor_ = file->message_type(7);
+  static const int BitToUserHandshake_offsets_[5] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BitToUserHandshake, rpc_version_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BitToUserHandshake, status_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BitToUserHandshake, errorid_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BitToUserHandshake, errormessage_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BitToUserHandshake, server_infos_),
   };
   BitToUserHandshake_reflection_ =
     new ::google::protobuf::internal::GeneratedMessageReflection(
@@ -155,9 +261,363 @@ void protobuf_AssignDesc_User_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(BitToUserHandshake));
+  LikeFilter_descriptor_ = file->message_type(8);
+  static const int LikeFilter_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LikeFilter, pattern_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LikeFilter, escape_),
+  };
+  LikeFilter_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      LikeFilter_descriptor_,
+      LikeFilter::default_instance_,
+      LikeFilter_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LikeFilter, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LikeFilter, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(LikeFilter));
+  GetCatalogsReq_descriptor_ = file->message_type(9);
+  static const int GetCatalogsReq_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetCatalogsReq, catalog_name_filter_),
+  };
+  GetCatalogsReq_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetCatalogsReq_descriptor_,
+      GetCatalogsReq::default_instance_,
+      GetCatalogsReq_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetCatalogsReq, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetCatalogsReq, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetCatalogsReq));
+  CatalogMetadata_descriptor_ = file->message_type(10);
+  static const int CatalogMetadata_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CatalogMetadata, catalog_name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CatalogMetadata, description_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CatalogMetadata, connect_),
+  };
+  CatalogMetadata_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      CatalogMetadata_descriptor_,
+      CatalogMetadata::default_instance_,
+      CatalogMetadata_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CatalogMetadata, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CatalogMetadata, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(CatalogMetadata));
+  GetCatalogsResp_descriptor_ = file->message_type(11);
+  static const int GetCatalogsResp_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetCatalogsResp, status_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetCatalogsResp, catalogs_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetCatalogsResp, error_),
+  };
+  GetCatalogsResp_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetCatalogsResp_descriptor_,
+      GetCatalogsResp::default_instance_,
+      GetCatalogsResp_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetCatalogsResp, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetCatalogsResp, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetCatalogsResp));
+  GetSchemasReq_descriptor_ = file->message_type(12);
+  static const int GetSchemasReq_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetSchemasReq, catalog_name_filter_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetSchemasReq, schema_name_filter_),
+  };
+  GetSchemasReq_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetSchemasReq_descriptor_,
+      GetSchemasReq::default_instance_,
+      GetSchemasReq_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetSchemasReq, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetSchemasReq, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetSchemasReq));
+  SchemaMetadata_descriptor_ = file->message_type(13);
+  static const int SchemaMetadata_offsets_[5] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SchemaMetadata, catalog_name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SchemaMetadata, schema_name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SchemaMetadata, owner_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SchemaMetadata, type_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SchemaMetadata, mutable__),
+  };
+  SchemaMetadata_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SchemaMetadata_descriptor_,
+      SchemaMetadata::default_instance_,
+      SchemaMetadata_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SchemaMetadata, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SchemaMetadata, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SchemaMetadata));
+  GetSchemasResp_descriptor_ = file->message_type(14);
+  static const int GetSchemasResp_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetSchemasResp, status_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetSchemasResp, schemas_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetSchemasResp, error_),
+  };
+  GetSchemasResp_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetSchemasResp_descriptor_,
+      GetSchemasResp::default_instance_,
+      GetSchemasResp_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetSchemasResp, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetSchemasResp, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetSchemasResp));
+  GetTablesReq_descriptor_ = file->message_type(15);
+  static const int GetTablesReq_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetTablesReq, catalog_name_filter_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetTablesReq, schema_name_filter_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetTablesReq, table_name_filter_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetTablesReq, table_type_filter_),
+  };
+  GetTablesReq_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetTablesReq_descriptor_,
+      GetTablesReq::default_instance_,
+      GetTablesReq_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetTablesReq, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetTablesReq, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetTablesReq));
+  TableMetadata_descriptor_ = file->message_type(16);
+  static const int TableMetadata_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TableMetadata, catalog_name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TableMetadata, schema_name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TableMetadata, table_name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TableMetadata, type_),
+  };
+  TableMetadata_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      TableMetadata_descriptor_,
+      TableMetadata::default_instance_,
+      TableMetadata_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TableMetadata, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TableMetadata, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(TableMetadata));
+  GetTablesResp_descriptor_ = file->message_type(17);
+  static const int GetTablesResp_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetTablesResp, status_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetTablesResp, tables_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetTablesResp, error_),
+  };
+  GetTablesResp_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetTablesResp_descriptor_,
+      GetTablesResp::default_instance_,
+      GetTablesResp_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetTablesResp, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetTablesResp, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetTablesResp));
+  GetColumnsReq_descriptor_ = file->message_type(18);
+  static const int GetColumnsReq_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetColumnsReq, catalog_name_filter_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetColumnsReq, schema_name_filter_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetColumnsReq, table_name_filter_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetColumnsReq, column_name_filter_),
+  };
+  GetColumnsReq_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetColumnsReq_descriptor_,
+      GetColumnsReq::default_instance_,
+      GetColumnsReq_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetColumnsReq, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetColumnsReq, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetColumnsReq));
+  ColumnMetadata_descriptor_ = file->message_type(19);
+  static const int ColumnMetadata_offsets_[17] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ColumnMetadata, catalog_name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ColumnMetadata, schema_name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ColumnMetadata, table_name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ColumnMetadata, column_name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ColumnMetadata, ordinal_position_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ColumnMetadata, default_value_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ColumnMetadata, is_nullable_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ColumnMetadata, data_type_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ColumnMetadata, char_max_length_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ColumnMetadata, char_octet_length_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ColumnMetadata, numeric_precision_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ColumnMetadata, numeric_precision_radix_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ColumnMetadata, numeric_scale_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ColumnMetadata, date_time_precision_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ColumnMetadata, interval_type_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ColumnMetadata, interval_precision_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ColumnMetadata, column_size_),
+  };
+  ColumnMetadata_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ColumnMetadata_descriptor_,
+      ColumnMetadata::default_instance_,
+      ColumnMetadata_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ColumnMetadata, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ColumnMetadata, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ColumnMetadata));
+  GetColumnsResp_descriptor_ = file->message_type(20);
+  static const int GetColumnsResp_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetColumnsResp, status_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetColumnsResp, columns_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetColumnsResp, error_),
+  };
+  GetColumnsResp_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetColumnsResp_descriptor_,
+      GetColumnsResp::default_instance_,
+      GetColumnsResp_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetColumnsResp, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetColumnsResp, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetColumnsResp));
+  CreatePreparedStatementReq_descriptor_ = file->message_type(21);
+  static const int CreatePreparedStatementReq_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreatePreparedStatementReq, sql_query_),
+  };
+  CreatePreparedStatementReq_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      CreatePreparedStatementReq_descriptor_,
+      CreatePreparedStatementReq::default_instance_,
+      CreatePreparedStatementReq_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreatePreparedStatementReq, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreatePreparedStatementReq, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(CreatePreparedStatementReq));
+  ResultColumnMetadata_descriptor_ = file->message_type(22);
+  static const int ResultColumnMetadata_offsets_[19] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ResultColumnMetadata, catalog_name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ResultColumnMetadata, schema_name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ResultColumnMetadata, table_name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ResultColumnMetadata, column_name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ResultColumnMetadata, label_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ResultColumnMetadata, data_type_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ResultColumnMetadata, is_nullable_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ResultColumnMetadata, precision_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ResultColumnMetadata, scale_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ResultColumnMetadata, signed__),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ResultColumnMetadata, display_size_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ResultColumnMetadata, is_aliased_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ResultColumnMetadata, searchability_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ResultColumnMetadata, updatability_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ResultColumnMetadata, auto_increment_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ResultColumnMetadata, case_sensitivity_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ResultColumnMetadata, sortable_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ResultColumnMetadata, class_name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ResultColumnMetadata, is_currency_),
+  };
+  ResultColumnMetadata_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ResultColumnMetadata_descriptor_,
+      ResultColumnMetadata::default_instance_,
+      ResultColumnMetadata_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ResultColumnMetadata, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ResultColumnMetadata, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ResultColumnMetadata));
+  PreparedStatementHandle_descriptor_ = file->message_type(23);
+  static const int PreparedStatementHandle_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PreparedStatementHandle, server_info_),
+  };
+  PreparedStatementHandle_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      PreparedStatementHandle_descriptor_,
+      PreparedStatementHandle::default_instance_,
+      PreparedStatementHandle_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PreparedStatementHandle, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PreparedStatementHandle, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(PreparedStatementHandle));
+  PreparedStatement_descriptor_ = file->message_type(24);
+  static const int PreparedStatement_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PreparedStatement, columns_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PreparedStatement, server_handle_),
+  };
+  PreparedStatement_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      PreparedStatement_descriptor_,
+      PreparedStatement::default_instance_,
+      PreparedStatement_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PreparedStatement, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PreparedStatement, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(PreparedStatement));
+  CreatePreparedStatementResp_descriptor_ = file->message_type(25);
+  static const int CreatePreparedStatementResp_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreatePreparedStatementResp, status_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreatePreparedStatementResp, prepared_statement_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreatePreparedStatementResp, error_),
+  };
+  CreatePreparedStatementResp_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      CreatePreparedStatementResp_descriptor_,
+      CreatePreparedStatementResp::default_instance_,
+      CreatePreparedStatementResp_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreatePreparedStatementResp, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreatePreparedStatementResp, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(CreatePreparedStatementResp));
+  RunQuery_descriptor_ = file->message_type(26);
+  static const int RunQuery_offsets_[5] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RunQuery, results_mode_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RunQuery, type_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RunQuery, plan_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RunQuery, fragments_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RunQuery, prepared_statement_handle_),
+  };
+  RunQuery_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      RunQuery_descriptor_,
+      RunQuery::default_instance_,
+      RunQuery_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RunQuery, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RunQuery, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(RunQuery));
   RpcType_descriptor_ = file->enum_type(0);
   QueryResultsMode_descriptor_ = file->enum_type(1);
   HandshakeStatus_descriptor_ = file->enum_type(2);
+  RequestStatus_descriptor_ = file->enum_type(3);
+  ColumnSearchability_descriptor_ = file->enum_type(4);
+  ColumnUpdatability_descriptor_ = file->enum_type(5);
 }
 
 namespace {
@@ -175,13 +635,55 @@ void protobuf_RegisterTypes(const ::std::string&) {
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     UserProperties_descriptor_, &UserProperties::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    RpcEndpointInfos_descriptor_, &RpcEndpointInfos::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     UserToBitHandshake_descriptor_, &UserToBitHandshake::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     RequestResults_descriptor_, &RequestResults::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    RunQuery_descriptor_, &RunQuery::default_instance());
+    GetQueryPlanFragments_descriptor_, &GetQueryPlanFragments::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    QueryPlanFragments_descriptor_, &QueryPlanFragments::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     BitToUserHandshake_descriptor_, &BitToUserHandshake::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    LikeFilter_descriptor_, &LikeFilter::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetCatalogsReq_descriptor_, &GetCatalogsReq::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    CatalogMetadata_descriptor_, &CatalogMetadata::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetCatalogsResp_descriptor_, &GetCatalogsResp::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetSchemasReq_descriptor_, &GetSchemasReq::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SchemaMetadata_descriptor_, &SchemaMetadata::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetSchemasResp_descriptor_, &GetSchemasResp::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetTablesReq_descriptor_, &GetTablesReq::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    TableMetadata_descriptor_, &TableMetadata::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetTablesResp_descriptor_, &GetTablesResp::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetColumnsReq_descriptor_, &GetColumnsReq::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ColumnMetadata_descriptor_, &ColumnMetadata::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetColumnsResp_descriptor_, &GetColumnsResp::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    CreatePreparedStatementReq_descriptor_, &CreatePreparedStatementReq::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ResultColumnMetadata_descriptor_, &ResultColumnMetadata::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    PreparedStatementHandle_descriptor_, &PreparedStatementHandle::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    PreparedStatement_descriptor_, &PreparedStatement::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    CreatePreparedStatementResp_descriptor_, &CreatePreparedStatementResp::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    RunQuery_descriptor_, &RunQuery::default_instance());
 }
 
 }  // namespace
@@ -191,14 +693,56 @@ void protobuf_ShutdownFile_User_2eproto() {
   delete Property_reflection_;
   delete UserProperties::default_instance_;
   delete UserProperties_reflection_;
+  delete RpcEndpointInfos::default_instance_;
+  delete RpcEndpointInfos_reflection_;
   delete UserToBitHandshake::default_instance_;
   delete UserToBitHandshake_reflection_;
   delete RequestResults::default_instance_;
   delete RequestResults_reflection_;
-  delete RunQuery::default_instance_;
-  delete RunQuery_reflection_;
+  delete GetQueryPlanFragments::default_instance_;
+  delete GetQueryPlanFragments_reflection_;
+  delete QueryPlanFragments::default_instance_;
+  delete QueryPlanFragments_reflection_;
   delete BitToUserHandshake::default_instance_;
   delete BitToUserHandshake_reflection_;
+  delete LikeFilter::default_instance_;
+  delete LikeFilter_reflection_;
+  delete GetCatalogsReq::default_instance_;
+  delete GetCatalogsReq_reflection_;
+  delete CatalogMetadata::default_instance_;
+  delete CatalogMetadata_reflection_;
+  delete GetCatalogsResp::default_instance_;
+  delete GetCatalogsResp_reflection_;
+  delete GetSchemasReq::default_instance_;
+  delete GetSchemasReq_reflection_;
+  delete SchemaMetadata::default_instance_;
+  delete SchemaMetadata_reflection_;
+  delete GetSchemasResp::default_instance_;
+  delete GetSchemasResp_reflection_;
+  delete GetTablesReq::default_instance_;
+  delete GetTablesReq_reflection_;
+  delete TableMetadata::default_instance_;
+  delete TableMetadata_reflection_;
+  delete GetTablesResp::default_instance_;
+  delete GetTablesResp_reflection_;
+  delete GetColumnsReq::default_instance_;
+  delete GetColumnsReq_reflection_;
+  delete ColumnMetadata::default_instance_;
+  delete ColumnMetadata_reflection_;
+  delete GetColumnsResp::default_instance_;
+  delete GetColumnsResp_reflection_;
+  delete CreatePreparedStatementReq::default_instance_;
+  delete CreatePreparedStatementReq_reflection_;
+  delete ResultColumnMetadata::default_instance_;
+  delete ResultColumnMetadata_reflection_;
+  delete PreparedStatementHandle::default_instance_;
+  delete PreparedStatementHandle_reflection_;
+  delete PreparedStatement::default_instance_;
+  delete PreparedStatement_reflection_;
+  delete CreatePreparedStatementResp::default_instance_;
+  delete CreatePreparedStatementResp_reflection_;
+  delete RunQuery::default_instance_;
+  delete RunQuery_reflection_;
 }
 
 void protobuf_AddDesc_User_2eproto() {
@@ -209,51 +753,197 @@ void protobuf_AddDesc_User_2eproto() {
 
   ::exec::protobuf_AddDesc_SchemaDef_2eproto();
   ::exec::shared::protobuf_AddDesc_UserBitShared_2eproto();
+  ::exec::bit::data::protobuf_AddDesc_BitData_2eproto();
+  ::exec::bit::control::protobuf_AddDesc_BitControl_2eproto();
+  ::exec::bit::protobuf_AddDesc_ExecutionProtos_2eproto();
   ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
     "\n\nUser.proto\022\texec.user\032\017SchemaDef.proto"
-    "\032\023UserBitShared.proto\"&\n\010Property\022\013\n\003key"
-    "\030\001 \002(\t\022\r\n\005value\030\002 \002(\t\"9\n\016UserProperties\022"
-    "\'\n\nproperties\030\001 \003(\0132\023.exec.user.Property"
-    "\"\234\002\n\022UserToBitHandshake\022.\n\007channel\030\001 \001(\016"
-    "2\027.exec.shared.RpcChannel:\004USER\022\031\n\021suppo"
-    "rt_listening\030\002 \001(\010\022\023\n\013rpc_version\030\003 \001(\005\022"
-    "1\n\013credentials\030\004 \001(\0132\034.exec.shared.UserC"
-    "redentials\022-\n\nproperties\030\005 \001(\0132\031.exec.us"
-    "er.UserProperties\022$\n\025support_complex_typ"
-    "es\030\006 \001(\010:\005false\022\036\n\017support_timeout\030\007 \001(\010"
-    ":\005false\"S\n\016RequestResults\022&\n\010query_id\030\001 "
-    "\001(\0132\024.exec.shared.QueryId\022\031\n\021maximum_res"
-    "ponses\030\002 \001(\005\"q\n\010RunQuery\0221\n\014results_mode"
-    "\030\001 \001(\0162\033.exec.user.QueryResultsMode\022$\n\004t"
-    "ype\030\002 \001(\0162\026.exec.shared.QueryType\022\014\n\004pla"
-    "n\030\003 \001(\t\"|\n\022BitToUserHandshake\022\023\n\013rpc_ver"
-    "sion\030\002 \001(\005\022*\n\006status\030\003 \001(\0162\032.exec.user.H"
-    "andshakeStatus\022\017\n\007errorId\030\004 \001(\t\022\024\n\014error"
-    "Message\030\005 \001(\t*\341\001\n\007RpcType\022\r\n\tHANDSHAKE\020\000"
-    "\022\007\n\003ACK\020\001\022\013\n\007GOODBYE\020\002\022\r\n\tRUN_QUERY\020\003\022\020\n"
-    "\014CANCEL_QUERY\020\004\022\023\n\017REQUEST_RESULTS\020\005\022\027\n\023"
-    "RESUME_PAUSED_QUERY\020\013\022\016\n\nQUERY_DATA\020\006\022\020\n"
-    "\014QUERY_HANDLE\020\007\022\026\n\022REQ_META_FUNCTIONS\020\010\022"
-    "\026\n\022RESP_FUNCTION_LIST\020\t\022\020\n\014QUERY_RESULT\020"
-    "\n*#\n\020QueryResultsMode\022\017\n\013STREAM_FULL\020\001*^"
-    "\n\017HandshakeStatus\022\013\n\007SUCCESS\020\001\022\030\n\024RPC_VE"
-    "RSION_MISMATCH\020\002\022\017\n\013AUTH_FAILED\020\003\022\023\n\017UNK"
-    "NOWN_FAILURE\020\004B+\n\033org.apache.drill.exec."
-    "protoB\nUserProtosH\001", 1179);
+    "\032\023UserBitShared.proto\032\rBitData.proto\032\020Bi"
+    "tControl.proto\032\025ExecutionProtos.proto\"&\n"
+    "\010Property\022\013\n\003key\030\001 \002(\t\022\r\n\005value\030\002 \002(\t\"9\n"
+    "\016UserProperties\022\'\n\nproperties\030\001 \003(\0132\023.ex"
+    "ec.user.Property\"\210\001\n\020RpcEndpointInfos\022\014\n"
+    "\004name\030\001 \001(\t\022\017\n\007version\030\002 \001(\t\022\024\n\014majorVer"
+    "sion\030\003 \001(\r\022\024\n\014minorVersion\030\004 \001(\r\022\024\n\014patc"
+    "hVersion\030\005 \001(\r\022\023\n\013application\030\006 \001(\t\"\317\002\n\022"
+    "UserToBitHandshake\022.\n\007channel\030\001 \001(\0162\027.ex"
+    "ec.shared.RpcChannel:\004USER\022\031\n\021support_li"
+    "stening\030\002 \001(\010\022\023\n\013rpc_version\030\003 \001(\005\0221\n\013cr"
+    "edentials\030\004 \001(\0132\034.exec.shared.UserCreden"
+    "tials\022-\n\nproperties\030\005 \001(\0132\031.exec.user.Us"
+    "erProperties\022$\n\025support_complex_types\030\006 "
+    "\001(\010:\005false\022\036\n\017support_timeout\030\007 \001(\010:\005fal"
+    "se\0221\n\014client_infos\030\010 \001(\0132\033.exec.user.Rpc"
+    "EndpointInfos\"S\n\016RequestResults\022&\n\010query"
+    "_id\030\001 \001(\0132\024.exec.shared.QueryId\022\031\n\021maxim"
+    "um_responses\030\002 \001(\005\"g\n\025GetQueryPlanFragme"
+    "nts\022\r\n\005query\030\001 \002(\t\022$\n\004type\030\002 \001(\0162\026.exec."
+    "shared.QueryType\022\031\n\nsplit_plan\030\003 \001(\010:\005fa"
+    "lse\"\316\001\n\022QueryPlanFragments\0223\n\006status\030\001 \002"
+    "(\0162#.exec.shared.QueryResult.QueryState\022"
+    "&\n\010query_id\030\002 \001(\0132\024.exec.shared.QueryId\022"
+    "1\n\tfragments\030\003 \003(\0132\036.exec.bit.control.Pl"
+    "anFragment\022(\n\005error\030\004 \001(\0132\031.exec.shared."
+    "DrillPBError\"\257\001\n\022BitToUserHandshake\022\023\n\013r"
+    "pc_version\030\002 \001(\005\022*\n\006status\030\003 \001(\0162\032.exec."
+    "user.HandshakeStatus\022\017\n\007errorId\030\004 \001(\t\022\024\n"
+    "\014errorMessage\030\005 \001(\t\0221\n\014server_infos\030\006 \001("
+    "\0132\033.exec.user.RpcEndpointInfos\"-\n\nLikeFi"
+    "lter\022\017\n\007pattern\030\001 \001(\t\022\016\n\006escape\030\002 \001(\t\"D\n"
+    "\016GetCatalogsReq\0222\n\023catalog_name_filter\030\001"
+    " \001(\0132\025.exec.user.LikeFilter\"M\n\017CatalogMe"
+    "tadata\022\024\n\014catalog_name\030\001 \001(\t\022\023\n\013descript"
+    "ion\030\002 \001(\t\022\017\n\007connect\030\003 \001(\t\"\223\001\n\017GetCatalo"
+    "gsResp\022(\n\006status\030\001 \001(\0162\030.exec.user.Reque"
+    "stStatus\022,\n\010catalogs\030\002 \003(\0132\032.exec.user.C"
+    "atalogMetadata\022(\n\005error\030\003 \001(\0132\031.exec.sha"
+    "red.DrillPBError\"v\n\rGetSchemasReq\0222\n\023cat"
+    "alog_name_filter\030\001 \001(\0132\025.exec.user.LikeF"
+    "ilter\0221\n\022schema_name_filter\030\002 \001(\0132\025.exec"
+    ".user.LikeFilter\"i\n\016SchemaMetadata\022\024\n\014ca"
+    "talog_name\030\001 \001(\t\022\023\n\013schema_name\030\002 \001(\t\022\r\n"
+    "\005owner\030\003 \001(\t\022\014\n\004type\030\004 \001(\t\022\017\n\007mutable\030\005 "
+    "\001(\t\"\220\001\n\016GetSchemasResp\022(\n\006status\030\001 \001(\0162\030"
+    ".exec.user.RequestStatus\022*\n\007schemas\030\002 \003("
+    "\0132\031.exec.user.SchemaMetadata\022(\n\005error\030\003 "
+    "\001(\0132\031.exec.shared.DrillPBError\"\302\001\n\014GetTa"
+    "blesReq\0222\n\023catalog_name_filter\030\001 \001(\0132\025.e"
+    "xec.user.LikeFilter\0221\n\022schema_name_filte"
+    "r\030\002 \001(\0132\025.exec.user.LikeFilter\0220\n\021table_"
+    "name_filter\030\003 \001(\0132\025.exec.user.LikeFilter"
+    "\022\031\n\021table_type_filter\030\004 \003(\t\"\\\n\rTableMeta"
+    "data\022\024\n\014catalog_name\030\001 \001(\t\022\023\n\013schema_nam"
+    "e\030\002 \001(\t\022\022\n\ntable_name\030\003 \001(\t\022\014\n\004type\030\004 \001("
+    "\t\"\215\001\n\rGetTablesResp\022(\n\006status\030\001 \001(\0162\030.ex"
+    "ec.user.RequestStatus\022(\n\006tables\030\002 \003(\0132\030."
+    "exec.user.TableMetadata\022(\n\005error\030\003 \001(\0132\031"
+    ".exec.shared.DrillPBError\"\333\001\n\rGetColumns"
+    "Req\0222\n\023catalog_name_filter\030\001 \001(\0132\025.exec."
+    "user.LikeFilter\0221\n\022schema_name_filter\030\002 "
+    "\001(\0132\025.exec.user.LikeFilter\0220\n\021table_name"
+    "_filter\030\003 \001(\0132\025.exec.user.LikeFilter\0221\n\022"
+    "column_name_filter\030\004 \001(\0132\025.exec.user.Lik"
+    "eFilter\"\251\003\n\016ColumnMetadata\022\024\n\014catalog_na"
+    "me\030\001 \001(\t\022\023\n\013schema_name\030\002 \001(\t\022\022\n\ntable_n"
+    "ame\030\003 \001(\t\022\023\n\013column_name\030\004 \001(\t\022\030\n\020ordina"
+    "l_position\030\005 \001(\005\022\025\n\rdefault_value\030\006 \001(\t\022"
+    "\023\n\013is_nullable\030\007 \001(\010\022\021\n\tdata_type\030\010 \001(\t\022"
+    "\027\n\017char_max_length\030\t \001(\005\022\031\n\021char_octet_l"
+    "ength\030\n \001(\005\022\031\n\021numeric_precision\030\013 \001(\005\022\037"
+    "\n\027numeric_precision_radix\030\014 \001(\005\022\025\n\rnumer"
+    "ic_scale\030\r \001(\005\022\033\n\023date_time_precision\030\016 "
+    "\001(\005\022\025\n\rinterval_type\030\017 \001(\t\022\032\n\022interval_p"
+    "recision\030\020 \001(\005\022\023\n\013column_size\030\021 \001(\005\"\220\001\n\016"
+    "GetColumnsResp\022(\n\006status\030\001 \001(\0162\030.exec.us"
+    "er.RequestStatus\022*\n\007columns\030\002 \003(\0132\031.exec"
+    ".user.ColumnMetadata\022(\n\005error\030\003 \001(\0132\031.ex"
+    "ec.shared.DrillPBError\"/\n\032CreatePrepared"
+    "StatementReq\022\021\n\tsql_query\030\001 \001(\t\"\326\003\n\024Resu"
+    "ltColumnMetadata\022\024\n\014catalog_name\030\001 \001(\t\022\023"
+    "\n\013schema_name\030\002 \001(\t\022\022\n\ntable_name\030\003 \001(\t\022"
+    "\023\n\013column_name\030\004 \001(\t\022\r\n\005label\030\005 \001(\t\022\021\n\td"
+    "ata_type\030\006 \001(\t\022\023\n\013is_nullable\030\007 \001(\010\022\021\n\tp"
+    "recision\030\010 \001(\005\022\r\n\005scale\030\t \001(\005\022\016\n\006signed\030"
+    "\n \001(\010\022\024\n\014display_size\030\013 \001(\005\022\022\n\nis_aliase"
+    "d\030\014 \001(\010\0225\n\rsearchability\030\r \001(\0162\036.exec.us"
+    "er.ColumnSearchability\0223\n\014updatability\030\016"
+    " \001(\0162\035.exec.user.ColumnUpdatability\022\026\n\016a"
+    "uto_increment\030\017 \001(\010\022\030\n\020case_sensitivity\030"
+    "\020 \001(\010\022\020\n\010sortable\030\021 \001(\010\022\022\n\nclass_name\030\022 "
+    "\001(\t\022\023\n\013is_currency\030\024 \001(\010\".\n\027PreparedStat"
+    "ementHandle\022\023\n\013server_info\030\001 \001(\014\"\200\001\n\021Pre"
+    "paredStatement\0220\n\007columns\030\001 \003(\0132\037.exec.u"
+    "ser.ResultColumnMetadata\0229\n\rserver_handl"
+    "e\030\002 \001(\0132\".exec.user.PreparedStatementHan"
+    "dle\"\253\001\n\033CreatePreparedStatementResp\022(\n\006s"
+    "tatus\030\001 \001(\0162\030.exec.user.RequestStatus\0228\n"
+    "\022prepared_statement\030\002 \001(\0132\034.exec.user.Pr"
+    "eparedStatement\022(\n\005error\030\003 \001(\0132\031.exec.sh"
+    "ared.DrillPBError\"\353\001\n\010RunQuery\0221\n\014result"
+    "s_mode\030\001 \001(\0162\033.exec.user.QueryResultsMod"
+    "e\022$\n\004type\030\002 \001(\0162\026.exec.shared.QueryType\022"
+    "\014\n\004plan\030\003 \001(\t\0221\n\tfragments\030\004 \003(\0132\036.exec."
+    "bit.control.PlanFragment\022E\n\031prepared_sta"
+    "tement_handle\030\005 \001(\0132\".exec.user.Prepared"
+    "StatementHandle*\310\003\n\007RpcType\022\r\n\tHANDSHAKE"
+    "\020\000\022\007\n\003ACK\020\001\022\013\n\007GOODBYE\020\002\022\r\n\tRUN_QUERY\020\003\022"
+    "\020\n\014CANCEL_QUERY\020\004\022\023\n\017REQUEST_RESULTS\020\005\022\027"
+    "\n\023RESUME_PAUSED_QUERY\020\013\022\034\n\030GET_QUERY_PLA"
+    "N_FRAGMENTS\020\014\022\020\n\014GET_CATALOGS\020\016\022\017\n\013GET_S"
+    "CHEMAS\020\017\022\016\n\nGET_TABLES\020\020\022\017\n\013GET_COLUMNS\020"
+    "\021\022\035\n\031CREATE_PREPARED_STATEMENT\020\026\022\016\n\nQUER"
+    "Y_DATA\020\006\022\020\n\014QUERY_HANDLE\020\007\022\030\n\024QUERY_PLAN"
+    "_FRAGMENTS\020\r\022\014\n\010CATALOGS\020\022\022\013\n\007SCHEMAS\020\023\022"
+    "\n\n\006TABLES\020\024\022\013\n\007COLUMNS\020\025\022\026\n\022PREPARED_STA"
+    "TEMENT\020\027\022\026\n\022REQ_META_FUNCTIONS\020\010\022\026\n\022RESP"
+    "_FUNCTION_LIST\020\t\022\020\n\014QUERY_RESULT\020\n*#\n\020Qu"
+    "eryResultsMode\022\017\n\013STREAM_FULL\020\001*^\n\017Hands"
+    "hakeStatus\022\013\n\007SUCCESS\020\001\022\030\n\024RPC_VERSION_M"
+    "ISMATCH\020\002\022\017\n\013AUTH_FAILED\020\003\022\023\n\017UNKNOWN_FA"
+    "ILURE\020\004*D\n\rRequestStatus\022\022\n\016UNKNOWN_STAT"
+    "US\020\000\022\006\n\002OK\020\001\022\n\n\006FAILED\020\002\022\013\n\007TIMEOUT\020\003*Y\n"
+    "\023ColumnSearchability\022\031\n\025UNKNOWN_SEARCHAB"
+    "ILITY\020\000\022\010\n\004NONE\020\001\022\010\n\004CHAR\020\002\022\n\n\006NUMBER\020\003\022"
+    "\007\n\003ALL\020\004*K\n\022ColumnUpdatability\022\030\n\024UNKNOW"
+    "N_UPDATABILITY\020\000\022\r\n\tREAD_ONLY\020\001\022\014\n\010WRITA"
+    "BLE\020\002B+\n\033org.apache.drill.exec.protoB\nUs"
+    "erProtosH\001", 5210);
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
     "User.proto", &protobuf_RegisterTypes);
   Property::default_instance_ = new Property();
   UserProperties::default_instance_ = new UserProperties();
+  RpcEndpointInfos::default_instance_ = new RpcEndpointInfos();
   UserToBitHandshake::default_instance_ = new UserToBitHandshake();
   RequestResults::default_instance_ = new RequestResults();
-  RunQuery::default_instance_ = new RunQuery();
+  GetQueryPlanFragments::default_instance_ = new GetQueryPlanFragments();
+  QueryPlanFragments::default_instance_ = new QueryPlanFragments();
   BitToUserHandshake::default_instance_ = new BitToUserHandshake();
+  LikeFilter::default_instance_ = new LikeFilter();
+  GetCatalogsReq::default_instance_ = new GetCatalogsReq();
+  CatalogMetadata::default_instance_ = new CatalogMetadata();
+  GetCatalogsResp::default_instance_ = new GetCatalogsResp();
+  GetSchemasReq::default_instance_ = new GetSchemasReq();
+  SchemaMetadata::default_instance_ = new SchemaMetadata();
+  GetSchemasResp::default_instance_ = new GetSchemasResp();
+  GetTablesReq::default_instance_ = new GetTablesReq();
+  TableMetadata::default_instance_ = new TableMetadata();
+  GetTablesResp::default_instance_ = new GetTablesResp();
+  GetColumnsReq::default_instance_ = new GetColumnsReq();
+  ColumnMetadata::default_instance_ = new ColumnMetadata();
+  GetColumnsResp::default_instance_ = new GetColumnsResp();
+  CreatePreparedStatementReq::default_instance_ = new CreatePreparedStatementReq();
+  ResultColumnMetadata::default_instance_ = new ResultColumnMetadata();
+  PreparedStatementHandle::default_instance_ = new PreparedStatementHandle();
+  PreparedStatement::default_instance_ = new PreparedStatement();
+  CreatePreparedStatementResp::default_instance_ = new CreatePreparedStatementResp();
+  RunQuery::default_instance_ = new RunQuery();
   Property::default_instance_->InitAsDefaultInstance();
   UserProperties::default_instance_->InitAsDefaultInstance();
+  RpcEndpointInfos::default_instance_->InitAsDefaultInstance();
   UserToBitHandshake::default_instance_->InitAsDefaultInstance();
   RequestResults::default_instance_->InitAsDefaultInstance();
-  RunQuery::default_instance_->InitAsDefaultInstance();
+  GetQueryPlanFragments::default_instance_->InitAsDefaultInstance();
+  QueryPlanFragments::default_instance_->InitAsDefaultInstance();
   BitToUserHandshake::default_instance_->InitAsDefaultInstance();
+  LikeFilter::default_instance_->InitAsDefaultInstance();
+  GetCatalogsReq::default_instance_->InitAsDefaultInstance();
+  CatalogMetadata::default_instance_->InitAsDefaultInstance();
+  GetCatalogsResp::default_instance_->InitAsDefaultInstance();
+  GetSchemasReq::default_instance_->InitAsDefaultInstance();
+  SchemaMetadata::default_instance_->InitAsDefaultInstance();
+  GetSchemasResp::default_instance_->InitAsDefaultInstance();
+  GetTablesReq::default_instance_->InitAsDefaultInstance();
+  TableMetadata::default_instance_->InitAsDefaultInstance();
+  GetTablesResp::default_instance_->InitAsDefaultInstance();
+  GetColumnsReq::default_instance_->InitAsDefaultInstance();
+  ColumnMetadata::default_instance_->InitAsDefaultInstance();
+  GetColumnsResp::default_instance_->InitAsDefaultInstance();
+  CreatePreparedStatementReq::default_instance_->InitAsDefaultInstance();
+  ResultColumnMetadata::default_instance_->InitAsDefaultInstance();
+  PreparedStatementHandle::default_instance_->InitAsDefaultInstance();
+  PreparedStatement::default_instance_->InitAsDefaultInstance();
+  CreatePreparedStatementResp::default_instance_->InitAsDefaultInstance();
+  RunQuery::default_instance_->InitAsDefaultInstance();
   ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_User_2eproto);
 }
 
@@ -281,6 +971,18 @@ bool RpcType_IsValid(int value) {
     case 9:
     case 10:
     case 11:
+    case 12:
+    case 13:
+    case 14:
+    case 15:
+    case 16:
+    case 17:
+    case 18:
+    case 19:
+    case 20:
+    case 21:
+    case 22:
+    case 23:
       return true;
     default:
       return false;
@@ -316,6 +1018,54 @@ bool HandshakeStatus_IsValid(int value) {
   }
 }
 
+const ::google::protobuf::EnumDescriptor* RequestStatus_descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return RequestStatus_descriptor_;
+}
+bool RequestStatus_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+      return true;
+    default:
+      return false;
+  }
+}
+
+const ::google::protobuf::EnumDescriptor* ColumnSearchability_descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ColumnSearchability_descriptor_;
+}
+bool ColumnSearchability_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+      return true;
+    default:
+      return false;
+  }
+}
+
+const ::google::protobuf::EnumDescriptor* ColumnUpdatability_descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ColumnUpdatability_descriptor_;
+}
+bool ColumnUpdatability_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+    case 2:
+      return true;
+    default:
+      return false;
+  }
+}
+
 
 // ===================================================================
 
@@ -809,6 +1559,465 @@ void UserProperties::Swap(UserProperties* other) {
 // ===================================================================
 
 #ifndef _MSC_VER
+const int RpcEndpointInfos::kNameFieldNumber;
+const int RpcEndpointInfos::kVersionFieldNumber;
+const int RpcEndpointInfos::kMajorVersionFieldNumber;
+const int RpcEndpointInfos::kMinorVersionFieldNumber;
+const int RpcEndpointInfos::kPatchVersionFieldNumber;
+const int RpcEndpointInfos::kApplicationFieldNumber;
+#endif  // !_MSC_VER
+
+RpcEndpointInfos::RpcEndpointInfos()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void RpcEndpointInfos::InitAsDefaultInstance() {
+}
+
+RpcEndpointInfos::RpcEndpointInfos(const RpcEndpointInfos& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void RpcEndpointInfos::SharedCtor() {
+  _cached_size_ = 0;
+  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  version_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  majorversion_ = 0u;
+  minorversion_ = 0u;
+  patchversion_ = 0u;
+  application_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+RpcEndpointInfos::~RpcEndpointInfos() {
+  SharedDtor();
+}
+
+void RpcEndpointInfos::SharedDtor() {
+  if (name_ != &::google::protobuf::internal::kEmptyString) {
+    delete name_;
+  }
+  if (version_ != &::google::protobuf::internal::kEmptyString) {
+    delete version_;
+  }
+  if (application_ != &::google::protobuf::internal::kEmptyString) {
+    delete application_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void RpcEndpointInfos::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* RpcEndpointInfos::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return RpcEndpointInfos_descriptor_;
+}
+
+const RpcEndpointInfos& RpcEndpointInfos::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_User_2eproto();
+  return *default_instance_;
+}
+
+RpcEndpointInfos* RpcEndpointInfos::default_instance_ = NULL;
+
+RpcEndpointInfos* RpcEndpointInfos::New() const {
+  return new RpcEndpointInfos;
+}
+
+void RpcEndpointInfos::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (has_name()) {
+      if (name_ != &::google::protobuf::internal::kEmptyString) {
+        name_->clear();
+      }
+    }
+    if (has_version()) {
+      if (version_ != &::google::protobuf::internal::kEmptyString) {
+        version_->clear();
+      }
+    }
+    majorversion_ = 0u;
+    minorversion_ = 0u;
+    patchversion_ = 0u;
+    if (has_application()) {
+      if (application_ != &::google::protobuf::internal::kEmptyString) {
+        application_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool RpcEndpointInfos::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string name = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->name().data(), this->name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(18)) goto parse_version;
+        break;
+      }
+
+      // optional string version = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_version:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_version()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->version().data(), this->version().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(24)) goto parse_majorVersion;
+        break;
+      }
+
+      // optional uint32 majorVersion = 3;
+      case 3: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_majorVersion:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &majorversion_)));
+          set_has_majorversion();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(32)) goto parse_minorVersion;
+        break;
+      }
+
+      // optional uint32 minorVersion = 4;
+      case 4: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_minorVersion:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &minorversion_)));
+          set_has_minorversion();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(40)) goto parse_patchVersion;
+        break;
+      }
+
+      // optional uint32 patchVersion = 5;
+      case 5: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_patchVersion:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &patchversion_)));
+          set_has_patchversion();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(50)) goto parse_application;
+        break;
+      }
+
+      // optional string application = 6;
+      case 6: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_application:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_application()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->application().data(), this->application().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void RpcEndpointInfos::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // optional string name = 1;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      1, this->name(), output);
+  }
+
+  // optional string version = 2;
+  if (has_version()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->version().data(), this->version().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      2, this->version(), output);
+  }
+
+  // optional uint32 majorVersion = 3;
+  if (has_majorversion()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->majorversion(), output);
+  }
+
+  // optional uint32 minorVersion = 4;
+  if (has_minorversion()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->minorversion(), output);
+  }
+
+  // optional uint32 patchVersion = 5;
+  if (has_patchversion()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->patchversion(), output);
+  }
+
+  // optional string application = 6;
+  if (has_application()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->application().data(), this->application().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      6, this->application(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* RpcEndpointInfos::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // optional string name = 1;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->name(), target);
+  }
+
+  // optional string version = 2;
+  if (has_version()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->version().data(), this->version().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        2, this->version(), target);
+  }
+
+  // optional uint32 majorVersion = 3;
+  if (has_majorversion()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->majorversion(), target);
+  }
+
+  // optional uint32 minorVersion = 4;
+  if (has_minorversion()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->minorversion(), target);
+  }
+
+  // optional uint32 patchVersion = 5;
+  if (has_patchversion()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(5, this->patchversion(), target);
+  }
+
+  // optional string application = 6;
+  if (has_application()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->application().data(), this->application().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        6, this->application(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int RpcEndpointInfos::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string name = 1;
+    if (has_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->name());
+    }
+
+    // optional string version = 2;
+    if (has_version()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->version());
+    }
+
+    // optional uint32 majorVersion = 3;
+    if (has_majorversion()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->majorversion());
+    }
+
+    // optional uint32 minorVersion = 4;
+    if (has_minorversion()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->minorversion());
+    }
+
+    // optional uint32 patchVersion = 5;
+    if (has_patchversion()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->patchversion());
+    }
+
+    // optional string application = 6;
+    if (has_application()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->application());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void RpcEndpointInfos::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const RpcEndpointInfos* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const RpcEndpointInfos*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void RpcEndpointInfos::MergeFrom(const RpcEndpointInfos& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_name()) {
+      set_name(from.name());
+    }
+    if (from.has_version()) {
+      set_version(from.version());
+    }
+    if (from.has_majorversion()) {
+      set_majorversion(from.majorversion());
+    }
+    if (from.has_minorversion()) {
+      set_minorversion(from.minorversion());
+    }
+    if (from.has_patchversion()) {
+      set_patchversion(from.patchversion());
+    }
+    if (from.has_application()) {
+      set_application(from.application());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void RpcEndpointInfos::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void RpcEndpointInfos::CopyFrom(const RpcEndpointInfos& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool RpcEndpointInfos::IsInitialized() const {
+
+  return true;
+}
+
+void RpcEndpointInfos::Swap(RpcEndpointInfos* other) {
+  if (other != this) {
+    std::swap(name_, other->name_);
+    std::swap(version_, other->version_);
+    std::swap(majorversion_, other->majorversion_);
+    std::swap(minorversion_, other->minorversion_);
+    std::swap(patchversion_, other->patchversion_);
+    std::swap(application_, other->application_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata RpcEndpointInfos::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = RpcEndpointInfos_descriptor_;
+  metadata.reflection = RpcEndpointInfos_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
 const int UserToBitHandshake::kChannelFieldNumber;
 const int UserToBitHandshake::kSupportListeningFieldNumber;
 const int UserToBitHandshake::kRpcVersionFieldNumber;
@@ -816,6 +2025,7 @@ const int UserToBitHandshake::kCredentialsFieldNumber;
 const int UserToBitHandshake::kPropertiesFieldNumber;
 const int UserToBitHandshake::kSupportComplexTypesFieldNumber;
 const int UserToBitHandshake::kSupportTimeoutFieldNumber;
+const int UserToBitHandshake::kClientInfosFieldNumber;
 #endif  // !_MSC_VER
 
 UserToBitHandshake::UserToBitHandshake()
@@ -826,6 +2036,7 @@ UserToBitHandshake::UserToBitHandshake()
 void UserToBitHandshake::InitAsDefaultInstance() {
   credentials_ = const_cast< ::exec::shared::UserCredentials*>(&::exec::shared::UserCredentials::default_instance());
   properties_ = const_cast< ::exec::user::UserProperties*>(&::exec::user::UserProperties::default_instance());
+  client_infos_ = const_cast< ::exec::user::RpcEndpointInfos*>(&::exec::user::RpcEndpointInfos::default_instance());
 }
 
 UserToBitHandshake::UserToBitHandshake(const UserToBitHandshake& from)
@@ -843,6 +2054,7 @@ void UserToBitHandshake::SharedCtor() {
   properties_ = NULL;
   support_complex_types_ = false;
   support_timeout_ = false;
+  client_infos_ = NULL;
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
@@ -854,6 +2066,7 @@ void UserToBitHandshake::SharedDtor() {
   if (this != default_instance_) {
     delete credentials_;
     delete properties_;
+    delete client_infos_;
   }
 }
 
@@ -891,6 +2104,9 @@ void UserToBitHandshake::Clear() {
     }
     support_complex_types_ = false;
     support_timeout_ = false;
+    if (has_client_infos()) {
+      if (client_infos_ != NULL) client_infos_->::exec::user::RpcEndpointInfos::Clear();
+    }
   }
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
   mutable_unknown_fields()->Clear();
@@ -1010,6 +2226,20 @@ bool UserToBitHandshake::MergePartialFromCodedStream(
         } else {
           goto handle_uninterpreted;
         }
+        if (input->ExpectTag(66)) goto parse_client_infos;
+        break;
+      }
+
+      // optional .exec.user.RpcEndpointInfos client_infos = 8;
+      case 8: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_client_infos:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_client_infos()));
+        } else {
+          goto handle_uninterpreted;
+        }
         if (input->ExpectAtEnd()) return true;
         break;
       }
@@ -1070,6 +2300,12 @@ void UserToBitHandshake::SerializeWithCachedSizes(
     ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->support_timeout(), output);
   }
 
+  // optional .exec.user.RpcEndpointInfos client_infos = 8;
+  if (has_client_infos()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      8, this->client_infos(), output);
+  }
+
   if (!unknown_fields().empty()) {
     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
         unknown_fields(), output);
@@ -1118,6 +2354,13 @@ void UserToBitHandshake::SerializeWithCachedSizes(
     target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(7, this->support_timeout(), target);
   }
 
+  // optional .exec.user.RpcEndpointInfos client_infos = 8;
+  if (has_client_infos()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        8, this->client_infos(), target);
+  }
+
   if (!unknown_fields().empty()) {
     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
         unknown_fields(), target);
@@ -1171,6 +2414,13 @@ int UserToBitHandshake::ByteSize() const {
       total_size += 1 + 1;
     }
 
+    // optional .exec.user.RpcEndpointInfos client_infos = 8;
+    if (has_client_infos()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->client_infos());
+    }
+
   }
   if (!unknown_fields().empty()) {
     total_size +=
@@ -1219,6 +2469,9 @@ void UserToBitHandshake::MergeFrom(const UserToBitHandshake& from) {
     if (from.has_support_timeout()) {
       set_support_timeout(from.support_timeout());
     }
+    if (from.has_client_infos()) {
+      mutable_client_infos()->::exec::user::RpcEndpointInfos::MergeFrom(from.client_infos());
+    }
   }
   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 }
@@ -1252,6 +2505,7 @@ void UserToBitHandshake::Swap(UserToBitHandshake* other) {
     std::swap(properties_, other->properties_);
     std::swap(support_complex_types_, other->support_complex_types_);
     std::swap(support_timeout_, other->support_timeout_);
+    std::swap(client_infos_, other->client_infos_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
     std::swap(_cached_size_, other->_cached_size_);
@@ -1523,99 +2777,95 @@ void RequestResults::Swap(RequestResults* other) {
 // ===================================================================
 
 #ifndef _MSC_VER
-const int RunQuery::kResultsModeFieldNumber;
-const int RunQuery::kTypeFieldNumber;
-const int RunQuery::kPlanFieldNumber;
+const int GetQueryPlanFragments::kQueryFieldNumber;
+const int GetQueryPlanFragments::kTypeFieldNumber;
+const int GetQueryPlanFragments::kSplitPlanFieldNumber;
 #endif  // !_MSC_VER
 
-RunQuery::RunQuery()
+GetQueryPlanFragments::GetQueryPlanFragments()
   : ::google::protobuf::Message() {
   SharedCtor();
 }
 
-void RunQuery::InitAsDefaultInstance() {
+void GetQueryPlanFragments::InitAsDefaultInstance() {
 }
 
-RunQuery::RunQuery(const RunQuery& from)
+GetQueryPlanFragments::GetQueryPlanFragments(const GetQueryPlanFragments& from)
   : ::google::protobuf::Message() {
   SharedCtor();
   MergeFrom(from);
 }
 
-void RunQuery::SharedCtor() {
+void GetQueryPlanFragments::SharedCtor() {
   _cached_size_ = 0;
-  results_mode_ = 1;
+  query_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
   type_ = 1;
-  plan_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  split_plan_ = false;
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
-RunQuery::~RunQuery() {
+GetQueryPlanFragments::~GetQueryPlanFragments() {
   SharedDtor();
 }
 
-void RunQuery::SharedDtor() {
-  if (plan_ != &::google::protobuf::internal::kEmptyString) {
-    delete plan_;
+void GetQueryPlanFragments::SharedDtor() {
+  if (query_ != &::google::protobuf::internal::kEmptyString) {
+    delete query_;
   }
   if (this != default_instance_) {
   }
 }
 
-void RunQuery::SetCachedSize(int size) const {
+void GetQueryPlanFragments::SetCachedSize(int size) const {
   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
   _cached_size_ = size;
   GOOGLE_SAFE_CONCURRENT_WRITES_END();
 }
-const ::google::protobuf::Descriptor* RunQuery::descriptor() {
+const ::google::protobuf::Descriptor* GetQueryPlanFragments::descriptor() {
   protobuf_AssignDescriptorsOnce();
-  return RunQuery_descriptor_;
+  return GetQueryPlanFragments_descriptor_;
 }
 
-const RunQuery& RunQuery::default_instance() {
+const GetQueryPlanFragments& GetQueryPlanFragments::default_instance() {
   if (default_instance_ == NULL) protobuf_AddDesc_User_2eproto();
   return *default_instance_;
 }
 
-RunQuery* RunQuery::default_instance_ = NULL;
+GetQueryPlanFragments* GetQueryPlanFragments::default_instance_ = NULL;
 
-RunQuery* RunQuery::New() const {
-  return new RunQuery;
+GetQueryPlanFragments* GetQueryPlanFragments::New() const {
+  return new GetQueryPlanFragments;
 }
 
-void RunQuery::Clear() {
+void GetQueryPlanFragments::Clear() {
   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    results_mode_ = 1;
-    type_ = 1;
-    if (has_plan()) {
-      if (plan_ != &::google::protobuf::internal::kEmptyString) {
-        plan_->clear();
+    if (has_query()) {
+      if (query_ != &::google::protobuf::internal::kEmptyString) {
+        query_->clear();
       }
     }
+    type_ = 1;
+    split_plan_ = false;
   }
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
   mutable_unknown_fields()->Clear();
 }
 
-bool RunQuery::MergePartialFromCodedStream(
+bool GetQueryPlanFragments::MergePartialFromCodedStream(
     ::google::protobuf::io::CodedInputStream* input) {
 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
   ::google::protobuf::uint32 tag;
   while ((tag = input->ReadTag()) != 0) {
     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional .exec.user.QueryResultsMode results_mode = 1;
+      // required string query = 1;
       case 1: {
         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
-          int value;
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
-                 input, &value)));
-          if (::exec::user::QueryResultsMode_IsValid(value)) {
-            set_results_mode(static_cast< ::exec::user::QueryResultsMode >(value));
-          } else {
-            mutable_unknown_fields()->AddVarint(1, value);
-          }
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_query()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->query().data(), this->query().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
         } else {
           goto handle_uninterpreted;
         }
@@ -1640,20 +2890,19 @@ bool RunQuery::MergePartialFromCodedStream(
         } else {
           goto handle_uninterpreted;
         }
-        if (input->ExpectTag(26)) goto parse_plan;
+        if (input->ExpectTag(24)) goto parse_split_plan;
         break;
       }
 
-      // optional string plan = 3;
+      // optional bool split_plan = 3 [default = false];
       case 3: {
         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
-         parse_plan:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_plan()));
-          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
-            this->plan().data(), this->plan().length(),
-            ::google::protobuf::internal::WireFormat::PARSE);
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_split_plan:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &split_plan_)));
+          set_has_split_plan();
         } else {
           goto handle_uninterpreted;
         }
@@ -1677,12 +2926,15 @@ bool RunQuery::MergePartialFromCodedStream(
 #undef DO_
 }
 
-void RunQuery::SerializeWithCachedSizes(
+void GetQueryPlanFragments::SerializeWithCachedSizes(
     ::google::protobuf::io::CodedOutputStream* output) const {
-  // optional .exec.user.QueryResultsMode results_mode = 1;
-  if (has_results_mode()) {
-    ::google::protobuf::internal::WireFormatLite::WriteEnum(
-      1, this->results_mode(), output);
+  // required string query = 1;
+  if (has_query()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->query().data(), this->query().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      1, this->query(), output);
   }
 
   // optional .exec.shared.QueryType type = 2;
@@ -1691,13 +2943,9 @@ void RunQuery::SerializeWithCachedSizes(
       2, this->type(), output);
   }
 
-  // optional string plan = 3;
-  if (has_plan()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
-      this->plan().data(), this->plan().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE);
-    ::google::protobuf::internal::WireFormatLite::WriteString(
-      3, this->plan(), output);
+  // optional bool split_plan = 3 [default = false];
+  if (has_split_plan()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->split_plan(), output);
   }
 
   if (!unknown_fields().empty()) {
@@ -1706,12 +2954,16 @@ void RunQuery::SerializeWithCachedSizes(
   }
 }
 
-::google::protobuf::uint8* RunQuery::SerializeWithCachedSizesToArray(
+::google::protobuf::uint8* GetQueryPlanFragments::SerializeWithCachedSizesToArray(
     ::google::protobuf::uint8* target) const {
-  // optional .exec.user.QueryResultsMode results_mode = 1;
-  if (has_results_mode()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
-      1, this->results_mode(), target);
+  // required string query = 1;
+  if (has_query()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->query().data(), this->query().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->query(), target);
   }
 
   // optional .exec.shared.QueryType type = 2;
@@ -1720,14 +2972,9 @@ void RunQuery::SerializeWithCachedSizes(
       2, this->type(), target);
   }
 
-  // optional string plan = 3;
-  if (has_plan()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
-      this->plan().data(), this->plan().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE);
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        3, this->plan(), target);
+  // optional bool split_plan = 3 [default = false];
+  if (has_split_plan()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->split_plan(), target);
   }
 
   if (!unknown_fields().empty()) {
@@ -1737,14 +2984,15 @@ void RunQuery::SerializeWithCachedSizes(
   return target;
 }
 
-int RunQuery::ByteSize() const {
+int GetQueryPlanFragments::ByteSize() const {
   int total_size = 0;
 
   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional .exec.user.QueryResultsMode results_mode = 1;
-    if (has_results_mode()) {
+    // required string query = 1;
+    if (has_query()) {
       total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::EnumSize(this->results_mode());
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->query());
     }
 
     // optional .exec.shared.QueryType type = 2;
@@ -1753,11 +3001,9 @@ int RunQuery::ByteSize() const {
         ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
     }
 
-    // optional string plan = 3;
-    if (has_plan()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::StringSize(
-          this->plan());
+    // optional bool split_plan = 3 [default = false];
+    if (has_split_plan()) {
+      total_size += 1 + 1;
     }
 
   }
@@ -1772,10 +3018,10 @@ int RunQuery::ByteSize() const {
   return total_size;
 }
 
-void RunQuery::MergeFrom(const ::google::protobuf::Message& from) {
+void GetQueryPlanFragments::MergeFrom(const ::google::protobuf::Message& from) {
   GOOGLE_CHECK_NE(&from, this);
-  const RunQuery* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const RunQuery*>(
+  const GetQueryPlanFragments* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetQueryPlanFragments*>(
       &from);
   if (source == NULL) {
     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
@@ -1784,55 +3030,401 @@ void RunQuery::MergeFrom(const ::google::protobuf::Message& from) {
   }
 }
 
-void RunQuery::MergeFrom(const RunQuery& from) {
+void GetQueryPlanFragments::MergeFrom(const GetQueryPlanFragments& from) {
   GOOGLE_CHECK_NE(&from, this);
   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_results_mode()) {
-      set_results_mode(from.results_mode());
+    if (from.has_query()) {
+      set_query(from.query());
     }
     if (from.has_type()) {
       set_type(from.type());
     }
-    if (from.has_plan()) {
-      set_plan(from.plan());
+    if (from.has_split_plan()) {
+      set_split_plan(from.split_plan());
     }
   }
   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 }
 
-void RunQuery::CopyFrom(const ::google::protobuf::Message& from) {
+void GetQueryPlanFragments::CopyFrom(const ::google::protobuf::Message& from) {
   if (&from == this) return;
   Clear();
   MergeFrom(from);
 }
 
-void RunQuery::CopyFrom(const RunQuery& from) {
+void GetQueryPlanFragments::CopyFrom(const GetQueryPlanFragments& from) {
   if (&from == this) return;
   Clear();
   MergeFrom(from);
 }
 
-bool RunQuery::IsInitialized() const {
+bool GetQueryPlanFragments::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
 
   return true;
 }
 
-void RunQuery::Swap(RunQuery* other) {
+void GetQueryPlanFragments::Swap(GetQueryPlanFragments* other) {
   if (other != this) {
-    std::swap(results_mode_, other->results_mode_);
+    std::swap(query_, other->query_);
     std::swap(type_, other->type_);
-    std::swap(plan_, other->plan_);
+    std::swap(split_plan_, other->split_plan_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
     std::swap(_cached_size_, other->_cached_size_);
   }
 }
 
-::google::protobuf::Metadata RunQuery::GetMetadata() const {
+::google::protobuf::Metadata GetQueryPlanFragments::GetMetadata() const {
   protobuf_AssignDescriptorsOnce();
   ::google::protobuf::Metadata metadata;
-  metadata.descriptor = RunQuery_descriptor_;
-  metadata.reflection = RunQuery_reflection_;
+  metadata.descriptor = GetQueryPlanFragments_descriptor_;
+  metadata.reflection = GetQueryPlanFragments_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int QueryPlanFragments::kStatusFieldNumber;
+const int QueryPlanFragments::kQueryIdFieldNumber;
+const int QueryPlanFragments::kFragmentsFieldNumber;
+const int QueryPlanFragments::kErrorFieldNumber;
+#endif  // !_MSC_VER
+
+QueryPlanFragments::QueryPlanFragments()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void QueryPlanFragments::InitAsDefaultInstance() {
+  query_id_ = const_cast< ::exec::shared::QueryId*>(&::exec::shared::QueryId::default_instance());
+  error_ = const_cast< ::exec::shared::DrillPBError*>(&::exec::shared::DrillPBError::default_instance());
+}
+
+QueryPlanFragments::QueryPlanFragments(const QueryPlanFragments& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void QueryPlanFragments::SharedCtor() {
+  _cached_size_ = 0;
+  status_ = 0;
+  query_id_ = NULL;
+  error_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+QueryPlanFragments::~QueryPlanFragments() {
+  SharedDtor();
+}
+
+void QueryPlanFragments::SharedDtor() {
+  if (this != default_instance_) {
+    delete query_id_;
+    delete error_;
+  }
+}
+
+void QueryPlanFragments::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* QueryPlanFragments::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return QueryPlanFragments_descriptor_;
+}
+
+const QueryPlanFragments& QueryPlanFragments::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_User_2eproto();
+  return *default_instance_;
+}
+
+QueryPlanFragments* QueryPlanFragments::default_instance_ = NULL;
+
+QueryPlanFragments* QueryPlanFragments::New() const {
+  return new QueryPlanFragments;
+}
+
+void QueryPlanFragments::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    status_ = 0;
+    if (has_query_id()) {
+      if (query_id_ != NULL) query_id_->::exec::shared::QueryId::Clear();
+    }
+    if (has_error()) {
+      if (error_ != NULL) error_->::exec::shared::DrillPBError::Clear();
+    }
+  }
+  fragments_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool QueryPlanFragments::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .exec.shared.QueryResult.QueryState status = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::exec::shared::QueryResult_QueryState_IsValid(value)) {
+            set_status(static_cast< ::exec::shared::QueryResult_QueryState >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(1, value);
+          }
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(18)) goto parse_query_id;
+        break;
+      }
+
+      // optional .exec.shared.QueryId query_id = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_query_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_query_id()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(26)) goto parse_fragments;
+        break;
+      }
+
+      // repeated .exec.bit.control.PlanFragment fragments = 3;
+      case 3: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_fragments:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_fragments()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(26)) goto parse_fragments;
+        if (input->ExpectTag(34)) goto parse_error;
+        break;
+      }
+
+      // optional .exec.shared.DrillPBError error = 4;
+      case 4: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_error:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_error()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void QueryPlanFragments::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // required .exec.shared.QueryResult.QueryState status = 1;
+  if (has_status()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      1, this->status(), output);
+  }
+
+  // optional .exec.shared.QueryId query_id = 2;
+  if (has_query_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->query_id(), output);
+  }
+
+  // repeated .exec.bit.control.PlanFragment fragments = 3;
+  for (int i = 0; i < this->fragments_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->fragments(i), output);
+  }
+
+  // optional .exec.shared.DrillPBError error = 4;
+  if (has_error()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->error(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* QueryPlanFragments::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // required .exec.shared.QueryResult.QueryState status = 1;
+  if (has_status()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      1, this->status(), target);
+  }
+
+  // optional .exec.shared.QueryId query_id = 2;
+  if (has_query_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->query_id(), target);
+  }
+
+  // repeated .exec.bit.control.PlanFragment fragments = 3;
+  for (int i = 0; i < this->fragments_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->fragments(i), target);
+  }
+
+  // optional .exec.shared.DrillPBError error = 4;
+  if (has_error()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->error(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int QueryPlanFragments::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .exec.shared.QueryResult.QueryState status = 1;
+    if (has_status()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->status());
+    }
+
+    // optional .exec.shared.QueryId query_id = 2;
+    if (has_query_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->query_id());
+    }
+
+    // optional .exec.shared.DrillPBError error = 4;
+    if (has_error()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->error());
+    }
+
+  }
+  // repeated .exec.bit.control.PlanFragment fragments = 3;
+  total_size += 1 * this->fragments_size();
+  for (int i = 0; i < this->fragments_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->fragments(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void QueryPlanFragments::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const QueryPlanFragments* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const QueryPlanFragments*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void QueryPlanFragments::MergeFrom(const QueryPlanFragments& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  fragments_.MergeFrom(from.fragments_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_status()) {
+      set_status(from.status());
+    }
+    if (from.has_query_id()) {
+      mutable_query_id()->::exec::shared::QueryId::MergeFrom(from.query_id());
+    }
+    if (from.has_error()) {
+      mutable_error()->::exec::shared::DrillPBError::MergeFrom(from.error());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void QueryPlanFragments::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void QueryPlanFragments::CopyFrom(const QueryPlanFragments& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool QueryPlanFragments::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  return true;
+}
+
+void QueryPlanFragments::Swap(QueryPlanFragments* other) {
+  if (other != this) {
+    std::swap(status_, other->status_);
+    std::swap(query_id_, other->query_id_);
+    fragments_.Swap(&other->fragments_);
+    std::swap(error_, other->error_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata QueryPlanFragments::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = QueryPlanFragments_descriptor_;
+  metadata.reflection = QueryPlanFragments_reflection_;
   return metadata;
 }
 
@@ -1844,6 +3436,7 @@ const int BitToUserHandshake::kRpcVersionFieldNumber;
 const int BitToUserHandshake::kStatusFieldNumber;
 const int BitToUserHandshake::kErrorIdFieldNumber;
 const int BitToUserHandshake::kErrorMessageFieldNumber;
+const int BitToUserHandshake::kServerInfosFieldNumber;
 #endif  // !_MSC_VER
 
 BitToUserHandshake::BitToUserHandshake()
@@ -1852,6 +3445,7 @@ BitToUserHandshake::BitToUserHandshake()
 }
 
 void BitToUserHandshake::InitAsDefaultInstance() {
+  server_infos_ = const_cast< ::exec::user::RpcEndpointInfos*>(&::exec::user::RpcEndpointInfos::default_instance());
 }
 
 BitToUserHandshake::BitToUserHandshake(const BitToUserHandshake& from)
@@ -1866,6 +3460,7 @@ void BitToUserHandshake::SharedCtor() {
   status_ = 1;
   errorid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
   errormessage_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  server_infos_ = NULL;
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
@@ -1881,6 +3476,7 @@ void BitToUserHandshake::SharedDtor() {
     delete errormessage_;
   }
   if (this != default_instance_) {
+    delete server_infos_;
   }
 }
 
@@ -1919,6 +3515,9 @@ void BitToUserHandshake::Clear() {
         errormessage_->clear();
       }
     }
+    if (has_server_infos()) {
+      if (server_infos_ != NULL) server_infos_->::exec::user::RpcEndpointInfos::Clear();
+    }
   }
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
   mutable_unknown_fields()->Clear();
@@ -1996,6 +3595,20 @@ bool BitToUserHandshake::MergePartialFromCodedStream(
         } else {
           goto handle_uninterpreted;
         }
+        if (input->ExpectTag(50)) goto parse_server_infos;
+        break;
+      }
+
+      // optional .exec.user.RpcEndpointInfos server_infos = 6;
+      case 6: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_server_infos:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_server_infos()));
+        } else {
+          goto handle_uninterpreted;
+        }
         if (input->ExpectAtEnd()) return true;
         break;
       }
@@ -2047,6 +3660,12 @@ void BitToUserHandshake::SerializeWithCachedSizes(
       5, this->errormessage(), output);
   }
 
+  // optional .exec.user.RpcEndpointInfos server_infos = 6;
+  if (has_server_infos()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      6, this->server_infos(), output);
+  }
+
   if (!unknown_fields().empty()) {
     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
         unknown_fields(), output);
@@ -2086,6 +3705,13 @@ void BitToUserHandshake::SerializeWithCachedSizes(
         5, this->errormessage(), target);
   }
 
+  // optional .exec.user.RpcEndpointInfos server_infos = 6;
+  if (has_server_infos()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        6, this->server_infos(), target);
+  }
+
   if (!unknown_fields().empty()) {
     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
         unknown_fields(), target);
@@ -2124,6 +3750,13 @@ int BitToUserHandshake::ByteSize() const {
           this->errormessage());
     }
 
+    // optional .exec.user.RpcEndpointInfos server_infos = 6;
+    if (has_server_infos()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->server_infos());
+    }
+
   }
   if (!unknown_fields().empty()) {
     total_size +=
@@ -2163,6 +3796,9 @@ void BitToUserHandshake::MergeFrom(const BitToUserHandshake& from) {
     if (from.has_errormessage()) {
       set_errormessage(from.errormessage());
     }
+    if (from.has_server_infos()) {
+      mutable_server_infos()->::exec::user::RpcEndpointInfos::MergeFrom(from.server_infos());
+    }
   }
   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 }
@@ -2190,6 +3826,7 @@ void BitToUserHandshake::Swap(BitToUserHandshake* other) {
     std::swap(status_, other->status_);
     std::swap(errorid_, other->errorid_);
     std::swap(errormessage_, other->errormessage_);
+    std::swap(server_infos_, other->server_infos_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
     std::swap(_cached_size_, other->_cached_size_);
@@ -2205,6 +3842,7277 @@ void BitToUserHandshake::Swap(BitToUserHandshake* other) {
 }
 
 
+// ===================================================================
+
+#ifndef _MSC_VER
+const int LikeFilter::kPatternFieldNumber;
+const int LikeFilter::kEscapeFieldNumber;
+#endif  // !_MSC_VER
+
+LikeFilter::LikeFilter()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void LikeFilter::InitAsDefaultInstance() {
+}
+
+LikeFilter::LikeFilter(const LikeFilter& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void LikeFilter::SharedCtor() {
+  _cached_size_ = 0;
+  pattern_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  escape_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+LikeFilter::~LikeFilter() {
+  SharedDtor();
+}
+
+void LikeFilter::SharedDtor() {
+  if (pattern_ != &::google::protobuf::internal::kEmptyString) {
+    delete pattern_;
+  }
+  if (escape_ != &::google::protobuf::internal::kEmptyString) {
+    delete escape_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void LikeFilter::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* LikeFilter::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return LikeFilter_descriptor_;
+}
+
+const LikeFilter& LikeFilter::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_User_2eproto();
+  return *default_instance_;
+}
+
+LikeFilter* LikeFilter::default_instance_ = NULL;
+
+LikeFilter* LikeFilter::New() const {
+  return new LikeFilter;
+}
+
+void LikeFilter::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (has_pattern()) {
+      if (pattern_ != &::google::protobuf::internal::kEmptyString) {
+        pattern_->clear();
+      }
+    }
+    if (has_escape()) {
+      if (escape_ != &::google::protobuf::internal::kEmptyString) {
+        escape_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool LikeFilter::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string pattern = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_pattern()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->pattern().data(), this->pattern().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(18)) goto parse_escape;
+        break;
+      }
+
+      // optional string escape = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_escape:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_escape()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->escape().data(), this->escape().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void LikeFilter::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // optional string pattern = 1;
+  if (has_pattern()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->pattern().data(), this->pattern().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      1, this->pattern(), output);
+  }
+
+  // optional string escape = 2;
+  if (has_escape()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->escape().data(), this->escape().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      2, this->escape(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* LikeFilter::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // optional string pattern = 1;
+  if (has_pattern()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->pattern().data(), this->pattern().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->pattern(), target);
+  }
+
+  // optional string escape = 2;
+  if (has_escape()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->escape().data(), this->escape().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        2, this->escape(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int LikeFilter::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string pattern = 1;
+    if (has_pattern()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->pattern());
+    }
+
+    // optional string escape = 2;
+    if (has_escape()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->escape());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void LikeFilter::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const LikeFilter* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const LikeFilter*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void LikeFilter::MergeFrom(const LikeFilter& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_pattern()) {
+      set_pattern(from.pattern());
+    }
+    if (from.has_escape()) {
+      set_escape(from.escape());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void LikeFilter::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void LikeFilter::CopyFrom(const LikeFilter& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool LikeFilter::IsInitialized() const {
+
+  return true;
+}
+
+void LikeFilter::Swap(LikeFilter* other) {
+  if (other != this) {
+    std::swap(pattern_, other->pattern_);
+    std::swap(escape_, other->escape_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata LikeFilter::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = LikeFilter_descriptor_;
+  metadata.reflection = LikeFilter_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetCatalogsReq::kCatalogNameFilterFieldNumber;
+#endif  // !_MSC_VER
+
+GetCatalogsReq::GetCatalogsReq()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void GetCatalogsReq::InitAsDefaultInstance() {
+  catalog_name_filter_ = const_cast< ::exec::user::LikeFilter*>(&::exec::user::LikeFilter::default_instance());
+}
+
+GetCatalogsReq::GetCatalogsReq(const GetCatalogsReq& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void GetCatalogsReq::SharedCtor() {
+  _cached_size_ = 0;
+  catalog_name_filter_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetCatalogsReq::~GetCatalogsReq() {
+  SharedDtor();
+}
+
+void GetCatalogsReq::SharedDtor() {
+  if (this != default_instance_) {
+    delete catalog_name_filter_;
+  }
+}
+
+void GetCatalogsReq::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetCatalogsReq::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetCatalogsReq_descriptor_;
+}
+
+const GetCatalogsReq& GetCatalogsReq::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_User_2eproto();
+  return *default_instance_;
+}
+
+GetCatalogsReq* GetCatalogsReq::default_instance_ = NULL;
+
+GetCatalogsReq* GetCatalogsReq::New() const {
+  return new GetCatalogsReq;
+}
+
+void GetCatalogsReq::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (has_catalog_name_filter()) {
+      if (catalog_name_filter_ != NULL) catalog_name_filter_->::exec::user::LikeFilter::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetCatalogsReq::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .exec.user.LikeFilter catalog_name_filter = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_catalog_name_filter()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void GetCatalogsReq::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // optional .exec.user.LikeFilter catalog_name_filter = 1;
+  if (has_catalog_name_filter()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->catalog_name_filter(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* GetCatalogsReq::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // optional .exec.user.LikeFilter catalog_name_filter = 1;
+  if (has_catalog_name_filter()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->catalog_name_filter(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int GetCatalogsReq::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .exec.user.LikeFilter catalog_name_filter = 1;
+    if (has_catalog_name_filter()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->catalog_name_filter());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetCatalogsReq::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetCatalogsReq* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetCatalogsReq*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetCatalogsReq::MergeFrom(const GetCatalogsReq& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_catalog_name_filter()) {
+      mutable_catalog_name_filter()->::exec::user::LikeFilter::MergeFrom(from.catalog_name_filter());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetCatalogsReq::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetCatalogsReq::CopyFrom(const GetCatalogsReq& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetCatalogsReq::IsInitialized() const {
+
+  return true;
+}
+
+void GetCatalogsReq::Swap(GetCatalogsReq* other) {
+  if (other != this) {
+    std::swap(catalog_name_filter_, other->catalog_name_filter_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetCatalogsReq::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetCatalogsReq_descriptor_;
+  metadata.reflection = GetCatalogsReq_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int CatalogMetadata::kCatalogNameFieldNumber;
+const int CatalogMetadata::kDescriptionFieldNumber;
+const int CatalogMetadata::kConnectFieldNumber;
+#endif  // !_MSC_VER
+
+CatalogMetadata::CatalogMetadata()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void CatalogMetadata::InitAsDefaultInstance() {
+}
+
+CatalogMetadata::CatalogMetadata(const CatalogMetadata& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void CatalogMetadata::SharedCtor() {
+  _cached_size_ = 0;
+  catalog_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  description_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  connect_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+CatalogMetadata::~CatalogMetadata() {
+  SharedDtor();
+}
+
+void CatalogMetadata::SharedDtor() {
+  if (catalog_name_ != &::google::protobuf::internal::kEmptyString) {
+    delete catalog_name_;
+  }
+  if (description_ != &::google::protobuf::internal::kEmptyString) {
+    delete description_;
+  }
+  if (connect_ != &::google::protobuf::internal::kEmptyString) {
+    delete connect_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void CatalogMetadata::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* CatalogMetadata::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return CatalogMetadata_descriptor_;
+}
+
+const CatalogMetadata& CatalogMetadata::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_User_2eproto();
+  return *default_instance_;
+}
+
+CatalogMetadata* CatalogMetadata::default_instance_ = NULL;
+
+CatalogMetadata* CatalogMetadata::New() const {
+  return new CatalogMetadata;
+}
+
+void CatalogMetadata::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (has_catalog_name()) {
+      if (catalog_name_ != &::google::protobuf::internal::kEmptyString) {
+        catalog_name_->clear();
+      }
+    }
+    if (has_description()) {
+      if (description_ != &::google::protobuf::internal::kEmptyString) {
+        description_->clear();
+      }
+    }
+    if (has_connect()) {
+      if (connect_ != &::google::protobuf::internal::kEmptyString) {
+        connect_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool CatalogMetadata::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string catalog_name = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_catalog_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->catalog_name().data(), this->catalog_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(18)) goto parse_description;
+        break;
+      }
+
+      // optional string description = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_description:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_description()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->description().data(), this->description().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(26)) goto parse_connect;
+        break;
+      }
+
+      // optional string connect = 3;
+      case 3: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_connect:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_connect()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->connect().data(), this->connect().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void CatalogMetadata::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // optional string catalog_name = 1;
+  if (has_catalog_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->catalog_name().data(), this->catalog_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      1, this->catalog_name(), output);
+  }
+
+  // optional string description = 2;
+  if (has_description()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->description().data(), this->description().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      2, this->description(), output);
+  }
+
+  // optional string connect = 3;
+  if (has_connect()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->connect().data(), this->connect().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      3, this->connect(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* CatalogMetadata::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // optional string catalog_name = 1;
+  if (has_catalog_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->catalog_name().data(), this->catalog_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->catalog_name(), target);
+  }
+
+  // optional string description = 2;
+  if (has_description()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->description().data(), this->description().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        2, this->description(), target);
+  }
+
+  // optional string connect = 3;
+  if (has_connect()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->connect().data(), this->connect().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        3, this->connect(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int CatalogMetadata::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string catalog_name = 1;
+    if (has_catalog_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->catalog_name());
+    }
+
+    // optional string description = 2;
+    if (has_description()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->description());
+    }
+
+    // optional string connect = 3;
+    if (has_connect()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->connect());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void CatalogMetadata::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const CatalogMetadata* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const CatalogMetadata*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void CatalogMetadata::MergeFrom(const CatalogMetadata& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_catalog_name()) {
+      set_catalog_name(from.catalog_name());
+    }
+    if (from.has_description()) {
+      set_description(from.description());
+    }
+    if (from.has_connect()) {
+      set_connect(from.connect());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void CatalogMetadata::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void CatalogMetadata::CopyFrom(const CatalogMetadata& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool CatalogMetadata::IsInitialized() const {
+
+  return true;
+}
+
+void CatalogMetadata::Swap(CatalogMetadata* other) {
+  if (other != this) {
+    std::swap(catalog_name_, other->catalog_name_);
+    std::swap(description_, other->description_);
+    std::swap(connect_, other->connect_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata CatalogMetadata::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = CatalogMetadata_descriptor_;
+  metadata.reflection = CatalogMetadata_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetCatalogsResp::kStatusFieldNumber;
+const int GetCatalogsResp::kCatalogsFieldNumber;
+const int GetCatalogsResp::kErrorFieldNumber;
+#endif  // !_MSC_VER
+
+GetCatalogsResp::GetCatalogsResp()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void GetCatalogsResp::InitAsDefaultInstance() {
+  error_ = const_cast< ::exec::shared::DrillPBError*>(&::exec::shared::DrillPBError::default_instance());
+}
+
+GetCatalogsResp::GetCatalogsResp(const GetCatalogsResp& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void GetCatalogsResp::SharedCtor() {
+  _cached_size_ = 0;
+  status_ = 0;
+  error_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetCatalogsResp::~GetCatalogsResp() {
+  SharedDtor();
+}
+
+void GetCatalogsResp::SharedDtor() {
+  if (this != default_instance_) {
+    delete error_;
+  }
+}
+
+void GetCatalogsResp::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetCatalogsResp::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetCatalogsResp_descriptor_;
+}
+
+const GetCatalogsResp& GetCatalogsResp::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_User_2eproto();
+  return *default_instance_;
+}
+
+GetCatalogsResp* GetCatalogsResp::default_instance_ = NULL;
+
+GetCatalogsResp* GetCatalogsResp::New() const {
+  return new GetCatalogsResp;
+}
+
+void GetCatalogsResp::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    status_ = 0;
+    if (has_error()) {
+      if (error_ != NULL) error_->::exec::shared::DrillPBError::Clear();
+    }
+  }
+  catalogs_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetCatalogsResp::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .exec.user.RequestStatus status = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::exec::user::RequestStatus_IsValid(value)) {
+            set_status(static_cast< ::exec::user::RequestStatus >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(1, value);
+          }
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(18)) goto parse_catalogs;
+        break;
+      }
+
+      // repeated .exec.user.CatalogMetadata catalogs = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_catalogs:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_catalogs()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(18)) goto parse_catalogs;
+        if (input->ExpectTag(26)) goto parse_error;
+        break;
+      }
+
+      // optional .exec.shared.DrillPBError error = 3;
+      case 3: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_error:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_error()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void GetCatalogsResp::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // optional .exec.user.RequestStatus status = 1;
+  if (has_status()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      1, this->status(), output);
+  }
+
+  // repeated .exec.user.CatalogMetadata catalogs = 2;
+  for (int i = 0; i < this->catalogs_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->catalogs(i), output);
+  }
+
+  // optional .exec.shared.DrillPBError error = 3;
+  if (has_error()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->error(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* GetCatalogsResp::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // optional .exec.user.RequestStatus status = 1;
+  if (has_status()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      1, this->status(), target);
+  }
+
+  // repeated .exec.user.CatalogMetadata catalogs = 2;
+  for (int i = 0; i < this->catalogs_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->catalogs(i), target);
+  }
+
+  // optional .exec.shared.DrillPBError error = 3;
+  if (has_error()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->error(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int GetCatalogsResp::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .exec.user.RequestStatus status = 1;
+    if (has_status()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->status());
+    }
+
+    // optional .exec.shared.DrillPBError error = 3;
+    if (has_error()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->error());
+    }
+
+  }
+  // repeated .exec.user.CatalogMetadata catalogs = 2;
+  total_size += 1 * this->catalogs_size();
+  for (int i = 0; i < this->catalogs_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->catalogs(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetCatalogsResp::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetCatalogsResp* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetCatalogsResp*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetCatalogsResp::MergeFrom(const GetCatalogsResp& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  catalogs_.MergeFrom(from.catalogs_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_status()) {
+      set_status(from.status());
+    }
+    if (from.has_error()) {
+      mutable_error()->::exec::shared::DrillPBError::MergeFrom(from.error());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetCatalogsResp::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetCatalogsResp::CopyFrom(const GetCatalogsResp& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetCatalogsResp::IsInitialized() const {
+
+  return true;
+}
+
+void GetCatalogsResp::Swap(GetCatalogsResp* other) {
+  if (other != this) {
+    std::swap(status_, other->status_);
+    catalogs_.Swap(&other->catalogs_);
+    std::swap(error_, other->error_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetCatalogsResp::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetCatalogsResp_descriptor_;
+  metadata.reflection = GetCatalogsResp_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetSchemasReq::kCatalogNameFilterFieldNumber;
+const int GetSchemasReq::kSchemaNameFilterFieldNumber;
+#endif  // !_MSC_VER
+
+GetSchemasReq::GetSchemasReq()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void GetSchemasReq::InitAsDefaultInstance() {
+  catalog_name_filter_ = const_cast< ::exec::user::LikeFilter*>(&::exec::user::LikeFilter::default_instance());
+  schema_name_filter_ = const_cast< ::exec::user::LikeFilter*>(&::exec::user::LikeFilter::default_instance());
+}
+
+GetSchemasReq::GetSchemasReq(const GetSchemasReq& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void GetSchemasReq::SharedCtor() {
+  _cached_size_ = 0;
+  catalog_name_filter_ = NULL;
+  schema_name_filter_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetSchemasReq::~GetSchemasReq() {
+  SharedDtor();
+}
+
+void GetSchemasReq::SharedDtor() {
+  if (this != default_instance_) {
+    delete catalog_name_filter_;
+    delete schema_name_filter_;
+  }
+}
+
+void GetSchemasReq::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetSchemasReq::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetSchemasReq_descriptor_;
+}
+
+const GetSchemasReq& GetSchemasReq::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_User_2eproto();
+  return *default_instance_;
+}
+
+GetSchemasReq* GetSchemasReq::default_instance_ = NULL;
+
+GetSchemasReq* GetSchemasReq::New() const {
+  return new GetSchemasReq;
+}
+
+void GetSchemasReq::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (has_catalog_name_filter()) {
+      if (catalog_name_filter_ != NULL) catalog_name_filter_->::exec::user::LikeFilter::Clear();
+    }
+    if (has_schema_name_filter()) {
+      if (schema_name_filter_ != NULL) schema_name_filter_->::exec::user::LikeFilter::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetSchemasReq::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .exec.user.LikeFilter catalog_name_filter = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_catalog_name_filter()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(18)) goto parse_schema_name_filter;
+        break;
+      }
+
+      // optional .exec.user.LikeFilter schema_name_filter = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_schema_name_filter:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_schema_name_filter()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void GetSchemasReq::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // optional .exec.user.LikeFilter catalog_name_filter = 1;
+  if (has_catalog_name_filter()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->catalog_name_filter(), output);
+  }
+
+  // optional .exec.user.LikeFilter schema_name_filter = 2;
+  if (has_schema_name_filter()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->schema_name_filter(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* GetSchemasReq::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // optional .exec.user.LikeFilter catalog_name_filter = 1;
+  if (has_catalog_name_filter()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->catalog_name_filter(), target);
+  }
+
+  // optional .exec.user.LikeFilter schema_name_filter = 2;
+  if (has_schema_name_filter()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->schema_name_filter(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int GetSchemasReq::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .exec.user.LikeFilter catalog_name_filter = 1;
+    if (has_catalog_name_filter()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->catalog_name_filter());
+    }
+
+    // optional .exec.user.LikeFilter schema_name_filter = 2;
+    if (has_schema_name_filter()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->schema_name_filter());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetSchemasReq::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetSchemasReq* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetSchemasReq*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetSchemasReq::MergeFrom(const GetSchemasReq& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_catalog_name_filter()) {
+      mutable_catalog_name_filter()->::exec::user::LikeFilter::MergeFrom(from.catalog_name_filter());
+    }
+    if (from.has_schema_name_filter()) {
+      mutable_schema_name_filter()->::exec::user::LikeFilter::MergeFrom(from.schema_name_filter());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetSchemasReq::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetSchemasReq::CopyFrom(const GetSchemasReq& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetSchemasReq::IsInitialized() const {
+
+  return true;
+}
+
+void GetSchemasReq::Swap(GetSchemasReq* other) {
+  if (other != this) {
+    std::swap(catalog_name_filter_, other->catalog_name_filter_);
+    std::swap(schema_name_filter_, other->schema_name_filter_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetSchemasReq::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetSchemasReq_descriptor_;
+  metadata.reflection = GetSchemasReq_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SchemaMetadata::kCatalogNameFieldNumber;
+const int SchemaMetadata::kSchemaNameFieldNumber;
+const int SchemaMetadata::kOwnerFieldNumber;
+const int SchemaMetadata::kTypeFieldNumber;
+const int SchemaMetadata::kMutableFieldNumber;
+#endif  // !_MSC_VER
+
+SchemaMetadata::SchemaMetadata()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void SchemaMetadata::InitAsDefaultInstance() {
+}
+
+SchemaMetadata::SchemaMetadata(const SchemaMetadata& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void SchemaMetadata::SharedCtor() {
+  _cached_size_ = 0;
+  catalog_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  schema_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  owner_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  mutable__ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SchemaMetadata::~SchemaMetadata() {
+  SharedDtor();
+}
+
+void SchemaMetadata::SharedDtor() {
+  if (catalog_name_ != &::google::protobuf::internal::kEmptyString) {
+    delete catalog_name_;
+  }
+  if (schema_name_ != &::google::protobuf::internal::kEmptyString) {
+    delete schema_name_;
+  }
+  if (owner_ != &::google::protobuf::internal::kEmptyString) {
+    delete owner_;
+  }
+  if (type_ != &::google::protobuf::internal::kEmptyString) {
+    delete type_;
+  }
+  if (mutable__ != &::google::protobuf::internal::kEmptyString) {
+    delete mutable__;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void SchemaMetadata::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SchemaMetadata::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SchemaMetadata_descriptor_;
+}
+
+const SchemaMetadata& SchemaMetadata::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_User_2eproto();
+  return *default_instance_;
+}
+
+SchemaMetadata* SchemaMetadata::default_instance_ = NULL;
+
+SchemaMetadata* SchemaMetadata::New() const {
+  return new SchemaMetadata;
+}
+
+void SchemaMetadata::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (has_catalog_name()) {
+      if (catalog_name_ != &::google::protobuf::internal::kEmptyString) {
+        catalog_name_->clear();
+      }
+    }
+    if (has_schema_name()) {
+      if (schema_name_ != &::google::protobuf::internal::kEmptyString) {
+        schema_name_->clear();
+      }
+    }
+    if (has_owner()) {
+      if (owner_ != &::google::protobuf::internal::kEmptyString) {
+        owner_->clear();
+      }
+    }
+    if (has_type()) {
+      if (type_ != &::google::protobuf::internal::kEmptyString) {
+        type_->clear();
+      }
+    }
+    if (has_mutable_()) {
+      if (mutable__ != &::google::protobuf::internal::kEmptyString) {
+        mutable__->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SchemaMetadata::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string catalog_name = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_catalog_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->catalog_name().data(), this->catalog_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(18)) goto parse_schema_name;
+        break;
+      }
+
+      // optional string schema_name = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_schema_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_schema_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->schema_name().data(), this->schema_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(26)) goto parse_owner;
+        break;
+      }
+
+      // optional string owner = 3;
+      case 3: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_owner:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_owner()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->owner().data(), this->owner().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(34)) goto parse_type;
+        break;
+      }
+
+      // optional string type = 4;
+      case 4: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_type:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_type()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->type().data(), this->type().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(42)) goto parse_mutable;
+        break;
+      }
+
+      // optional string mutable = 5;
+      case 5: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_mutable:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_mutable_()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->mutable_().data(), this->mutable_().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void SchemaMetadata::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // optional string catalog_name = 1;
+  if (has_catalog_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->catalog_name().data(), this->catalog_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      1, this->catalog_name(), output);
+  }
+
+  // optional string schema_name = 2;
+  if (has_schema_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->schema_name().data(), this->schema_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      2, this->schema_name(), output);
+  }
+
+  // optional string owner = 3;
+  if (has_owner()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->owner().data(), this->owner().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      3, this->owner(), output);
+  }
+
+  // optional string type = 4;
+  if (has_type()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->type().data(), this->type().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      4, this->type(), output);
+  }
+
+  // optional string mutable = 5;
+  if (has_mutable_()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->mutable_().data(), this->mutable_().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      5, this->mutable_(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* SchemaMetadata::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // optional string catalog_name = 1;
+  if (has_catalog_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->catalog_name().data(), this->catalog_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->catalog_name(), target);
+  }
+
+  // optional string schema_name = 2;
+  if (has_schema_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->schema_name().data(), this->schema_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        2, this->schema_name(), target);
+  }
+
+  // optional string owner = 3;
+  if (has_owner()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->owner().data(), this->owner().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        3, this->owner(), target);
+  }
+
+  // optional string type = 4;
+  if (has_type()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->type().data(), this->type().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        4, this->type(), target);
+  }
+
+  // optional string mutable = 5;
+  if (has_mutable_()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->mutable_().data(), this->mutable_().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        5, this->mutable_(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int SchemaMetadata::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string catalog_name = 1;
+    if (has_catalog_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->catalog_name());
+    }
+
+    // optional string schema_name = 2;
+    if (has_schema_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->schema_name());
+    }
+
+    // optional string owner = 3;
+    if (has_owner()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->owner());
+    }
+
+    // optional string type = 4;
+    if (has_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->type());
+    }
+
+    // optional string mutable = 5;
+    if (has_mutable_()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->mutable_());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SchemaMetadata::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SchemaMetadata* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SchemaMetadata*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SchemaMetadata::MergeFrom(const SchemaMetadata& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_catalog_name()) {
+      set_catalog_name(from.catalog_name());
+    }
+    if (from.has_schema_name()) {
+      set_schema_name(from.schema_name());
+    }
+    if (from.has_owner()) {
+      set_owner(from.owner());
+    }
+    if (from.has_type()) {
+      set_type(from.type());
+    }
+    if (from.has_mutable_()) {
+      set_mutable_(from.mutable_());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SchemaMetadata::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SchemaMetadata::CopyFrom(const SchemaMetadata& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SchemaMetadata::IsInitialized() const {
+
+  return true;
+}
+
+void SchemaMetadata::Swap(SchemaMetadata* other) {
+  if (other != this) {
+    std::swap(catalog_name_, other->catalog_name_);
+    std::swap(schema_name_, other->schema_name_);
+    std::swap(owner_, other->owner_);
+    std::swap(type_, other->type_);
+    std::swap(mutable__, other->mutable__);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SchemaMetadata::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SchemaMetadata_descriptor_;
+  metadata.reflection = SchemaMetadata_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetSchemasResp::kStatusFieldNumber;
+const int GetSchemasResp::kSchemasFieldNumber;
+const int GetSchemasResp::kErrorFieldNumber;
+#endif  // !_MSC_VER
+
+GetSchemasResp::GetSchemasResp()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void GetSchemasResp::InitAsDefaultInstance() {
+  error_ = const_cast< ::exec::shared::DrillPBError*>(&::exec::shared::DrillPBError::default_instance());
+}
+
+GetSchemasResp::GetSchemasResp(const GetSchemasResp& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void GetSchemasResp::SharedCtor() {
+  _cached_size_ = 0;
+  status_ = 0;
+  error_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetSchemasResp::~GetSchemasResp() {
+  SharedDtor();
+}
+
+void GetSchemasResp::SharedDtor() {
+  if (this != default_instance_) {
+    delete error_;
+  }
+}
+
+void GetSchemasResp::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetSchemasResp::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetSchemasResp_descriptor_;
+}
+
+const GetSchemasResp& GetSchemasResp::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_User_2eproto();
+  return *default_instance_;
+}
+
+GetSchemasResp* GetSchemasResp::default_instance_ = NULL;
+
+GetSchemasResp* GetSchemasResp::New() const {
+  return new GetSchemasResp;
+}
+
+void GetSchemasResp::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    status_ = 0;
+    if (has_error()) {
+      if (error_ != NULL) error_->::exec::shared::DrillPBError::Clear();
+    }
+  }
+  schemas_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetSchemasResp::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .exec.user.RequestStatus status = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::exec::user::RequestStatus_IsValid(value)) {
+            set_status(static_cast< ::exec::user::RequestStatus >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(1, value);
+          }
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(18)) goto parse_schemas;
+        break;
+      }
+
+      // repeated .exec.user.SchemaMetadata schemas = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_schemas:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_schemas()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(18)) goto parse_schemas;
+        if (input->ExpectTag(26)) goto parse_error;
+        break;
+      }
+
+      // optional .exec.shared.DrillPBError error = 3;
+      case 3: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_error:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_error()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void GetSchemasResp::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // optional .exec.user.RequestStatus status = 1;
+  if (has_status()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      1, this->status(), output);
+  }
+
+  // repeated .exec.user.SchemaMetadata schemas = 2;
+  for (int i = 0; i < this->schemas_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->schemas(i), output);
+  }
+
+  // optional .exec.shared.DrillPBError error = 3;
+  if (has_error()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->error(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* GetSchemasResp::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // optional .exec.user.RequestStatus status = 1;
+  if (has_status()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      1, this->status(), target);
+  }
+
+  // repeated .exec.user.SchemaMetadata schemas = 2;
+  for (int i = 0; i < this->schemas_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->schemas(i), target);
+  }
+
+  // optional .exec.shared.DrillPBError error = 3;
+  if (has_error()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->error(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int GetSchemasResp::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .exec.user.RequestStatus status = 1;
+    if (has_status()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->status());
+    }
+
+    // optional .exec.shared.DrillPBError error = 3;
+    if (has_error()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->error());
+    }
+
+  }
+  // repeated .exec.user.SchemaMetadata schemas = 2;
+  total_size += 1 * this->schemas_size();
+  for (int i = 0; i < this->schemas_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->schemas(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetSchemasResp::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetSchemasResp* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetSchemasResp*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetSchemasResp::MergeFrom(const GetSchemasResp& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  schemas_.MergeFrom(from.schemas_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_status()) {
+      set_status(from.status());
+    }
+    if (from.has_error()) {
+      mutable_error()->::exec::shared::DrillPBError::MergeFrom(from.error());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetSchemasResp::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetSchemasResp::CopyFrom(const GetSchemasResp& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetSchemasResp::IsInitialized() const {
+
+  return true;
+}
+
+void GetSchemasResp::Swap(GetSchemasResp* other) {
+  if (other != this) {
+    std::swap(status_, other->status_);
+    schemas_.Swap(&other->schemas_);
+    std::swap(error_, other->error_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetSchemasResp::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetSchemasResp_descriptor_;
+  metadata.reflection = GetSchemasResp_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetTablesReq::kCatalogNameFilterFieldNumber;
+const int GetTablesReq::kSchemaNameFilterFieldNumber;
+const int GetTablesReq::kTableNameFilterFieldNumber;
+const int GetTablesReq::kTableTypeFilterFieldNumber;
+#endif  // !_MSC_VER
+
+GetTablesReq::GetTablesReq()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void GetTablesReq::InitAsDefaultInstance() {
+  catalog_name_filter_ = const_cast< ::exec::user::LikeFilter*>(&::exec::user::LikeFilter::default_instance());
+  schema_name_filter_ = const_cast< ::exec::user::LikeFilter*>(&::exec::user::LikeFilter::default_instance());
+  table_name_filter_ = const_cast< ::exec::user::LikeFilter*>(&::exec::user::LikeFilter::default_instance());
+}
+
+GetTablesReq::GetTablesReq(const GetTablesReq& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void GetTablesReq::SharedCtor() {
+  _cached_size_ = 0;
+  catalog_name_filter_ = NULL;
+  schema_name_filter_ = NULL;
+  table_name_filter_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetTablesReq::~GetTablesReq() {
+  SharedDtor();
+}
+
+void GetTablesReq::SharedDtor() {
+  if (this != default_instance_) {
+    delete catalog_name_filter_;
+    delete schema_name_filter_;
+    delete table_name_filter_;
+  }
+}
+
+void GetTablesReq::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetTablesReq::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetTablesReq_descriptor_;
+}
+
+const GetTablesReq& GetTablesReq::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_User_2eproto();
+  return *default_instance_;
+}
+
+GetTablesReq* GetTablesReq::default_instance_ = NULL;
+
+GetTablesReq* GetTablesReq::New() const {
+  return new GetTablesReq;
+}
+
+void GetTablesReq::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (has_catalog_name_filter()) {
+      if (catalog_name_filter_ != NULL) catalog_name_filter_->::exec::user::LikeFilter::Clear();
+    }
+    if (has_schema_name_filter()) {
+      if (schema_name_filter_ != NULL) schema_name_filter_->::exec::user::LikeFilter::Clear();
+    }
+    if (has_table_name_filter()) {
+      if (table_name_filter_ != NULL) table_name_filter_->::exec::user::LikeFilter::Clear();
+    }
+  }
+  table_type_filter_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetTablesReq::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .exec.user.LikeFilter catalog_name_filter = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_catalog_name_filter()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(18)) goto parse_schema_name_filter;
+        break;
+      }
+
+      // optional .exec.user.LikeFilter schema_name_filter = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_schema_name_filter:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_schema_name_filter()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(26)) goto parse_table_name_filter;
+        break;
+      }
+
+      // optional .exec.user.LikeFilter table_name_filter = 3;
+      case 3: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_table_name_filter:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_table_name_filter()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(34)) goto parse_table_type_filter;
+        break;
+      }
+
+      // repeated string table_type_filter = 4;
+      case 4: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_table_type_filter:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->add_table_type_filter()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->table_type_filter(this->table_type_filter_size() - 1).data(),
+            this->table_type_filter(this->table_type_filter_size() - 1).length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(34)) goto parse_table_type_filter;
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void GetTablesReq::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // optional .exec.user.LikeFilter catalog_name_filter = 1;
+  if (has_catalog_name_filter()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->catalog_name_filter(), output);
+  }
+
+  // optional .exec.user.LikeFilter schema_name_filter = 2;
+  if (has_schema_name_filter()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->schema_name_filter(), output);
+  }
+
+  // optional .exec.user.LikeFilter table_name_filter = 3;
+  if (has_table_name_filter()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->table_name_filter(), output);
+  }
+
+  // repeated string table_type_filter = 4;
+  for (int i = 0; i < this->table_type_filter_size(); i++) {
+  ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+    this->table_type_filter(i).data(), this->table_type_filter(i).length(),
+    ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      4, this->table_type_filter(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* GetTablesReq::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // optional .exec.user.LikeFilter catalog_name_filter = 1;
+  if (has_catalog_name_filter()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->catalog_name_filter(), target);
+  }
+
+  // optional .exec.user.LikeFilter schema_name_filter = 2;
+  if (has_schema_name_filter()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->schema_name_filter(), target);
+  }
+
+  // optional .exec.user.LikeFilter table_name_filter = 3;
+  if (has_table_name_filter()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->table_name_filter(), target);
+  }
+
+  // repeated string table_type_filter = 4;
+  for (int i = 0; i < this->table_type_filter_size(); i++) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->table_type_filter(i).data(), this->table_type_filter(i).length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteStringToArray(4, this->table_type_filter(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int GetTablesReq::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .exec.user.LikeFilter catalog_name_filter = 1;
+    if (has_catalog_name_filter()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->catalog_name_filter());
+    }
+
+    // optional .exec.user.LikeFilter schema_name_filter = 2;
+    if (has_schema_name_filter()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->schema_name_filter());
+    }
+
+    // optional .exec.user.LikeFilter table_name_filter = 3;
+    if (has_table_name_filter()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->table_name_filter());
+    }
+
+  }
+  // repeated string table_type_filter = 4;
+  total_size += 1 * this->table_type_filter_size();
+  for (int i = 0; i < this->table_type_filter_size(); i++) {
+    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
+      this->table_type_filter(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetTablesReq::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetTablesReq* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetTablesReq*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetTablesReq::MergeFrom(const GetTablesReq& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  table_type_filter_.MergeFrom(from.table_type_filter_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_catalog_name_filter()) {
+      mutable_catalog_name_filter()->::exec::user::LikeFilter::MergeFrom(from.catalog_name_filter());
+    }
+    if (from.has_schema_name_filter()) {
+      mutable_schema_name_filter()->::exec::user::LikeFilter::MergeFrom(from.schema_name_filter());
+    }
+    if (from.has_table_name_filter()) {
+      mutable_table_name_filter()->::exec::user::LikeFilter::MergeFrom(from.table_name_filter());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetTablesReq::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetTablesReq::CopyFrom(const GetTablesReq& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetTablesReq::IsInitialized() const {
+
+  return true;
+}
+
+void GetTablesReq::Swap(GetTablesReq* other) {
+  if (other != this) {
+    std::swap(catalog_name_filter_, other->catalog_name_filter_);
+    std::swap(schema_name_filter_, other->schema_name_filter_);
+    std::swap(table_name_filter_, other->table_name_filter_);
+    table_type_filter_.Swap(&other->table_type_filter_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetTablesReq::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetTablesReq_descriptor_;
+  metadata.reflection = GetTablesReq_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int TableMetadata::kCatalogNameFieldNumber;
+const int TableMetadata::kSchemaNameFieldNumber;
+const int TableMetadata::kTableNameFieldNumber;
+const int TableMetadata::kTypeFieldNumber;
+#endif  // !_MSC_VER
+
+TableMetadata::TableMetadata()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void TableMetadata::InitAsDefaultInstance() {
+}
+
+TableMetadata::TableMetadata(const TableMetadata& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void TableMetadata::SharedCtor() {
+  _cached_size_ = 0;
+  catalog_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  schema_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  table_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+TableMetadata::~TableMetadata() {
+  SharedDtor();
+}
+
+void TableMetadata::SharedDtor() {
+  if (catalog_name_ != &::google::protobuf::internal::kEmptyString) {
+    delete catalog_name_;
+  }
+  if (schema_name_ != &::google::protobuf::internal::kEmptyString) {
+    delete schema_name_;
+  }
+  if (table_name_ != &::google::protobuf::internal::kEmptyString) {
+    delete table_name_;
+  }
+  if (type_ != &::google::protobuf::internal::kEmptyString) {
+    delete type_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void TableMetadata::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* TableMetadata::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return TableMetadata_descriptor_;
+}
+
+const TableMetadata& TableMetadata::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_User_2eproto();
+  return *default_instance_;
+}
+
+TableMetadata* TableMetadata::default_instance_ = NULL;
+
+TableMetadata* TableMetadata::New() const {
+  return new TableMetadata;
+}
+
+void TableMetadata::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (has_catalog_name()) {
+      if (catalog_name_ != &::google::protobuf::internal::kEmptyString) {
+        catalog_name_->clear();
+      }
+    }
+    if (has_schema_name()) {
+      if (schema_name_ != &::google::protobuf::internal::kEmptyString) {
+        schema_name_->clear();
+      }
+    }
+    if (has_table_name()) {
+      if (table_name_ != &::google::protobuf::internal::kEmptyString) {
+        table_name_->clear();
+      }
+    }
+    if (has_type()) {
+      if (type_ != &::google::protobuf::internal::kEmptyString) {
+        type_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool TableMetadata::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string catalog_name = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_catalog_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->catalog_name().data(), this->catalog_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(18)) goto parse_schema_name;
+        break;
+      }
+
+      // optional string schema_name = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_schema_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_schema_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->schema_name().data(), this->schema_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(26)) goto parse_table_name;
+        break;
+      }
+
+      // optional string table_name = 3;
+      case 3: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_table_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_table_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->table_name().data(), this->table_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(34)) goto parse_type;
+        break;
+      }
+
+      // optional string type = 4;
+      case 4: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_type:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_type()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->type().data(), this->type().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void TableMetadata::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // optional string catalog_name = 1;
+  if (has_catalog_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->catalog_name().data(), this->catalog_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      1, this->catalog_name(), output);
+  }
+
+  // optional string schema_name = 2;
+  if (has_schema_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->schema_name().data(), this->schema_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      2, this->schema_name(), output);
+  }
+
+  // optional string table_name = 3;
+  if (has_table_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->table_name().data(), this->table_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      3, this->table_name(), output);
+  }
+
+  // optional string type = 4;
+  if (has_type()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->type().data(), this->type().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      4, this->type(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* TableMetadata::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // optional string catalog_name = 1;
+  if (has_catalog_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->catalog_name().data(), this->catalog_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->catalog_name(), target);
+  }
+
+  // optional string schema_name = 2;
+  if (has_schema_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->schema_name().data(), this->schema_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        2, this->schema_name(), target);
+  }
+
+  // optional string table_name = 3;
+  if (has_table_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->table_name().data(), this->table_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        3, this->table_name(), target);
+  }
+
+  // optional string type = 4;
+  if (has_type()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->type().data(), this->type().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        4, this->type(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int TableMetadata::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string catalog_name = 1;
+    if (has_catalog_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->catalog_name());
+    }
+
+    // optional string schema_name = 2;
+    if (has_schema_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->schema_name());
+    }
+
+    // optional string table_name = 3;
+    if (has_table_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->table_name());
+    }
+
+    // optional string type = 4;
+    if (has_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->type());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void TableMetadata::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const TableMetadata* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const TableMetadata*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void TableMetadata::MergeFrom(const TableMetadata& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_catalog_name()) {
+      set_catalog_name(from.catalog_name());
+    }
+    if (from.has_schema_name()) {
+      set_schema_name(from.schema_name());
+    }
+    if (from.has_table_name()) {
+      set_table_name(from.table_name());
+    }
+    if (from.has_type()) {
+      set_type(from.type());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void TableMetadata::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void TableMetadata::CopyFrom(const TableMetadata& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool TableMetadata::IsInitialized() const {
+
+  return true;
+}
+
+void TableMetadata::Swap(TableMetadata* other) {
+  if (other != this) {
+    std::swap(catalog_name_, other->catalog_name_);
+    std::swap(schema_name_, other->schema_name_);
+    std::swap(table_name_, other->table_name_);
+    std::swap(type_, other->type_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata TableMetadata::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = TableMetadata_descriptor_;
+  metadata.reflection = TableMetadata_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetTablesResp::kStatusFieldNumber;
+const int GetTablesResp::kTablesFieldNumber;
+const int GetTablesResp::kErrorFieldNumber;
+#endif  // !_MSC_VER
+
+GetTablesResp::GetTablesResp()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void GetTablesResp::InitAsDefaultInstance() {
+  error_ = const_cast< ::exec::shared::DrillPBError*>(&::exec::shared::DrillPBError::default_instance());
+}
+
+GetTablesResp::GetTablesResp(const GetTablesResp& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void GetTablesResp::SharedCtor() {
+  _cached_size_ = 0;
+  status_ = 0;
+  error_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetTablesResp::~GetTablesResp() {
+  SharedDtor();
+}
+
+void GetTablesResp::SharedDtor() {
+  if (this != default_instance_) {
+    delete error_;
+  }
+}
+
+void GetTablesResp::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetTablesResp::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetTablesResp_descriptor_;
+}
+
+const GetTablesResp& GetTablesResp::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_User_2eproto();
+  return *default_instance_;
+}
+
+GetTablesResp* GetTablesResp::default_instance_ = NULL;
+
+GetTablesResp* GetTablesResp::New() const {
+  return new GetTablesResp;
+}
+
+void GetTablesResp::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    status_ = 0;
+    if (has_error()) {
+      if (error_ != NULL) error_->::exec::shared::DrillPBError::Clear();
+    }
+  }
+  tables_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetTablesResp::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .exec.user.RequestStatus status = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::exec::user::RequestStatus_IsValid(value)) {
+            set_status(static_cast< ::exec::user::RequestStatus >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(1, value);
+          }
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(18)) goto parse_tables;
+        break;
+      }
+
+      // repeated .exec.user.TableMetadata tables = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_tables:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_tables()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(18)) goto parse_tables;
+        if (input->ExpectTag(26)) goto parse_error;
+        break;
+      }
+
+      // optional .exec.shared.DrillPBError error = 3;
+      case 3: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_error:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_error()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void GetTablesResp::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // optional .exec.user.RequestStatus status = 1;
+  if (has_status()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      1, this->status(), output);
+  }
+
+  // repeated .exec.user.TableMetadata tables = 2;
+  for (int i = 0; i < this->tables_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->tables(i), output);
+  }
+
+  // optional .exec.shared.DrillPBError error = 3;
+  if (has_error()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->error(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* GetTablesResp::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // optional .exec.user.RequestStatus status = 1;
+  if (has_status()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      1, this->status(), target);
+  }
+
+  // repeated .exec.user.TableMetadata tables = 2;
+  for (int i = 0; i < this->tables_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->tables(i), target);
+  }
+
+  // optional .exec.shared.DrillPBError error = 3;
+  if (has_error()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->error(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int GetTablesResp::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .exec.user.RequestStatus status = 1;
+    if (has_status()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->status());
+    }
+
+    // optional .exec.shared.DrillPBError error = 3;
+    if (has_error()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->error());
+    }
+
+  }
+  // repeated .exec.user.TableMetadata tables = 2;
+  total_size += 1 * this->tables_size();
+  for (int i = 0; i < this->tables_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->tables(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetTablesResp::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetTablesResp* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetTablesResp*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetTablesResp::MergeFrom(const GetTablesResp& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  tables_.MergeFrom(from.tables_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_status()) {
+      set_status(from.status());
+    }
+    if (from.has_error()) {
+      mutable_error()->::exec::shared::DrillPBError::MergeFrom(from.error());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetTablesResp::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetTablesResp::CopyFrom(const GetTablesResp& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetTablesResp::IsInitialized() const {
+
+  return true;
+}
+
+void GetTablesResp::Swap(GetTablesResp* other) {
+  if (other != this) {
+    std::swap(status_, other->status_);
+    tables_.Swap(&other->tables_);
+    std::swap(error_, other->error_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetTablesResp::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetTablesResp_descriptor_;
+  metadata.reflection = GetTablesResp_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetColumnsReq::kCatalogNameFilterFieldNumber;
+const int GetColumnsReq::kSchemaNameFilterFieldNumber;
+const int GetColumnsReq::kTableNameFilterFieldNumber;
+const int GetColumnsReq::kColumnNameFilterFieldNumber;
+#endif  // !_MSC_VER
+
+GetColumnsReq::GetColumnsReq()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void GetColumnsReq::InitAsDefaultInstance() {
+  catalog_name_filter_ = const_cast< ::exec::user::LikeFilter*>(&::exec::user::LikeFilter::default_instance());
+  schema_name_filter_ = const_cast< ::exec::user::LikeFilter*>(&::exec::user::LikeFilter::default_instance());
+  table_name_filter_ = const_cast< ::exec::user::LikeFilter*>(&::exec::user::LikeFilter::default_instance());
+  column_name_filter_ = const_cast< ::exec::user::LikeFilter*>(&::exec::user::LikeFilter::default_instance());
+}
+
+GetColumnsReq::GetColumnsReq(const GetColumnsReq& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void GetColumnsReq::SharedCtor() {
+  _cached_size_ = 0;
+  catalog_name_filter_ = NULL;
+  schema_name_filter_ = NULL;
+  table_name_filter_ = NULL;
+  column_name_filter_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetColumnsReq::~GetColumnsReq() {
+  SharedDtor();
+}
+
+void GetColumnsReq::SharedDtor() {
+  if (this != default_instance_) {
+    delete catalog_name_filter_;
+    delete schema_name_filter_;
+    delete table_name_filter_;
+    delete column_name_filter_;
+  }
+}
+
+void GetColumnsReq::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetColumnsReq::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetColumnsReq_descriptor_;
+}
+
+const GetColumnsReq& GetColumnsReq::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_User_2eproto();
+  return *default_instance_;
+}
+
+GetColumnsReq* GetColumnsReq::default_instance_ = NULL;
+
+GetColumnsReq* GetColumnsReq::New() const {
+  return new GetColumnsReq;
+}
+
+void GetColumnsReq::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (has_catalog_name_filter()) {
+      if (catalog_name_filter_ != NULL) catalog_name_filter_->::exec::user::LikeFilter::Clear();
+    }
+    if (has_schema_name_filter()) {
+      if (schema_name_filter_ != NULL) schema_name_filter_->::exec::user::LikeFilter::Clear();
+    }
+    if (has_table_name_filter()) {
+      if (table_name_filter_ != NULL) table_name_filter_->::exec::user::LikeFilter::Clear();
+    }
+    if (has_column_name_filter()) {
+      if (column_name_filter_ != NULL) column_name_filter_->::exec::user::LikeFilter::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetColumnsReq::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .exec.user.LikeFilter catalog_name_filter = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_catalog_name_filter()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(18)) goto parse_schema_name_filter;
+        break;
+      }
+
+      // optional .exec.user.LikeFilter schema_name_filter = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_schema_name_filter:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_schema_name_filter()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(26)) goto parse_table_name_filter;
+        break;
+      }
+
+      // optional .exec.user.LikeFilter table_name_filter = 3;
+      case 3: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_table_name_filter:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_table_name_filter()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(34)) goto parse_column_name_filter;
+        break;
+      }
+
+      // optional .exec.user.LikeFilter column_name_filter = 4;
+      case 4: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_column_name_filter:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_column_name_filter()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void GetColumnsReq::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // optional .exec.user.LikeFilter catalog_name_filter = 1;
+  if (has_catalog_name_filter()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->catalog_name_filter(), output);
+  }
+
+  // optional .exec.user.LikeFilter schema_name_filter = 2;
+  if (has_schema_name_filter()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->schema_name_filter(), output);
+  }
+
+  // optional .exec.user.LikeFilter table_name_filter = 3;
+  if (has_table_name_filter()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->table_name_filter(), output);
+  }
+
+  // optional .exec.user.LikeFilter column_name_filter = 4;
+  if (has_column_name_filter()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->column_name_filter(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* GetColumnsReq::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // optional .exec.user.LikeFilter catalog_name_filter = 1;
+  if (has_catalog_name_filter()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->catalog_name_filter(), target);
+  }
+
+  // optional .exec.user.LikeFilter schema_name_filter = 2;
+  if (has_schema_name_filter()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->schema_name_filter(), target);
+  }
+
+  // optional .exec.user.LikeFilter table_name_filter = 3;
+  if (has_table_name_filter()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->table_name_filter(), target);
+  }
+
+  // optional .exec.user.LikeFilter column_name_filter = 4;
+  if (has_column_name_filter()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->column_name_filter(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int GetColumnsReq::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .exec.user.LikeFilter catalog_name_filter = 1;
+    if (has_catalog_name_filter()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->catalog_name_filter());
+    }
+
+    // optional .exec.user.LikeFilter schema_name_filter = 2;
+    if (has_schema_name_filter()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->schema_name_filter());
+    }
+
+    // optional .exec.user.LikeFilter table_name_filter = 3;
+    if (has_table_name_filter()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->table_name_filter());
+    }
+
+    // optional .exec.user.LikeFilter column_name_filter = 4;
+    if (has_column_name_filter()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->column_name_filter());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetColumnsReq::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetColumnsReq* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetColumnsReq*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetColumnsReq::MergeFrom(const GetColumnsReq& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_catalog_name_filter()) {
+      mutable_catalog_name_filter()->::exec::user::LikeFilter::MergeFrom(from.catalog_name_filter());
+    }
+    if (from.has_schema_name_filter()) {
+      mutable_schema_name_filter()->::exec::user::LikeFilter::MergeFrom(from.schema_name_filter());
+    }
+    if (from.has_table_name_filter()) {
+      mutable_table_name_filter()->::exec::user::LikeFilter::MergeFrom(from.table_name_filter());
+    }
+    if (from.has_column_name_filter()) {
+      mutable_column_name_filter()->::exec::user::LikeFilter::MergeFrom(from.column_name_filter());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetColumnsReq::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetColumnsReq::CopyFrom(const GetColumnsReq& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetColumnsReq::IsInitialized() const {
+
+  return true;
+}
+
+void GetColumnsReq::Swap(GetColumnsReq* other) {
+  if (other != this) {
+    std::swap(catalog_name_filter_, other->catalog_name_filter_);
+    std::swap(schema_name_filter_, other->schema_name_filter_);
+    std::swap(table_name_filter_, other->table_name_filter_);
+    std::swap(column_name_filter_, other->column_name_filter_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetColumnsReq::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetColumnsReq_descriptor_;
+  metadata.reflection = GetColumnsReq_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ColumnMetadata::kCatalogNameFieldNumber;
+const int ColumnMetadata::kSchemaNameFieldNumber;
+const int ColumnMetadata::kTableNameFieldNumber;
+const int ColumnMetadata::kColumnNameFieldNumber;
+const int ColumnMetadata::kOrdinalPositionFieldNumber;
+const int ColumnMetadata::kDefaultValueFieldNumber;
+const int ColumnMetadata::kIsNullableFieldNumber;
+const int ColumnMetadata::kDataTypeFieldNumber;
+const int ColumnMetadata::kCharMaxLengthFieldNumber;
+const int ColumnMetadata::kCharOctetLengthFieldNumber;
+const int ColumnMetadata::kNumericPrecisionFieldNumber;
+const int ColumnMetadata::kNumericPrecisionRadixFieldNumber;
+const int ColumnMetadata::kNumericScaleFieldNumber;
+const int ColumnMetadata::kDateTimePrecisionFieldNumber;
+const int ColumnMetadata::kIntervalTypeFieldNumber;
+const int ColumnMetadata::kIntervalPrecisionFieldNumber;
+const int ColumnMetadata::kColumnSizeFieldNumber;
+#endif  // !_MSC_VER
+
+ColumnMetadata::ColumnMetadata()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void ColumnMetadata::InitAsDefaultInstance() {
+}
+
+ColumnMetadata::ColumnMetadata(const ColumnMetadata& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void ColumnMetadata::SharedCtor() {
+  _cached_size_ = 0;
+  catalog_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  schema_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  table_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  column_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  ordinal_position_ = 0;
+  default_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  is_nullable_ = false;
+  data_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  char_max_length_ = 0;
+  char_octet_length_ = 0;
+  numeric_precision_ = 0;
+  numeric_precision_radix_ = 0;
+  numeric_scale_ = 0;
+  date_time_precision_ = 0;
+  interval_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  interval_precision_ = 0;
+  column_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ColumnMetadata::~ColumnMetadata() {
+  SharedDtor();
+}
+
+void ColumnMetadata::SharedDtor() {
+  if (catalog_name_ != &::google::protobuf::internal::kEmptyString) {
+    delete catalog_name_;
+  }
+  if (schema_name_ != &::google::protobuf::internal::kEmptyString) {
+    delete schema_name_;
+  }
+  if (table_name_ != &::google::protobuf::internal::kEmptyString) {
+    delete table_name_;
+  }
+  if (column_name_ != &::google::protobuf::internal::kEmptyString) {
+    delete column_name_;
+  }
+  if (default_value_ != &::google::protobuf::internal::kEmptyString) {
+    delete default_value_;
+  }
+  if (data_type_ != &::google::protobuf::internal::kEmptyString) {
+    delete data_type_;
+  }
+  if (interval_type_ != &::google::protobuf::internal::kEmptyString) {
+    delete interval_type_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void ColumnMetadata::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ColumnMetadata::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ColumnMetadata_descriptor_;
+}
+
+const ColumnMetadata& ColumnMetadata::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_User_2eproto();
+  return *default_instance_;
+}
+
+ColumnMetadata* ColumnMetadata::default_instance_ = NULL;
+
+ColumnMetadata* ColumnMetadata::New() const {
+  return new ColumnMetadata;
+}
+
+void ColumnMetadata::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (has_catalog_name()) {
+      if (catalog_name_ != &::google::protobuf::internal::kEmptyString) {
+        catalog_name_->clear();
+      }
+    }
+    if (has_schema_name()) {
+      if (schema_name_ != &::google::protobuf::internal::kEmptyString) {
+        schema_name_->clear();
+      }
+    }
+    if (has_table_name()) {
+      if (table_name_ != &::google::protobuf::internal::kEmptyString) {
+        table_name_->clear();
+      }
+    }
+    if (has_column_name()) {
+      if (column_name_ != &::google::protobuf::internal::kEmptyString) {
+        column_name_->clear();
+      }
+    }
+    ordinal_position_ = 0;
+    if (has_default_value()) {
+      if (default_value_ != &::google::protobuf::internal::kEmptyString) {
+        default_value_->clear();
+      }
+    }
+    is_nullable_ = false;
+    if (has_data_type()) {
+      if (data_type_ != &::google::protobuf::internal::kEmptyString) {
+        data_type_->clear();
+      }
+    }
+  }
+  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    char_max_length_ = 0;
+    char_octet_length_ = 0;
+    numeric_precision_ = 0;
+    numeric_precision_radix_ = 0;
+    numeric_scale_ = 0;
+    date_time_precision_ = 0;
+    if (has_interval_type()) {
+      if (interval_type_ != &::google::protobuf::internal::kEmptyString) {
+        interval_type_->clear();
+      }
+    }
+    interval_precision_ = 0;
+  }
+  if (_has_bits_[16 / 32] & (0xffu << (16 % 32))) {
+    column_size_ = 0;
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ColumnMetadata::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string catalog_name = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_catalog_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->catalog_name().data(), this->catalog_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(18)) goto parse_schema_name;
+        break;
+      }
+
+      // optional string schema_name = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_schema_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_schema_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->schema_name().data(), this->schema_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(26)) goto parse_table_name;
+        break;
+      }
+
+      // optional string table_name = 3;
+      case 3: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_table_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_table_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->table_name().data(), this->table_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(34)) goto parse_column_name;
+        break;
+      }
+
+      // optional string column_name = 4;
+      case 4: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_column_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_column_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->column_name().data(), this->column_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(40)) goto parse_ordinal_position;
+        break;
+      }
+
+      // optional int32 ordinal_position = 5;
+      case 5: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_ordinal_position:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &ordinal_position_)));
+          set_has_ordinal_position();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(50)) goto parse_default_value;
+        break;
+      }
+
+      // optional string default_value = 6;
+      case 6: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_default_value:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_default_value()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->default_value().data(), this->default_value().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(56)) goto parse_is_nullable;
+        break;
+      }
+
+      // optional bool is_nullable = 7;
+      case 7: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_is_nullable:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &is_nullable_)));
+          set_has_is_nullable();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(66)) goto parse_data_type;
+        break;
+      }
+
+      // optional string data_type = 8;
+      case 8: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_data_type:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_data_type()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->data_type().data(), this->data_type().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(72)) goto parse_char_max_length;
+        break;
+      }
+
+      // optional int32 char_max_length = 9;
+      case 9: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_char_max_length:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &char_max_length_)));
+          set_has_char_max_length();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(80)) goto parse_char_octet_length;
+        break;
+      }
+
+      // optional int32 char_octet_length = 10;
+      case 10: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_char_octet_length:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &char_octet_length_)));
+          set_has_char_octet_length();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(88)) goto parse_numeric_precision;
+        break;
+      }
+
+      // optional int32 numeric_precision = 11;
+      case 11: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_numeric_precision:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &numeric_precision_)));
+          set_has_numeric_precision();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(96)) goto parse_numeric_precision_radix;
+        break;
+      }
+
+      // optional int32 numeric_precision_radix = 12;
+      case 12: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_numeric_precision_radix:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &numeric_precision_radix_)));
+          set_has_numeric_precision_radix();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(104)) goto parse_numeric_scale;
+        break;
+      }
+
+      // optional int32 numeric_scale = 13;
+      case 13: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_numeric_scale:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &numeric_scale_)));
+          set_has_numeric_scale();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(112)) goto parse_date_time_precision;
+        break;
+      }
+
+      // optional int32 date_time_precision = 14;
+      case 14: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_date_time_precision:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &date_time_precision_)));
+          set_has_date_time_precision();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(122)) goto parse_interval_type;
+        break;
+      }
+
+      // optional string interval_type = 15;
+      case 15: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_interval_type:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_interval_type()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->interval_type().data(), this->interval_type().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(128)) goto parse_interval_precision;
+        break;
+      }
+
+      // optional int32 interval_precision = 16;
+      case 16: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_interval_precision:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &interval_precision_)));
+          set_has_interval_precision();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(136)) goto parse_column_size;
+        break;
+      }
+
+      // optional int32 column_size = 17;
+      case 17: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_column_size:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &column_size_)));
+          set_has_column_size();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void ColumnMetadata::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // optional string catalog_name = 1;
+  if (has_catalog_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->catalog_name().data(), this->catalog_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      1, this->catalog_name(), output);
+  }
+
+  // optional string schema_name = 2;
+  if (has_schema_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->schema_name().data(), this->schema_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      2, this->schema_name(), output);
+  }
+
+  // optional string table_name = 3;
+  if (has_table_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->table_name().data(), this->table_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      3, this->table_name(), output);
+  }
+
+  // optional string column_name = 4;
+  if (has_column_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->column_name().data(), this->column_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      4, this->column_name(), output);
+  }
+
+  // optional int32 ordinal_position = 5;
+  if (has_ordinal_position()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->ordinal_position(), output);
+  }
+
+  // optional string default_value = 6;
+  if (has_default_value()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->default_value().data(), this->default_value().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      6, this->default_value(), output);
+  }
+
+  // optional bool is_nullable = 7;
+  if (has_is_nullable()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->is_nullable(), output);
+  }
+
+  // optional string data_type = 8;
+  if (has_data_type()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->data_type().data(), this->data_type().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      8, this->data_type(), output);
+  }
+
+  // optional int32 char_max_length = 9;
+  if (has_char_max_length()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(9, this->char_max_length(), output);
+  }
+
+  // optional int32 char_octet_length = 10;
+  if (has_char_octet_length()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(10, this->char_octet_length(), output);
+  }
+
+  // optional int32 numeric_precision = 11;
+  if (has_numeric_precision()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(11, this->numeric_precision(), output);
+  }
+
+  // optional int32 numeric_precision_radix = 12;
+  if (has_numeric_precision_radix()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(12, this->numeric_precision_radix(), output);
+  }
+
+  // optional int32 numeric_scale = 13;
+  if (has_numeric_scale()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(13, this->numeric_scale(), output);
+  }
+
+  // optional int32 date_time_precision = 14;
+  if (has_date_time_precision()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(14, this->date_time_precision(), output);
+  }
+
+  // optional string interval_type = 15;
+  if (has_interval_type()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->interval_type().data(), this->interval_type().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      15, this->interval_type(), output);
+  }
+
+  // optional int32 interval_precision = 16;
+  if (has_interval_precision()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(16, this->interval_precision(), output);
+  }
+
+  // optional int32 column_size = 17;
+  if (has_column_size()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(17, this->column_size(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* ColumnMetadata::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // optional string catalog_name = 1;
+  if (has_catalog_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->catalog_name().data(), this->catalog_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->catalog_name(), target);
+  }
+
+  // optional string schema_name = 2;
+  if (has_schema_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->schema_name().data(), this->schema_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        2, this->schema_name(), target);
+  }
+
+  // optional string table_name = 3;
+  if (has_table_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->table_name().data(), this->table_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        3, this->table_name(), target);
+  }
+
+  // optional string column_name = 4;
+  if (has_column_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->column_name().data(), this->column_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        4, this->column_name(), target);
+  }
+
+  // optional int32 ordinal_position = 5;
+  if (has_ordinal_position()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->ordinal_position(), target);
+  }
+
+  // optional string default_value = 6;
+  if (has_default_value()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->default_value().data(), this->default_value().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        6, this->default_value(), target);
+  }
+
+  // optional bool is_nullable = 7;
+  if (has_is_nullable()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(7, this->is_nullable(), target);
+  }
+
+  // optional string data_type = 8;
+  if (has_data_type()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->data_type().data(), this->data_type().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        8, this->data_type(), target);
+  }
+
+  // optional int32 char_max_length = 9;
+  if (has_char_max_length()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(9, this->char_max_length(), target);
+  }
+
+  // optional int32 char_octet_length = 10;
+  if (has_char_octet_length()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(10, this->char_octet_length(), target);
+  }
+
+  // optional int32 numeric_precision = 11;
+  if (has_numeric_precision()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(11, this->numeric_precision(), target);
+  }
+
+  // optional int32 numeric_precision_radix = 12;
+  if (has_numeric_precision_radix()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(12, this->numeric_precision_radix(), target);
+  }
+
+  // optional int32 numeric_scale = 13;
+  if (has_numeric_scale()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(13, this->numeric_scale(), target);
+  }
+
+  // optional int32 date_time_precision = 14;
+  if (has_date_time_precision()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(14, this->date_time_precision(), target);
+  }
+
+  // optional string interval_type = 15;
+  if (has_interval_type()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->interval_type().data(), this->interval_type().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        15, this->interval_type(), target);
+  }
+
+  // optional int32 interval_precision = 16;
+  if (has_interval_precision()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(16, this->interval_precision(), target);
+  }
+
+  // optional int32 column_size = 17;
+  if (has_column_size()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(17, this->column_size(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int ColumnMetadata::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string catalog_name = 1;
+    if (has_catalog_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->catalog_name());
+    }
+
+    // optional string schema_name = 2;
+    if (has_schema_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->schema_name());
+    }
+
+    // optional string table_name = 3;
+    if (has_table_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->table_name());
+    }
+
+    // optional string column_name = 4;
+    if (has_column_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->column_name());
+    }
+
+    // optional int32 ordinal_position = 5;
+    if (has_ordinal_position()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->ordinal_position());
+    }
+
+    // optional string default_value = 6;
+    if (has_default_value()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->default_value());
+    }
+
+    // optional bool is_nullable = 7;
+    if (has_is_nullable()) {
+      total_size += 1 + 1;
+    }
+
+    // optional string data_type = 8;
+    if (has_data_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->data_type());
+    }
+
+  }
+  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    // optional int32 char_max_length = 9;
+    if (has_char_max_length()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->char_max_length());
+    }
+
+    // optional int32 char_octet_length = 10;
+    if (has_char_octet_length()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->char_octet_length());
+    }
+
+    // optional int32 numeric_precision = 11;
+    if (has_numeric_precision()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->numeric_precision());
+    }
+
+    // optional int32 numeric_precision_radix = 12;
+    if (has_numeric_precision_radix()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->numeric_precision_radix());
+    }
+
+    // optional int32 numeric_scale = 13;
+    if (has_numeric_scale()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->numeric_scale());
+    }
+
+    // optional int32 date_time_precision = 14;
+    if (has_date_time_precision()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->date_time_precision());
+    }
+
+    // optional string interval_type = 15;
+    if (has_interval_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->interval_type());
+    }
+
+    // optional int32 interval_precision = 16;
+    if (has_interval_precision()) {
+      total_size += 2 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->interval_precision());
+    }
+
+  }
+  if (_has_bits_[16 / 32] & (0xffu << (16 % 32))) {
+    // optional int32 column_size = 17;
+    if (has_column_size()) {
+      total_size += 2 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->column_size());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ColumnMetadata::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ColumnMetadata* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ColumnMetadata*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ColumnMetadata::MergeFrom(const ColumnMetadata& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_catalog_name()) {
+      set_catalog_name(from.catalog_name());
+    }
+    if (from.has_schema_name()) {
+      set_schema_name(from.schema_name());
+    }
+    if (from.has_table_name()) {
+      set_table_name(from.table_name());
+    }
+    if (from.has_column_name()) {
+      set_column_name(from.column_name());
+    }
+    if (from.has_ordinal_position()) {
+      set_ordinal_position(from.ordinal_position());
+    }
+    if (from.has_default_value()) {
+      set_default_value(from.default_value());
+    }
+    if (from.has_is_nullable()) {
+      set_is_nullable(from.is_nullable());
+    }
+    if (from.has_data_type()) {
+      set_data_type(from.data_type());
+    }
+  }
+  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    if (from.has_char_max_length()) {
+      set_char_max_length(from.char_max_length());
+    }
+    if (from.has_char_octet_length()) {
+      set_char_octet_length(from.char_octet_length());
+    }
+    if (from.has_numeric_precision()) {
+      set_numeric_precision(from.numeric_precision());
+    }
+    if (from.has_numeric_precision_radix()) {
+      set_numeric_precision_radix(from.numeric_precision_radix());
+    }
+    if (from.has_numeric_scale()) {
+      set_numeric_scale(from.numeric_scale());
+    }
+    if (from.has_date_time_precision()) {
+      set_date_time_precision(from.date_time_precision());
+    }
+    if (from.has_interval_type()) {
+      set_interval_type(from.interval_type());
+    }
+    if (from.has_interval_precision()) {
+      set_interval_precision(from.interval_precision());
+    }
+  }
+  if (from._has_bits_[16 / 32] & (0xffu << (16 % 32))) {
+    if (from.has_column_size()) {
+      set_column_size(from.column_size());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ColumnMetadata::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ColumnMetadata::CopyFrom(const ColumnMetadata& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ColumnMetadata::IsInitialized() const {
+
+  return true;
+}
+
+void ColumnMetadata::Swap(ColumnMetadata* other) {
+  if (other != this) {
+    std::swap(catalog_name_, other->catalog_name_);
+    std::swap(schema_name_, other->schema_name_);
+    std::swap(table_name_, other->table_name_);
+    std::swap(column_name_, other->column_name_);
+    std::swap(ordinal_position_, other->ordinal_position_);
+    std::swap(default_value_, other->default_value_);
+    std::swap(is_nullable_, other->is_nullable_);
+    std::swap(data_type_, other->data_type_);
+    std::swap(char_max_length_, other->char_max_length_);
+    std::swap(char_octet_length_, other->char_octet_length_);
+    std::swap(numeric_precision_, other->numeric_precision_);
+    std::swap(numeric_precision_radix_, other->numeric_precision_radix_);
+    std::swap(numeric_scale_, other->numeric_scale_);
+    std::swap(date_time_precision_, other->date_time_precision_);
+    std::swap(interval_type_, other->interval_type_);
+    std::swap(interval_precision_, other->interval_precision_);
+    std::swap(column_size_, other->column_size_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ColumnMetadata::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ColumnMetadata_descriptor_;
+  metadata.reflection = ColumnMetadata_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetColumnsResp::kStatusFieldNumber;
+const int GetColumnsResp::kColumnsFieldNumber;
+const int GetColumnsResp::kErrorFieldNumber;
+#endif  // !_MSC_VER
+
+GetColumnsResp::GetColumnsResp()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void GetColumnsResp::InitAsDefaultInstance() {
+  error_ = const_cast< ::exec::shared::DrillPBError*>(&::exec::shared::DrillPBError::default_instance());
+}
+
+GetColumnsResp::GetColumnsResp(const GetColumnsResp& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void GetColumnsResp::SharedCtor() {
+  _cached_size_ = 0;
+  status_ = 0;
+  error_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetColumnsResp::~GetColumnsResp() {
+  SharedDtor();
+}
+
+void GetColumnsResp::SharedDtor() {
+  if (this != default_instance_) {
+    delete error_;
+  }
+}
+
+void GetColumnsResp::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetColumnsResp::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetColumnsResp_descriptor_;
+}
+
+const GetColumnsResp& GetColumnsResp::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_User_2eproto();
+  return *default_instance_;
+}
+
+GetColumnsResp* GetColumnsResp::default_instance_ = NULL;
+
+GetColumnsResp* GetColumnsResp::New() const {
+  return new GetColumnsResp;
+}
+
+void GetColumnsResp::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    status_ = 0;
+    if (has_error()) {
+      if (error_ != NULL) error_->::exec::shared::DrillPBError::Clear();
+    }
+  }
+  columns_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetColumnsResp::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .exec.user.RequestStatus status = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::exec::user::RequestStatus_IsValid(value)) {
+            set_status(static_cast< ::exec::user::RequestStatus >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(1, value);
+          }
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(18)) goto parse_columns;
+        break;
+      }
+
+      // repeated .exec.user.ColumnMetadata columns = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_columns:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_columns()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(18)) goto parse_columns;
+        if (input->ExpectTag(26)) goto parse_error;
+        break;
+      }
+
+      // optional .exec.shared.DrillPBError error = 3;
+      case 3: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_error:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_error()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void GetColumnsResp::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // optional .exec.user.RequestStatus status = 1;
+  if (has_status()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      1, this->status(), output);
+  }
+
+  // repeated .exec.user.ColumnMetadata columns = 2;
+  for (int i = 0; i < this->columns_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->columns(i), output);
+  }
+
+  // optional .exec.shared.DrillPBError error = 3;
+  if (has_error()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->error(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* GetColumnsResp::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // optional .exec.user.RequestStatus status = 1;
+  if (has_status()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      1, this->status(), target);
+  }
+
+  // repeated .exec.user.ColumnMetadata columns = 2;
+  for (int i = 0; i < this->columns_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->columns(i), target);
+  }
+
+  // optional .exec.shared.DrillPBError error = 3;
+  if (has_error()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->error(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int GetColumnsResp::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .exec.user.RequestStatus status = 1;
+    if (has_status()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->status());
+    }
+
+    // optional .exec.shared.DrillPBError error = 3;
+    if (has_error()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->error());
+    }
+
+  }
+  // repeated .exec.user.ColumnMetadata columns = 2;
+  total_size += 1 * this->columns_size();
+  for (int i = 0; i < this->columns_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->columns(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetColumnsResp::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetColumnsResp* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetColumnsResp*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetColumnsResp::MergeFrom(const GetColumnsResp& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  columns_.MergeFrom(from.columns_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_status()) {
+      set_status(from.status());
+    }
+    if (from.has_error()) {
+      mutable_error()->::exec::shared::DrillPBError::MergeFrom(from.error());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetColumnsResp::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetColumnsResp::CopyFrom(const GetColumnsResp& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetColumnsResp::IsInitialized() const {
+
+  return true;
+}
+
+void GetColumnsResp::Swap(GetColumnsResp* other) {
+  if (other != this) {
+    std::swap(status_, other->status_);
+    columns_.Swap(&other->columns_);
+    std::swap(error_, other->error_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetColumnsResp::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetColumnsResp_descriptor_;
+  metadata.reflection = GetColumnsResp_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int CreatePreparedStatementReq::kSqlQueryFieldNumber;
+#endif  // !_MSC_VER
+
+CreatePreparedStatementReq::CreatePreparedStatementReq()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void CreatePreparedStatementReq::InitAsDefaultInstance() {
+}
+
+CreatePreparedStatementReq::CreatePreparedStatementReq(const CreatePreparedStatementReq& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void CreatePreparedStatementReq::SharedCtor() {
+  _cached_size_ = 0;
+  sql_query_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+CreatePreparedStatementReq::~CreatePreparedStatementReq() {
+  SharedDtor();
+}
+
+void CreatePreparedStatementReq::SharedDtor() {
+  if (sql_query_ != &::google::protobuf::internal::kEmptyString) {
+    delete sql_query_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void CreatePreparedStatementReq::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* CreatePreparedStatementReq::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return CreatePreparedStatementReq_descriptor_;
+}
+
+const CreatePreparedStatementReq& CreatePreparedStatementReq::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_User_2eproto();
+  return *default_instance_;
+}
+
+CreatePreparedStatementReq* CreatePreparedStatementReq::default_instance_ = NULL;
+
+CreatePreparedStatementReq* CreatePreparedStatementReq::New() const {
+  return new CreatePreparedStatementReq;
+}
+
+void CreatePreparedStatementReq::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (has_sql_query()) {
+      if (sql_query_ != &::google::protobuf::internal::kEmptyString) {
+        sql_query_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool CreatePreparedStatementReq::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string sql_query = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_sql_query()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->sql_query().data(), this->sql_query().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void CreatePreparedStatementReq::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // optional string sql_query = 1;
+  if (has_sql_query()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->sql_query().data(), this->sql_query().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      1, this->sql_query(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* CreatePreparedStatementReq::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // optional string sql_query = 1;
+  if (has_sql_query()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->sql_query().data(), this->sql_query().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->sql_query(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int CreatePreparedStatementReq::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string sql_query = 1;
+    if (has_sql_query()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->sql_query());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void CreatePreparedStatementReq::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const CreatePreparedStatementReq* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const CreatePreparedStatementReq*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void CreatePreparedStatementReq::MergeFrom(const CreatePreparedStatementReq& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_sql_query()) {
+      set_sql_query(from.sql_query());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void CreatePreparedStatementReq::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void CreatePreparedStatementReq::CopyFrom(const CreatePreparedStatementReq& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool CreatePreparedStatementReq::IsInitialized() const {
+
+  return true;
+}
+
+void CreatePreparedStatementReq::Swap(CreatePreparedStatementReq* other) {
+  if (other != this) {
+    std::swap(sql_query_, other->sql_query_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata CreatePreparedStatementReq::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = CreatePreparedStatementReq_descriptor_;
+  metadata.reflection = CreatePreparedStatementReq_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ResultColumnMetadata::kCatalogNameFieldNumber;
+const int ResultColumnMetadata::kSchemaNameFieldNumber;
+const int ResultColumnMetadata::kTableNameFieldNumber;
+const int ResultColumnMetadata::kColumnNameFieldNumber;
+const int ResultColumnMetadata::kLabelFieldNumber;
+const int ResultColumnMetadata::kDataTypeFieldNumber;
+const int ResultColumnMetadata::kIsNullableFieldNumber;
+const int ResultColumnMetadata::kPrecisionFieldNumber;
+const int ResultColumnMetadata::kScaleFieldNumber;
+const int ResultColumnMetadata::kSignedFieldNumber;
+const int ResultColumnMetadata::kDisplaySizeFieldNumber;
+const int ResultColumnMetadata::kIsAliasedFieldNumber;
+const int ResultColumnMetadata::kSearchabilityFieldNumber;
+const int ResultColumnMetadata::kUpdatabilityFieldNumber;
+const int ResultColumnMetadata::kAutoIncrementFieldNumber;
+const int ResultColumnMetadata::kCaseSensitivityFieldNumber;
+const int ResultColumnMetadata::kSortableFieldNumber;
+const int ResultColumnMetadata::kClassNameFieldNumber;
+const int ResultColumnMetadata::kIsCurrencyFieldNumber;
+#endif  // !_MSC_VER
+
+ResultColumnMetadata::ResultColumnMetadata()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void ResultColumnMetadata::InitAsDefaultInstance() {
+}
+
+ResultColumnMetadata::ResultColumnMetadata(const ResultColumnMetadata& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void ResultColumnMetadata::SharedCtor() {
+  _cached_size_ = 0;
+  catalog_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  schema_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  table_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  column_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  label_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  data_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  is_nullable_ = false;
+  precision_ = 0;
+  scale_ = 0;
+  signed__ = false;
+  display_size_ = 0;
+  is_aliased_ = false;
+  searchability_ = 0;
+  updatability_ = 0;
+  auto_increment_ = false;
+  case_sensitivity_ = false;
+  sortable_ = false;
+  class_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  is_currency_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ResultColumnMetadata::~ResultColumnMetadata() {
+  SharedDtor();
+}
+
+void ResultColumnMetadata::SharedDtor() {
+  if (catalog_name_ != &::google::protobuf::internal::kEmptyString) {
+    delete catalog_name_;
+  }
+  if (schema_name_ != &::google::protobuf::internal::kEmptyString) {
+    delete schema_name_;
+  }
+  if (table_name_ != &::google::protobuf::internal::kEmptyString) {
+    delete table_name_;
+  }
+  if (column_name_ != &::google::protobuf::internal::kEmptyString) {
+    delete column_name_;
+  }
+  if (label_ != &::google::protobuf::internal::kEmptyString) {
+    delete label_;
+  }
+  if (data_type_ != &::google::protobuf::internal::kEmptyString) {
+    delete data_type_;
+  }
+  if (class_name_ != &::google::protobuf::internal::kEmptyString) {
+    delete class_name_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void ResultColumnMetadata::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ResultColumnMetadata::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ResultColumnMetadata_descriptor_;
+}
+
+const ResultColumnMetadata& ResultColumnMetadata::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_User_2eproto();
+  return *default_instance_;
+}
+
+ResultColumnMetadata* ResultColumnMetadata::default_instance_ = NULL;
+
+ResultColumnMetadata* ResultColumnMetadata::New() const {
+  return new ResultColumnMetadata;
+}
+
+void ResultColumnMetadata::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (has_catalog_name()) {
+      if (catalog_name_ != &::google::protobuf::internal::kEmptyString) {
+        catalog_name_->clear();
+      }
+    }
+    if (has_schema_name()) {
+      if (schema_name_ != &::google::protobuf::internal::kEmptyString) {
+        schema_name_->clear();
+      }
+    }
+    if (has_table_name()) {
+      if (table_name_ != &::google::protobuf::internal::kEmptyString) {
+        table_name_->clear();
+      }
+    }
+    if (has_column_name()) {
+      if (column_name_ != &::google::protobuf::internal::kEmptyString) {
+        column_name_->clear();
+      }
+    }
+    if (has_label()) {
+      if (label_ != &::google::protobuf::internal::kEmptyString) {
+        label_->clear();
+      }
+    }
+    if (has_data_type()) {
+      if (data_type_ != &::google::protobuf::internal::kEmptyString) {
+        data_type_->clear();
+      }
+    }
+    is_nullable_ = false;
+    precision_ = 0;
+  }
+  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    scale_ = 0;
+    signed__ = false;
+    display_size_ = 0;
+    is_aliased_ = false;
+    searchability_ = 0;
+    updatability_ = 0;
+    auto_increment_ = false;
+    case_sensitivity_ = false;
+  }
+  if (_has_bits_[16 / 32] & (0xffu << (16 % 32))) {
+    sortable_ = false;
+    if (has_class_name()) {
+      if (class_name_ != &::google::protobuf::internal::kEmptyString) {
+        class_name_->clear();
+      }
+    }
+    is_currency_ = false;
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ResultColumnMetadata::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string catalog_name = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_catalog_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->catalog_name().data(), this->catalog_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(18)) goto parse_schema_name;
+        break;
+      }
+
+      // optional string schema_name = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_schema_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_schema_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->schema_name().data(), this->schema_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(26)) goto parse_table_name;
+        break;
+      }
+
+      // optional string table_name = 3;
+      case 3: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_table_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_table_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->table_name().data(), this->table_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(34)) goto parse_column_name;
+        break;
+      }
+
+      // optional string column_name = 4;
+      case 4: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_column_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_column_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->column_name().data(), this->column_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(42)) goto parse_label;
+        break;
+      }
+
+      // optional string label = 5;
+      case 5: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_label:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_label()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->label().data(), this->label().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(50)) goto parse_data_type;
+        break;
+      }
+
+      // optional string data_type = 6;
+      case 6: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_data_type:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_data_type()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->data_type().data(), this->data_type().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(56)) goto parse_is_nullable;
+        break;
+      }
+
+      // optional bool is_nullable = 7;
+      case 7: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_is_nullable:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &is_nullable_)));
+          set_has_is_nullable();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(64)) goto parse_precision;
+        break;
+      }
+
+      // optional int32 precision = 8;
+      case 8: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_precision:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &precision_)));
+          set_has_precision();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(72)) goto parse_scale;
+        break;
+      }
+
+      // optional int32 scale = 9;
+      case 9: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_scale:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &scale_)));
+          set_has_scale();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(80)) goto parse_signed;
+        break;
+      }
+
+      // optional bool signed = 10;
+      case 10: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_signed:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &signed__)));
+          set_has_signed_();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(88)) goto parse_display_size;
+        break;
+      }
+
+      // optional int32 display_size = 11;
+      case 11: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_display_size:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &display_size_)));
+          set_has_display_size();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(96)) goto parse_is_aliased;
+        break;
+      }
+
+      // optional bool is_aliased = 12;
+      case 12: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_is_aliased:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &is_aliased_)));
+          set_has_is_aliased();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(104)) goto parse_searchability;
+        break;
+      }
+
+      // optional .exec.user.ColumnSearchability searchability = 13;
+      case 13: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_searchability:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::exec::user::ColumnSearchability_IsValid(value)) {
+            set_searchability(static_cast< ::exec::user::ColumnSearchability >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(13, value);
+          }
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(112)) goto parse_updatability;
+        break;
+      }
+
+      // optional .exec.user.ColumnUpdatability updatability = 14;
+      case 14: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_updatability:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::exec::user::ColumnUpdatability_IsValid(value)) {
+            set_updatability(static_cast< ::exec::user::ColumnUpdatability >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(14, value);
+          }
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(120)) goto parse_auto_increment;
+        break;
+      }
+
+      // optional bool auto_increment = 15;
+      case 15: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_auto_increment:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &auto_increment_)));
+          set_has_auto_increment();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(128)) goto parse_case_sensitivity;
+        break;
+      }
+
+      // optional bool case_sensitivity = 16;
+      case 16: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_case_sensitivity:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &case_sensitivity_)));
+          set_has_case_sensitivity();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(136)) goto parse_sortable;
+        break;
+      }
+
+      // optional bool sortable = 17;
+      case 17: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_sortable:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &sortable_)));
+          set_has_sortable();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(146)) goto parse_class_name;
+        break;
+      }
+
+      // optional string class_name = 18;
+      case 18: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_class_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_class_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->class_name().data(), this->class_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(160)) goto parse_is_currency;
+        break;
+      }
+
+      // optional bool is_currency = 20;
+      case 20: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_is_currency:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &is_currency_)));
+          set_has_is_currency();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void ResultColumnMetadata::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // optional string catalog_name = 1;
+  if (has_catalog_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->catalog_name().data(), this->catalog_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      1, this->catalog_name(), output);
+  }
+
+  // optional string schema_name = 2;
+  if (has_schema_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->schema_name().data(), this->schema_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      2, this->schema_name(), output);
+  }
+
+  // optional string table_name = 3;
+  if (has_table_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->table_name().data(), this->table_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      3, this->table_name(), output);
+  }
+
+  // optional string column_name = 4;
+  if (has_column_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->column_name().data(), this->column_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      4, this->column_name(), output);
+  }
+
+  // optional string label = 5;
+  if (has_label()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->label().data(), this->label().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      5, this->label(), output);
+  }
+
+  // optional string data_type = 6;
+  if (has_data_type()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->data_type().data(), this->data_type().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      6, this->data_type(), output);
+  }
+
+  // optional bool is_nullable = 7;
+  if (has_is_nullable()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->is_nullable(), output);
+  }
+
+  // optional int32 precision = 8;
+  if (has_precision()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(8, this->precision(), output);
+  }
+
+  // optional int32 scale = 9;
+  if (has_scale()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(9, this->scale(), output);
+  }
+
+  // optional bool signed = 10;
+  if (has_signed_()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(10, this->signed_(), output);
+  }
+
+  // optional int32 display_size = 11;
+  if (has_display_size()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(11, this->display_size(), output);
+  }
+
+  // optional bool is_aliased = 12;
+  if (has_is_aliased()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(12, this->is_aliased(), output);
+  }
+
+  // optional .exec.user.ColumnSearchability searchability = 13;
+  if (has_searchability()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      13, this->searchability(), output);
+  }
+
+  // optional .exec.user.ColumnUpdatability updatability = 14;
+  if (has_updatability()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      14, this->updatability(), output);
+  }
+
+  // optional bool auto_increment = 15;
+  if (has_auto_increment()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(15, this->auto_increment(), output);
+  }
+
+  // optional bool case_sensitivity = 16;
+  if (has_case_sensitivity()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(16, this->case_sensitivity(), output);
+  }
+
+  // optional bool sortable = 17;
+  if (has_sortable()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(17, this->sortable(), output);
+  }
+
+  // optional string class_name = 18;
+  if (has_class_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->class_name().data(), this->class_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      18, this->class_name(), output);
+  }
+
+  // optional bool is_currency = 20;
+  if (has_is_currency()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(20, this->is_currency(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* ResultColumnMetadata::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // optional string catalog_name = 1;
+  if (has_catalog_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->catalog_name().data(), this->catalog_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->catalog_name(), target);
+  }
+
+  // optional string schema_name = 2;
+  if (has_schema_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->schema_name().data(), this->schema_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        2, this->schema_name(), target);
+  }
+
+  // optional string table_name = 3;
+  if (has_table_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->table_name().data(), this->table_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        3, this->table_name(), target);
+  }
+
+  // optional string column_name = 4;
+  if (has_column_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->column_name().data(), this->column_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        4, this->column_name(), target);
+  }
+
+  // optional string label = 5;
+  if (has_label()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->label().data(), this->label().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        5, this->label(), target);
+  }
+
+  // optional string data_type = 6;
+  if (has_data_type()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->data_type().data(), this->data_type().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        6, this->data_type(), target);
+  }
+
+  // optional bool is_nullable = 7;
+  if (has_is_nullable()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(7, this->is_nullable(), target);
+  }
+
+  // optional int32 precision = 8;
+  if (has_precision()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(8, this->precision(), target);
+  }
+
+  // optional int32 scale = 9;
+  if (has_scale()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(9, this->scale(), target);
+  }
+
+  // optional bool signed = 10;
+  if (has_signed_()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(10, this->signed_(), target);
+  }
+
+  // optional int32 display_size = 11;
+  if (has_display_size()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(11, this->display_size(), target);
+  }
+
+  // optional bool is_aliased = 12;
+  if (has_is_aliased()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(12, this->is_aliased(), target);
+  }
+
+  // optional .exec.user.ColumnSearchability searchability = 13;
+  if (has_searchability()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      13, this->searchability(), target);
+  }
+
+  // optional .exec.user.ColumnUpdatability updatability = 14;
+  if (has_updatability()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      14, this->updatability(), target);
+  }
+
+  // optional bool auto_increment = 15;
+  if (has_auto_increment()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(15, this->auto_increment(), target);
+  }
+
+  // optional bool case_sensitivity = 16;
+  if (has_case_sensitivity()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(16, this->case_sensitivity(), target);
+  }
+
+  // optional bool sortable = 17;
+  if (has_sortable()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(17, this->sortable(), target);
+  }
+
+  // optional string class_name = 18;
+  if (has_class_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->class_name().data(), this->class_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        18, this->class_name(), target);
+  }
+
+  // optional bool is_currency = 20;
+  if (has_is_currency()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(20, this->is_currency(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int ResultColumnMetadata::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string catalog_name = 1;
+    if (has_catalog_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->catalog_name());
+    }
+
+    // optional string schema_name = 2;
+    if (has_schema_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->schema_name());
+    }
+
+    // optional string table_name = 3;
+    if (has_table_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->table_name());
+    }
+
+    // optional string column_name = 4;
+    if (has_column_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->column_name());
+    }
+
+    // optional string label = 5;
+    if (has_label()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->label());
+    }
+
+    // optional string data_type = 6;
+    if (has_data_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->data_type());
+    }
+
+    // optional bool is_nullable = 7;
+    if (has_is_nullable()) {
+      total_size += 1 + 1;
+    }
+
+    // optional int32 precision = 8;
+    if (has_precision()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->precision());
+    }
+
+  }
+  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    // optional int32 scale = 9;
+    if (has_scale()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->scale());
+    }
+
+    // optional bool signed = 10;
+    if (has_signed_()) {
+      total_size += 1 + 1;
+    }
+
+    // optional int32 display_size = 11;
+    if (has_display_size()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->display_size());
+    }
+
+    // optional bool is_aliased = 12;
+    if (has_is_aliased()) {
+      total_size += 1 + 1;
+    }
+
+    // optional .exec.user.ColumnSearchability searchability = 13;
+    if (has_searchability()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->searchability());
+    }
+
+    // optional .exec.user.ColumnUpdatability updatability = 14;
+    if (has_updatability()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->updatability());
+    }
+
+    // optional bool auto_increment = 15;
+    if (has_auto_increment()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool case_sensitivity = 16;
+    if (has_case_sensitivity()) {
+      total_size += 2 + 1;
+    }
+
+  }
+  if (_has_bits_[16 / 32] & (0xffu << (16 % 32))) {
+    // optional bool sortable = 17;
+    if (has_sortable()) {
+      total_size += 2 + 1;
+    }
+
+    // optional string class_name = 18;
+    if (has_class_name()) {
+      total_size += 2 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->class_name());
+    }
+
+    // optional bool is_currency = 20;
+    if (has_is_currency()) {
+      total_size += 2 + 1;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ResultColumnMetadata::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ResultColumnMetadata* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ResultColumnMetadata*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ResultColumnMetadata::MergeFrom(const ResultColumnMetadata& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_catalog_name()) {
+      set_catalog_name(from.catalog_name());
+    }
+    if (from.has_schema_name()) {
+      set_schema_name(from.schema_name());
+    }
+    if (from.has_table_name()) {
+      set_table_name(from.table_name());
+    }
+    if (from.has_column_name()) {
+      set_column_name(from.column_name());
+    }
+    if (from.has_label()) {
+      set_label(from.label());
+    }
+    if (from.has_data_type()) {
+      set_data_type(from.data_type());
+    }
+    if (from.has_is_nullable()) {
+      set_is_nullable(from.is_nullable());
+    }
+    if (from.has_precision()) {
+      set_precision(from.precision());
+    }
+  }
+  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    if (from.has_scale()) {
+      set_scale(from.scale());
+    }
+    if (from.has_signed_()) {
+      set_signed_(from.signed_());
+    }
+    if (from.has_display_size()) {
+      set_display_size(from.display_size());
+    }
+    if (from.has_is_aliased()) {
+      set_is_aliased(from.is_aliased());
+    }
+    if (from.has_searchability()) {
+      set_searchability(from.searchability());
+    }
+    if (from.has_updatability()) {
+      set_updatability(from.updatability());
+    }
+    if (from.has_auto_increment()) {
+      set_auto_increment(from.auto_increment());
+    }
+    if (from.has_case_sensitivity()) {
+      set_case_sensitivity(from.case_sensitivity());
+    }
+  }
+  if (from._has_bits_[16 / 32] & (0xffu << (16 % 32))) {
+    if (from.has_sortable()) {
+      set_sortable(from.sortable());
+    }
+    if (from.has_class_name()) {
+      set_class_name(from.class_name());
+    }
+    if (from.has_is_currency()) {
+      set_is_currency(from.is_currency());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ResultColumnMetadata::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ResultColumnMetadata::CopyFrom(const ResultColumnMetadata& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ResultColumnMetadata::IsInitialized() const {
+
+  return true;
+}
+
+void ResultColumnMetadata::Swap(ResultColumnMetadata* other) {
+  if (other != this) {
+    std::swap(catalog_name_, other->catalog_name_);
+    std::swap(schema_name_, other->schema_name_);
+    std::swap(table_name_, other->table_name_);
+    std::swap(column_name_, other->column_name_);
+    std::swap(label_, other->label_);
+    std::swap(data_type_, other->data_type_);
+    std::swap(is_nullable_, other->is_nullable_);
+    std::swap(precision_, other->precision_);
+    std::swap(scale_, other->scale_);
+    std::swap(signed__, other->signed__);
+    std::swap(display_size_, other->display_size_);
+    std::swap(is_aliased_, other->is_aliased_);
+    std::swap(searchability_, other->searchability_);
+    std::swap(updatability_, other->updatability_);
+    std::swap(auto_increment_, other->auto_increment_);
+    std::swap(case_sensitivity_, other->case_sensitivity_);
+    std::swap(sortable_, other->sortable_);
+    std::swap(class_name_, other->class_name_);
+    std::swap(is_currency_, other->is_currency_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ResultColumnMetadata::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ResultColumnMetadata_descriptor_;
+  metadata.reflection = ResultColumnMetadata_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int PreparedStatementHandle::kServerInfoFieldNumber;
+#endif  // !_MSC_VER
+
+PreparedStatementHandle::PreparedStatementHandle()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void PreparedStatementHandle::InitAsDefaultInstance() {
+}
+
+PreparedStatementHandle::PreparedStatementHandle(const PreparedStatementHandle& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void PreparedStatementHandle::SharedCtor() {
+  _cached_size_ = 0;
+  server_info_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+PreparedStatementHandle::~PreparedStatementHandle() {
+  SharedDtor();
+}
+
+void PreparedStatementHandle::SharedDtor() {
+  if (server_info_ != &::google::protobuf::internal::kEmptyString) {
+    delete server_info_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void PreparedStatementHandle::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* PreparedStatementHandle::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return PreparedStatementHandle_descriptor_;
+}
+
+const PreparedStatementHandle& PreparedStatementHandle::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_User_2eproto();
+  return *default_instance_;
+}
+
+PreparedStatementHandle* PreparedStatementHandle::default_instance_ = NULL;
+
+PreparedStatementHandle* PreparedStatementHandle::New() const {
+  return new PreparedStatementHandle;
+}
+
+void PreparedStatementHandle::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (has_server_info()) {
+      if (server_info_ != &::google::protobuf::internal::kEmptyString) {
+        server_info_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool PreparedStatementHandle::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional bytes server_info = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_server_info()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void PreparedStatementHandle::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // optional bytes server_info = 1;
+  if (has_server_info()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytes(
+      1, this->server_info(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* PreparedStatementHandle::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // optional bytes server_info = 1;
+  if (has_server_info()) {
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
+        1, this->server_info(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int PreparedStatementHandle::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional bytes server_info = 1;
+    if (has_server_info()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->server_info());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void PreparedStatementHandle::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const PreparedStatementHandle* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const PreparedStatementHandle*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void PreparedStatementHandle::MergeFrom(const PreparedStatementHandle& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_server_info()) {
+      set_server_info(from.server_info());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void PreparedStatementHandle::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void PreparedStatementHandle::CopyFrom(const PreparedStatementHandle& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool PreparedStatementHandle::IsInitialized() const {
+
+  return true;
+}
+
+void PreparedStatementHandle::Swap(PreparedStatementHandle* other) {
+  if (other != this) {
+    std::swap(server_info_, other->server_info_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata PreparedStatementHandle::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = PreparedStatementHandle_descriptor_;
+  metadata.reflection = PreparedStatementHandle_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int PreparedStatement::kColumnsFieldNumber;
+const int PreparedStatement::kServerHandleFieldNumber;
+#endif  // !_MSC_VER
+
+PreparedStatement::PreparedStatement()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void PreparedStatement::InitAsDefaultInstance() {
+  server_handle_ = const_cast< ::exec::user::PreparedStatementHandle*>(&::exec::user::PreparedStatementHandle::default_instance());
+}
+
+PreparedStatement::PreparedStatement(const PreparedStatement& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void PreparedStatement::SharedCtor() {
+  _cached_size_ = 0;
+  server_handle_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+PreparedStatement::~PreparedStatement() {
+  SharedDtor();
+}
+
+void PreparedStatement::SharedDtor() {
+  if (this != default_instance_) {
+    delete server_handle_;
+  }
+}
+
+void PreparedStatement::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* PreparedStatement::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return PreparedStatement_descriptor_;
+}
+
+const PreparedStatement& PreparedStatement::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_User_2eproto();
+  return *default_instance_;
+}
+
+PreparedStatement* PreparedStatement::default_instance_ = NULL;
+
+PreparedStatement* PreparedStatement::New() const {
+  return new PreparedStatement;
+}
+
+void PreparedStatement::Clear() {
+  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    if (has_server_handle()) {
+      if (server_handle_ != NULL) server_handle_->::exec::user::PreparedStatementHandle::Clear();
+    }
+  }
+  columns_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool PreparedStatement::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .exec.user.ResultColumnMetadata columns = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_columns:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_columns()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(10)) goto parse_columns;
+        if (input->ExpectTag(18)) goto parse_server_handle;
+        break;
+      }
+
+      // optional .exec.user.PreparedStatementHandle server_handle = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_server_handle:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_server_handle()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void PreparedStatement::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // repeated .exec.user.ResultColumnMetadata columns = 1;
+  for (int i = 0; i < this->columns_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->columns(i), output);
+  }
+
+  // optional .exec.user.PreparedStatementHandle server_handle = 2;
+  if (has_server_handle()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->server_handle(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* PreparedStatement::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // repeated .exec.user.ResultColumnMetadata columns = 1;
+  for (int i = 0; i < this->columns_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->columns(i), target);
+  }
+
+  // optional .exec.user.PreparedStatementHandle server_handle = 2;
+  if (has_server_handle()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->server_handle(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int PreparedStatement::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    // optional .exec.user.PreparedStatementHandle server_handle = 2;
+    if (has_server_handle()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->server_handle());
+    }
+
+  }
+  // repeated .exec.user.ResultColumnMetadata columns = 1;
+  total_size += 1 * this->columns_size();
+  for (int i = 0; i < this->columns_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->columns(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void PreparedStatement::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const PreparedStatement* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const PreparedStatement*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void PreparedStatement::MergeFrom(const PreparedStatement& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  columns_.MergeFrom(from.columns_);
+  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    if (from.has_server_handle()) {
+      mutable_server_handle()->::exec::user::PreparedStatementHandle::MergeFrom(from.server_handle());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void PreparedStatement::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void PreparedStatement::CopyFrom(const PreparedStatement& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool PreparedStatement::IsInitialized() const {
+
+  return true;
+}
+
+void PreparedStatement::Swap(PreparedStatement* other) {
+  if (other != this) {
+    columns_.Swap(&other->columns_);
+    std::swap(server_handle_, other->server_handle_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata PreparedStatement::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = PreparedStatement_descriptor_;
+  metadata.reflection = PreparedStatement_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int CreatePreparedStatementResp::kStatusFieldNumber;
+const int CreatePreparedStatementResp::kPreparedStatementFieldNumber;
+const int CreatePreparedStatementResp::kErrorFieldNumber;
+#endif  // !_MSC_VER
+
+CreatePreparedStatementResp::CreatePreparedStatementResp()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void CreatePreparedStatementResp::InitAsDefaultInstance() {
+  prepared_statement_ = const_cast< ::exec::user::PreparedStatement*>(&::exec::user::PreparedStatement::default_instance());
+  error_ = const_cast< ::exec::shared::DrillPBError*>(&::exec::shared::DrillPBError::default_instance());
+}
+
+CreatePreparedStatementResp::CreatePreparedStatementResp(const CreatePreparedStatementResp& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void CreatePreparedStatementResp::SharedCtor() {
+  _cached_size_ = 0;
+  status_ = 0;
+  prepared_statement_ = NULL;
+  error_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+CreatePreparedStatementResp::~CreatePreparedStatementResp() {
+  SharedDtor();
+}
+
+void CreatePreparedStatementResp::SharedDtor() {
+  if (this != default_instance_) {
+    delete prepared_statement_;
+    delete error_;
+  }
+}
+
+void CreatePreparedStatementResp::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* CreatePreparedStatementResp::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return CreatePreparedStatementResp_descriptor_;
+}
+
+const CreatePreparedStatementResp& CreatePreparedStatementResp::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_User_2eproto();
+  return *default_instance_;
+}
+
+CreatePreparedStatementResp* CreatePreparedStatementResp::default_instance_ = NULL;
+
+CreatePreparedStatementResp* CreatePreparedStatementResp::New() const {
+  return new CreatePreparedStatementResp;
+}
+
+void CreatePreparedStatementResp::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    status_ = 0;
+    if (has_prepared_statement()) {
+      if (prepared_statement_ != NULL) prepared_statement_->::exec::user::PreparedStatement::Clear();
+    }
+    if (has_error()) {
+      if (error_ != NULL) error_->::exec::shared::DrillPBError::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool CreatePreparedStatementResp::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .exec.user.RequestStatus status = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::exec::user::RequestStatus_IsValid(value)) {
+            set_status(static_cast< ::exec::user::RequestStatus >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(1, value);
+          }
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(18)) goto parse_prepared_statement;
+        break;
+      }
+
+      // optional .exec.user.PreparedStatement prepared_statement = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_prepared_statement:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_prepared_statement()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(26)) goto parse_error;
+        break;
+      }
+
+      // optional .exec.shared.DrillPBError error = 3;
+      case 3: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_error:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_error()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void CreatePreparedStatementResp::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // optional .exec.user.RequestStatus status = 1;
+  if (has_status()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      1, this->status(), output);
+  }
+
+  // optional .exec.user.PreparedStatement prepared_statement = 2;
+  if (has_prepared_statement()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->prepared_statement(), output);
+  }
+
+  // optional .exec.shared.DrillPBError error = 3;
+  if (has_error()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->error(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* CreatePreparedStatementResp::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // optional .exec.user.RequestStatus status = 1;
+  if (has_status()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      1, this->status(), target);
+  }
+
+  // optional .exec.user.PreparedStatement prepared_statement = 2;
+  if (has_prepared_statement()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->prepared_statement(), target);
+  }
+
+  // optional .exec.shared.DrillPBError error = 3;
+  if (has_error()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->error(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int CreatePreparedStatementResp::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .exec.user.RequestStatus status = 1;
+    if (has_status()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->status());
+    }
+
+    // optional .exec.user.PreparedStatement prepared_statement = 2;
+    if (has_prepared_statement()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->prepared_statement());
+    }
+
+    // optional .exec.shared.DrillPBError error = 3;
+    if (has_error()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->error());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void CreatePreparedStatementResp::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const CreatePreparedStatementResp* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const CreatePreparedStatementResp*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void CreatePreparedStatementResp::MergeFrom(const CreatePreparedStatementResp& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_status()) {
+      set_status(from.status());
+    }
+    if (from.has_prepared_statement()) {
+      mutable_prepared_statement()->::exec::user::PreparedStatement::MergeFrom(from.prepared_statement());
+    }
+    if (from.has_error()) {
+      mutable_error()->::exec::shared::DrillPBError::MergeFrom(from.error());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void CreatePreparedStatementResp::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void CreatePreparedStatementResp::CopyFrom(const CreatePreparedStatementResp& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool CreatePreparedStatementResp::IsInitialized() const {
+
+  return true;
+}
+
+void CreatePreparedStatementResp::Swap(CreatePreparedStatementResp* other) {
+  if (other != this) {
+    std::swap(status_, other->status_);
+    std::swap(prepared_statement_, other->prepared_statement_);
+    std::swap(error_, other->error_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata CreatePreparedStatementResp::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = CreatePreparedStatementResp_descriptor_;
+  metadata.reflection = CreatePreparedStatementResp_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int RunQuery::kResultsModeFieldNumber;
+const int RunQuery::kTypeFieldNumber;
+const int RunQuery::kPlanFieldNumber;
+const int RunQuery::kFragmentsFieldNumber;
+const int RunQuery::kPreparedStatementHandleFieldNumber;
+#endif  // !_MSC_VER
+
+RunQuery::RunQuery()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void RunQuery::InitAsDefaultInstance() {
+  prepared_statement_handle_ = const_cast< ::exec::user::PreparedStatementHandle*>(&::exec::user::PreparedStatementHandle::default_instance());
+}
+
+RunQuery::RunQuery(const RunQuery& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void RunQuery::SharedCtor() {
+  _cached_size_ = 0;
+  results_mode_ = 1;
+  type_ = 1;
+  plan_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  prepared_statement_handle_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+RunQuery::~RunQuery() {
+  SharedDtor();
+}
+
+void RunQuery::SharedDtor() {
+  if (plan_ != &::google::protobuf::internal::kEmptyString) {
+    delete plan_;
+  }
+  if (this != default_instance_) {
+    delete prepared_statement_handle_;
+  }
+}
+
+void RunQuery::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* RunQuery::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return RunQuery_descriptor_;
+}
+
+const RunQuery& RunQuery::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_User_2eproto();
+  return *default_instance_;
+}
+
+RunQuery* RunQuery::default_instance_ = NULL;
+
+RunQuery* RunQuery::New() const {
+  return new RunQuery;
+}
+
+void RunQuery::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    results_mode_ = 1;
+    type_ = 1;
+    if (has_plan()) {
+      if (plan_ != &::google::protobuf::internal::kEmptyString) {
+        plan_->clear();
+      }
+    }
+    if (has_prepared_statement_handle()) {
+      if (prepared_statement_handle_ != NULL) prepared_statement_handle_->::exec::user::PreparedStatementHandle::Clear();
+    }
+  }
+  fragments_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool RunQuery::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .exec.user.QueryResultsMode results_mode = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::exec::user::QueryResultsMode_IsValid(value)) {
+            set_results_mode(static_cast< ::exec::user::QueryResultsMode >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(1, value);
+          }
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(16)) goto parse_type;
+        break;
+      }
+
+      // optional .exec.shared.QueryType type = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_type:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::exec::shared::QueryType_IsValid(value)) {
+            set_type(static_cast< ::exec::shared::QueryType >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(2, value);
+          }
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(26)) goto parse_plan;
+        break;
+      }
+
+      // optional string plan = 3;
+      case 3: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_plan:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_plan()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->plan().data(), this->plan().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(34)) goto parse_fragments;
+        break;
+      }
+
+      // repeated .exec.bit.control.PlanFragment fragments = 4;
+      case 4: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_fragments:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_fragments()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(34)) goto parse_fragments;
+        if (input->ExpectTag(42)) goto parse_prepared_statement_handle;
+        break;
+      }
+
+      // optional .exec.user.PreparedStatementHandle prepared_statement_handle = 5;
+      case 5: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_prepared_statement_handle:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_prepared_statement_handle()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void RunQuery::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // optional .exec.user.QueryResultsMode results_mode = 1;
+  if (has_results_mode()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      1, this->results_mode(), output);
+  }
+
+  // optional .exec.shared.QueryType type = 2;
+  if (has_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      2, this->type(), output);
+  }
+
+  // optional string plan = 3;
+  if (has_plan()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->plan().data(), this->plan().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      3, this->plan(), output);
+  }
+
+  // repeated .exec.bit.control.PlanFragment fragments = 4;
+  for (int i = 0; i < this->fragments_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->fragments(i), output);
+  }
+
+  // optional .exec.user.PreparedStatementHandle prepared_statement_handle = 5;
+  if (has_prepared_statement_handle()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->prepared_statement_handle(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* RunQuery::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // optional .exec.user.QueryResultsMode results_mode = 1;
+  if (has_results_mode()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      1, this->results_mode(), target);
+  }
+
+  // optional .exec.shared.QueryType type = 2;
+  if (has_type()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      2, this->type(), target);
+  }
+
+  // optional string plan = 3;
+  if (has_plan()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->plan().data(), this->plan().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        3, this->plan(), target);
+  }
+
+  // repeated .exec.bit.control.PlanFragment fragments = 4;
+  for (int i = 0; i < this->fragments_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->fragments(i), target);
+  }
+
+  // optional .exec.user.PreparedStatementHandle prepared_statement_handle = 5;
+  if (has_prepared_statement_handle()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->prepared_statement_handle(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int RunQuery::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .exec.user.QueryResultsMode results_mode = 1;
+    if (has_results_mode()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->results_mode());
+    }
+
+    // optional .exec.shared.QueryType type = 2;
+    if (has_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
+    }
+
+    // optional string plan = 3;
+    if (has_plan()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->plan());
+    }
+
+    // optional .exec.user.PreparedStatementHandle prepared_statement_handle = 5;
+    if (has_prepared_statement_handle()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->prepared_statement_handle());
+    }
+
+  }
+  // repeated .exec.bit.control.PlanFragment fragments = 4;
+  total_size += 1 * this->fragments_size();
+  for (int i = 0; i < this->fragments_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->fragments(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void RunQuery::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const RunQuery* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const RunQuery*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void RunQuery::MergeFrom(const RunQuery& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  fragments_.MergeFrom(from.fragments_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_results_mode()) {
+      set_results_mode(from.results_mode());
+    }
+    if (from.has_type()) {
+      set_type(from.type());
+    }
+    if (from.has_plan()) {
+      set_plan(from.plan());
+    }
+    if (from.has_prepared_statement_handle()) {
+      mutable_prepared_statement_handle()->::exec::user::PreparedStatementHandle::MergeFrom(from.prepared_statement_handle());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void RunQuery::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void RunQuery::CopyFrom(const RunQuery& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool RunQuery::IsInitialized() const {
+
+  return true;
+}
+
+void RunQuery::Swap(RunQuery* other) {
+  if (other != this) {
+    std::swap(results_mode_, other->results_mode_);
+    std::swap(type_, other->type_);
+    std::swap(plan_, other->plan_);
+    fragments_.Swap(&other->fragments_);
+    std::swap(prepared_statement_handle_, other->prepared_statement_handle_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata RunQuery::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = RunQuery_descriptor_;
+  metadata.reflection = RunQuery_reflection_;
+  return metadata;
+}
+
+
 // @@protoc_insertion_point(namespace_scope)
 
 }  // namespace user
diff --git a/contrib/native/client/src/protobuf/User.pb.h b/contrib/native/client/src/protobuf/User.pb.h
index 8628a5412..162c6e0d6 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,6 +1157,2440 @@ class BitToUserHandshake : public ::google::protobuf::Message {
   void InitAsDefaultInstance();
   static BitToUserHandshake* default_instance_;
 };
+// -------------------------------------------------------------------
+
+class LikeFilter : public ::google::protobuf::Message {
+ public:
+  LikeFilter();
+  virtual ~LikeFilter();
+
+  LikeFilter(const LikeFilter& from);
+
+  inline LikeFilter& operator=(const LikeFilter& 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 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=(const ResultColumnMetadata& 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 ResultColumnMetadata& default_instance();
+
+  void Swap(ResultColumnMetadata* other);
+
+  // implements Message ----------------------------------------------
+
+  ResultColumnMetadata* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ResultColumnMetadata& from);
+  void MergeFrom(const ResultColumnMetadata& 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 string label = 5;
+  inline bool has_label() const;
+  inline void clear_label();
+  static const int kLabelFieldNumber = 5;
+  inline const ::std::string& label() const;
+  inline void set_label(const ::std::string& value);
+  inline void set_label(const char* value);
+  inline void set_label(const char* value, size_t size);
+  inline ::std::string* mutable_label();
+  inline ::std::string* release_label();
+  inline void set_allocated_label(::std::string* label);
+
+  // optional string data_type = 6;
+  inline bool has_data_type() const;
+  inline void clear_data_type();
+  static const int kDataTypeFieldNumber = 6;
+  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 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 int32 precision = 8;
+  inline bool has_precision() const;
+  inline void clear_precision();
+  static const int kPrecisionFieldNumber = 8;
+  inline ::google::protobuf::int32 precision() const;
+  inline void set_precision(::google::protobuf::int32 value);
+
+  // optional int32 scale = 9;
+  inline bool has_scale() const;
+  inline void clear_scale();
+  static const int kScaleFieldNumber = 9;
+  inline ::google::protobuf::int32 scale() const;
+  inline void set_scale(::google::protobuf::int32 value);
+
+  // optional bool signed = 10;
+  inline bool has_signed_() const;
+  inline void clear_signed_();
+  static const int kSignedFieldNumber = 10;
+  inline bool signed_() const;
+  inline void set_signed_(bool value);
+
+  // optional int32 display_size = 11;
+  inline bool has_display_size() const;
+  inline void clear_display_size();
+  static const int kDisplaySizeFieldNumber = 11;
+  inline ::google::protobuf::int32 display_size() const;
+  inline void set_display_size(::google::protobuf::int32 value);
+
+  // optional bool is_aliased = 12;
+  inline bool has_is_aliased() const;
+  inline void clear_is_aliased();
+  static const int kIsAliasedFieldNumber = 12;
+  inline bool is_aliased() const;
+  inline void set_is_aliased(bool value);
+
+  // optional .exec.user.ColumnSearchability searchability = 13;
+  inline bool has_searchability() const;
+  inline void clear_searchability();
+  static const int kSearchabilityFieldNumber = 13;
+  inline ::exec::user::ColumnSearchability searchability() const;
+  inline void set_searchability(::exec::user::ColumnSearchability value);
+
+  // optional .exec.user.ColumnUpdatability updatability = 14;
+  inline bool has_updatability() const;
+  inline void clear_updatability();
+  static const int kUpdatabilityFieldNumber = 14;
+  inline ::exec::user::ColumnUpdatability updatability() const;
+  inline void set_updatability(::exec::user::ColumnUpdatability value);
+
+  // optional bool auto_increment = 15;
+  inline bool has_auto_increment() const;
+  inline void clear_auto_increment();
+  static const int kAutoIncrementFieldNumber = 15;
+  inline bool auto_increment() const;
+  inline void set_auto_increment(bool value);
+
+  // optional bool case_sensitivity = 16;
+  inline bool has_case_sensitivity() const;
+  inline void clear_case_sensitivity();
+  static const int kCaseSensitivityFieldNumber = 16;
+  inline bool case_sensitivity() const;
+  inline void set_case_sensitivity(bool value);
+
+  // optional bool sortable = 17;
+  inline bool has_sortable() const;
+  inline void clear_sortable();
+  static const int kSortableFieldNumber = 17;
+  inline bool sortable() const;
+  inline void set_sortable(bool value);
+
+  // optional string class_name = 18;
+  inline bool has_class_name() const;
+  inline void clear_class_name();
+  static const int kClassNameFieldNumber = 18;
+  inline const ::std::string& class_name() const;
+  inline void set_class_name(const ::std::string& value);
+  inline void set_class_name(const char* value);
+  inline void set_class_name(const char* value, size_t size);
+  inline ::std::string* mutable_class_name();
+  inline ::std::string* release_class_name();
+  inline void set_allocated_class_name(::std::string* class_name);
+
+  // optional bool is_currency = 20;
+  inline bool has_is_currency() const;
+  inline void clear_is_currency();
+  static const int kIsCurrencyFieldNumber = 20;
+  inline bool is_currency() const;
+  inline void set_is_currency(bool value);
+
+  // @@protoc_insertion_point(class_scope:exec.user.ResultColumnMetadata)
+ 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_label();
+  inline void clear_has_label();
+  inline void set_has_data_type();
+  inline void clear_has_data_type();
+  inline void set_has_is_nullable();
+  inline void clear_has_is_nullable();
+  inline void set_has_precision();
+  inline void clear_has_precision();
+  inline void set_has_scale();
+  inline void clear_has_scale();
+  inline void set_has_signed_();
+  inline void clear_has_signed_();
+  inline void set_has_display_size();
+  inline void clear_has_display_size();
+  inline void set_has_is_aliased();
+  inline void clear_has_is_aliased();
+  inline void set_has_searchability();
+  inline void clear_has_searchability();
+  inline void set_has_updatability();
+  inline void clear_has_updatability();
+  inline void set_has_auto_increment();
+  inline void clear_has_auto_increment();
+  inline void set_has_case_sensitivity();
+  inline void clear_has_case_sensitivity();
+  inline void set_has_sortable();
+  inline void clear_has_sortable();
+  inline void set_has_class_name();
+  inline void clear_has_class_name();
+  inline void set_has_is_currency();
+  inline void clear_has_is_currency();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::std::string* catalog_name_;
+  ::std::string* schema_name_;
+  ::std::string* table_name_;
+  ::std::string* column_name_;
+  ::std::string* label_;
+  ::std::string* data_type_;
+  ::google::protobuf::int32 precision_;
+  ::google::protobuf::int32 scale_;
+  ::google::protobuf::int32 display_size_;
+  bool is_nullable_;
+  bool signed__;
+  bool is_aliased_;
+  bool auto_increment_;
+  int searchability_;
+  int updatability_;
+  ::std::string* class_name_;
+  bool case_sensitivity_;
+  bool sortable_;
+  bool is_currency_;
+
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(19 + 31) / 32];
+
+  friend void  protobuf_AddDesc_User_2eproto();
+  friend void protobuf_AssignDesc_User_2eproto();
+  friend void protobuf_ShutdownFile_User_2eproto();
+
+  void InitAsDefaultInstance();
+  static ResultColumnMetadata* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class PreparedStatementHandle : public ::google::protobuf::Message {
+ public:
+  PreparedStatementHandle();
+  virtual ~PreparedStatementHandle();
+
+  PreparedStatementHandle(const PreparedStatementHandle& from);
+
+  inline PreparedStatementHandle& operator=(const PreparedStatementHandle& 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 PreparedStatementHandle& default_instance();
+
+  void Swap(PreparedStatementHandle* other);
+
+  // implements Message ----------------------------------------------
+
+  PreparedStatementHandle* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const PreparedStatementHandle& from);
+  void MergeFrom(const PreparedStatementHandle& 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 bytes server_info = 1;
+  inline bool has_server_info() const;
+  inline void clear_server_info();
+  static const int kServerInfoFieldNumber = 1;
+  inline const ::std::string& server_info() const;
+  inline void set_server_info(const ::std::string& value);
+  inline void set_server_info(const char* value);
+  inline void set_server_info(const void* value, size_t size);
+  inline ::std::string* mutable_server_info();
+  inline ::std::string* release_server_info();
+  inline void set_allocated_server_info(::std::string* server_info);
+
+  // @@protoc_insertion_point(class_scope:exec.user.PreparedStatementHandle)
+ private:
+  inline void set_has_server_info();
+  inline void clear_has_server_info();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::std::string* server_info_;
+
+  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 PreparedStatementHandle* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class PreparedStatement : public ::google::protobuf::Message {
+ public:
+  PreparedStatement();
+  virtual ~PreparedStatement();
+
+  PreparedStatement(const PreparedStatement& from);
+
+  inline PreparedStatement& operator=(const PreparedStatement& 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 PreparedStatement& default_instance();
+
+  void Swap(PreparedStatement* other);
+
+  // implements Message ----------------------------------------------
+
+  PreparedStatement* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const PreparedStatement& from);
+  void MergeFrom(const PreparedStatement& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .exec.user.ResultColumnMetadata columns = 1;
+  inline int columns_size() const;
+  inline void clear_columns();
+  static const int kColumnsFieldNumber = 1;
+  inline const ::exec::user::ResultColumnMetadata& columns(int index) const;
+  inline ::exec::user::ResultColumnMetadata* mutable_columns(int index);
+  inline ::exec::user::ResultColumnMetadata* add_columns();
+  inline const ::google::protobuf::RepeatedPtrField< ::exec::user::ResultColumnMetadata >&
+      columns() const;
+  inline ::google::protobuf::RepeatedPtrField< ::exec::user::ResultColumnMetadata >*
+      mutable_columns();
+
+  // optional .exec.user.PreparedStatementHandle server_handle = 2;
+  inline bool has_server_handle() const;
+  inline void clear_server_handle();
+  static const int kServerHandleFieldNumber = 2;
+  inline const ::exec::user::PreparedStatementHandle& server_handle() const;
+  inline ::exec::user::PreparedStatementHandle* mutable_server_handle();
+  inline ::exec::user::PreparedStatementHandle* release_server_handle();
+  inline void set_allocated_server_handle(::exec::user::PreparedStatementHandle* server_handle);
+
+  // @@protoc_insertion_point(class_scope:exec.user.PreparedStatement)
+ private:
+  inline void set_has_server_handle();
+  inline void clear_has_server_handle();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::RepeatedPtrField< ::exec::user::ResultColumnMetadata > columns_;
+  ::exec::user::PreparedStatementHandle* server_handle_;
+
+  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 PreparedStatement* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class CreatePreparedStatementResp : public ::google::protobuf::Message {
+ public:
+  CreatePreparedStatementResp();
+  virtual ~CreatePreparedStatementResp();
+
+  CreatePreparedStatementResp(const CreatePreparedStatementResp& from);
+
+  inline CreatePreparedStatementResp& operator=(const CreatePreparedStatementResp& 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 CreatePreparedStatementResp& default_instance();
+
+  void Swap(CreatePreparedStatementResp* other);
+
+  // implements Message ----------------------------------------------
+
+  CreatePreparedStatementResp* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const CreatePreparedStatementResp& from);
+  void MergeFrom(const CreatePreparedStatementResp& 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.PreparedStatement prepared_statement = 2;
+  inline bool has_prepared_statement() const;
+  inline void clear_prepared_statement();
+  static const int kPreparedStatementFieldNumber = 2;
+  inline const ::exec::user::PreparedStatement& prepared_statement() const;
+  inline ::exec::user::PreparedStatement* mutable_prepared_statement();
+  inline ::exec::user::PreparedStatement* release_prepared_statement();
+  inline void set_allocated_prepared_statement(::exec::user::PreparedStatement* prepared_statement);
+
+  // 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.CreatePreparedStatementResp)
+ private:
+  inline void set_has_status();
+  inline void clear_has_status();
+  inline void set_has_prepared_statement();
+  inline void clear_has_prepared_statement();
+  inline void set_has_error();
+  inline void clear_has_error();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::exec::user::PreparedStatement* prepared_statement_;
+  ::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 CreatePreparedStatementResp* 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_;
+};
 // ===================================================================
 
 
@@ -946,6 +3769,286 @@ UserProperties::mutable_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);
+  }
+}
+
+// -------------------------------------------------------------------
+
 // UserToBitHandshake
 
 // optional .exec.shared.RpcChannel channel = 1 [default = USER];
@@ -1135,6 +4238,44 @@ inline void UserToBitHandshake::set_support_timeout(bool value) {
   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();
+  }
+}
+
 // -------------------------------------------------------------------
 
 // RequestResults
@@ -1201,121 +4342,248 @@ inline void RequestResults::set_maximum_responses(::google::protobuf::int32 valu
 
 // -------------------------------------------------------------------
 
-// RunQuery
+// GetQueryPlanFragments
 
-// optional .exec.user.QueryResultsMode results_mode = 1;
-inline bool RunQuery::has_results_mode() const {
+// required string query = 1;
+inline bool GetQueryPlanFragments::has_query() const {
   return (_has_bits_[0] & 0x00000001u) != 0;
 }
-inline void RunQuery::set_has_results_mode() {
+inline void GetQueryPlanFragments::set_has_query() {
   _has_bits_[0] |= 0x00000001u;
 }
-inline void RunQuery::clear_has_results_mode() {
+inline void GetQueryPlanFragments::clear_has_query() {
   _has_bits_[0] &= ~0x00000001u;
 }
-inline void RunQuery::clear_results_mode() {
-  results_mode_ = 1;
-  clear_has_results_mode();
+inline void GetQueryPlanFragments::clear_query() {
+  if (query_ != &::google::protobuf::internal::kEmptyString) {
+    query_->clear();
+  }
+  clear_has_query();
 }
-inline ::exec::user::QueryResultsMode RunQuery::results_mode() const {
-  return static_cast< ::exec::user::QueryResultsMode >(results_mode_);
+inline const ::std::string& GetQueryPlanFragments::query() const {
+  return *query_;
 }
-inline void RunQuery::set_results_mode(::exec::user::QueryResultsMode value) {
-  assert(::exec::user::QueryResultsMode_IsValid(value));
-  set_has_results_mode();
-  results_mode_ = value;
+inline void GetQueryPlanFragments::set_query(const ::std::string& value) {
+  set_has_query();
+  if (query_ == &::google::protobuf::internal::kEmptyString) {
+    query_ = new ::std::string;
+  }
+  query_->assign(value);
+}
+inline void GetQueryPlanFragments::set_query(const char* value) {
+  set_has_query();
+  if (query_ == &::google::protobuf::internal::kEmptyString) {
+    query_ = new ::std::string;
+  }
+  query_->assign(value);
+}
+inline void GetQueryPlanFragments::set_query(const char* value, size_t size) {
+  set_has_query();
+  if (query_ == &::google::protobuf::internal::kEmptyString) {
+    query_ = new ::std::string;
+  }
+  query_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* GetQueryPlanFragments::mutable_query() {
+  set_has_query();
+  if (query_ == &::google::protobuf::internal::kEmptyString) {
+    query_ = new ::std::string;
+  }
+  return query_;
+}
+inline ::std::string* GetQueryPlanFragments::release_query() {
+  clear_has_query();
+  if (query_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = query_;
+    query_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void GetQueryPlanFragments::set_allocated_query(::std::string* query) {
+  if (query_ != &::google::protobuf::internal::kEmptyString) {
+    delete query_;
+  }
+  if (query) {
+    set_has_query();
+    query_ = query;
+  } else {
+    clear_has_query();
+    query_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
 }
 
 // optional .exec.shared.QueryType type = 2;
-inline bool RunQuery::has_type() const {
+inline bool GetQueryPlanFragments::has_type() const {
   return (_has_bits_[0] & 0x00000002u) != 0;
 }
-inline void RunQuery::set_has_type() {
+inline void GetQueryPlanFragments::set_has_type() {
   _has_bits_[0] |= 0x00000002u;
 }
-inline void RunQuery::clear_has_type() {
+inline void GetQueryPlanFragments::clear_has_type() {
   _has_bits_[0] &= ~0x00000002u;
 }
-inline void RunQuery::clear_type() {
+inline void GetQueryPlanFragments::clear_type() {
   type_ = 1;
   clear_has_type();
 }
-inline ::exec::shared::QueryType RunQuery::type() const {
+inline ::exec::shared::QueryType GetQueryPlanFragments::type() const {
   return static_cast< ::exec::shared::QueryType >(type_);
 }
-inline void RunQuery::set_type(::exec::shared::QueryType value) {
+inline void GetQueryPlanFragments::set_type(::exec::shared::QueryType value) {
   assert(::exec::shared::QueryType_IsValid(value));
   set_has_type();
   type_ = value;
 }
 
-// optional string plan = 3;
-inline bool RunQuery::has_plan() const {
+// optional bool split_plan = 3 [default = false];
+inline bool GetQueryPlanFragments::has_split_plan() const {
   return (_has_bits_[0] & 0x00000004u) != 0;
 }
-inline void RunQuery::set_has_plan() {
+inline void GetQueryPlanFragments::set_has_split_plan() {
   _has_bits_[0] |= 0x00000004u;
 }
-inline void RunQuery::clear_has_plan() {
+inline void GetQueryPlanFragments::clear_has_split_plan() {
   _has_bits_[0] &= ~0x00000004u;
 }
-inline void RunQuery::clear_plan() {
-  if (plan_ != &::google::protobuf::internal::kEmptyString) {
-    plan_->clear();
-  }
-  clear_has_plan();
+inline void GetQueryPlanFragments::clear_split_plan() {
+  split_plan_ = false;
+  clear_has_split_plan();
 }
-inline const ::std::string& RunQuery::plan() const {
-  return *plan_;
+inline bool GetQueryPlanFragments::split_plan() const {
+  return split_plan_;
 }
-inline void RunQuery::set_plan(const ::std::string& value) {
-  set_has_plan();
-  if (plan_ == &::google::protobuf::internal::kEmptyString) {
-    plan_ = new ::std::string;
-  }
-  plan_->assign(value);
+inline void GetQueryPlanFragments::set_split_plan(bool value) {
+  set_has_split_plan();
+  split_plan_ = value;
 }
-inline void RunQuery::set_plan(const char* value) {
-  set_has_plan();
-  if (plan_ == &::google::protobuf::internal::kEmptyString) {
-    plan_ = new ::std::string;
-  }
-  plan_->assign(value);
+
+// -------------------------------------------------------------------
+
+// QueryPlanFragments
+
+// required .exec.shared.QueryResult.QueryState status = 1;
+inline bool QueryPlanFragments::has_status() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
 }
-inline void RunQuery::set_plan(const char* value, size_t size) {
-  set_has_plan();
-  if (plan_ == &::google::protobuf::internal::kEmptyString) {
-    plan_ = new ::std::string;
-  }
-  plan_->assign(reinterpret_cast<const char*>(value), size);
+inline void QueryPlanFragments::set_has_status() {
+  _has_bits_[0] |= 0x00000001u;
 }
-inline ::std::string* RunQuery::mutable_plan() {
-  set_has_plan();
-  if (plan_ == &::google::protobuf::internal::kEmptyString) {
-    plan_ = new ::std::string;
-  }
-  return plan_;
+inline void QueryPlanFragments::clear_has_status() {
+  _has_bits_[0] &= ~0x00000001u;
 }
-inline ::std::string* RunQuery::release_plan() {
-  clear_has_plan();
-  if (plan_ == &::google::protobuf::internal::kEmptyString) {
-    return NULL;
+inline void QueryPlanFragments::clear_status() {
+  status_ = 0;
+  clear_has_status();
+}
+inline ::exec::shared::QueryResult_QueryState QueryPlanFragments::status() const {
+  return static_cast< ::exec::shared::QueryResult_QueryState >(status_);
+}
+inline void QueryPlanFragments::set_status(::exec::shared::QueryResult_QueryState value) {
+  assert(::exec::shared::QueryResult_QueryState_IsValid(value));
+  set_has_status();
+  status_ = value;
+}
+
+// optional .exec.shared.QueryId query_id = 2;
+inline bool QueryPlanFragments::has_query_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void QueryPlanFragments::set_has_query_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void QueryPlanFragments::clear_has_query_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void QueryPlanFragments::clear_query_id() {
+  if (query_id_ != NULL) query_id_->::exec::shared::QueryId::Clear();
+  clear_has_query_id();
+}
+inline const ::exec::shared::QueryId& QueryPlanFragments::query_id() const {
+  return query_id_ != NULL ? *query_id_ : *default_instance_->query_id_;
+}
+inline ::exec::shared::QueryId* QueryPlanFragments::mutable_query_id() {
+  set_has_query_id();
+  if (query_id_ == NULL) query_id_ = new ::exec::shared::QueryId;
+  return query_id_;
+}
+inline ::exec::shared::QueryId* QueryPlanFragments::release_query_id() {
+  clear_has_query_id();
+  ::exec::shared::QueryId* temp = query_id_;
+  query_id_ = NULL;
+  return temp;
+}
+inline void QueryPlanFragments::set_allocated_query_id(::exec::shared::QueryId* query_id) {
+  delete query_id_;
+  query_id_ = query_id;
+  if (query_id) {
+    set_has_query_id();
   } else {
-    ::std::string* temp = plan_;
-    plan_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
-    return temp;
+    clear_has_query_id();
   }
 }
-inline void RunQuery::set_allocated_plan(::std::string* plan) {
-  if (plan_ != &::google::protobuf::internal::kEmptyString) {
-    delete plan_;
-  }
-  if (plan) {
-    set_has_plan();
-    plan_ = plan;
+
+// repeated .exec.bit.control.PlanFragment fragments = 3;
+inline int QueryPlanFragments::fragments_size() const {
+  return fragments_.size();
+}
+inline void QueryPlanFragments::clear_fragments() {
+  fragments_.Clear();
+}
+inline const ::exec::bit::control::PlanFragment& QueryPlanFragments::fragments(int index) const {
+  return fragments_.Get(index);
+}
+inline ::exec::bit::control::PlanFragment* QueryPlanFragments::mutable_fragments(int index) {
+  return fragments_.Mutable(index);
+}
+inline ::exec::bit::control::PlanFragment* QueryPlanFragments::add_fragments() {
+  return fragments_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::exec::bit::control::PlanFragment >&
+QueryPlanFragments::fragments() const {
+  return fragments_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::exec::bit::control::PlanFragment >*
+QueryPlanFragments::mutable_fragments() {
+  return &fragments_;
+}
+
+// optional .exec.shared.DrillPBError error = 4;
+inline bool QueryPlanFragments::has_error() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void QueryPlanFragments::set_has_error() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void QueryPlanFragments::clear_has_error() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void QueryPlanFragments::clear_error() {
+  if (error_ != NULL) error_->::exec::shared::DrillPBError::Clear();
+  clear_has_error();
+}
+inline const ::exec::shared::DrillPBError& QueryPlanFragments::error() const {
+  return error_ != NULL ? *error_ : *default_instance_->error_;
+}
+inline ::exec::shared::DrillPBError* QueryPlanFragments::mutable_error() {
+  set_has_error();
+  if (error_ == NULL) error_ = new ::exec::shared::DrillPBError;
+  return error_;
+}
+inline ::exec::shared::DrillPBError* QueryPlanFragments::release_error() {
+  clear_has_error();
+  ::exec::shared::DrillPBError* temp = error_;
+  error_ = NULL;
+  return temp;
+}
+inline void QueryPlanFragments::set_allocated_error(::exec::shared::DrillPBError* error) {
+  delete error_;
+  error_ = error;
+  if (error) {
+    set_has_error();
   } else {
-    clear_has_plan();
-    plan_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    clear_has_error();
   }
 }
 
@@ -1508,6 +4776,3815 @@ inline void BitToUserHandshake::set_allocated_errormessage(::std::string* errorm
   }
 }
 
+// optional .exec.user.RpcEndpointInfos server_infos = 6;
+inline bool BitToUserHandshake::has_server_infos() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void BitToUserHandshake::set_has_server_infos() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void BitToUserHandshake::clear_has_server_infos() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void BitToUserHandshake::clear_server_infos() {
+  if (server_infos_ != NULL) server_infos_->::exec::user::RpcEndpointInfos::Clear();
+  clear_has_server_infos();
+}
+inline const ::exec::user::RpcEndpointInfos& BitToUserHandshake::server_infos() const {
+  return server_infos_ != NULL ? *server_infos_ : *default_instance_->server_infos_;
+}
+inline ::exec::user::RpcEndpointInfos* BitToUserHandshake::mutable_server_infos() {
+  set_has_server_infos();
+  if (server_infos_ == NULL) server_infos_ = new ::exec::user::RpcEndpointInfos;
+  return server_infos_;
+}
+inline ::exec::user::RpcEndpointInfos* BitToUserHandshake::release_server_infos() {
+  clear_has_server_infos();
+  ::exec::user::RpcEndpointInfos* temp = server_infos_;
+  server_infos_ = NULL;
+  return temp;
+}
+inline void BitToUserHandshake::set_allocated_server_infos(::exec::user::RpcEndpointInfos* server_infos) {
+  delete server_infos_;
+  server_infos_ = server_infos;
+  if (server_infos) {
+    set_has_server_infos();
+  } else {
+    clear_has_server_infos();
+  }
+}
+
+// -------------------------------------------------------------------
+
+// LikeFilter
+
+// optional string pattern = 1;
+inline bool LikeFilter::has_pattern() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void LikeFilter::set_has_pattern() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void LikeFilter::clear_has_pattern() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void LikeFilter::clear_pattern() {
+  if (pattern_ != &::google::protobuf::internal::kEmptyString) {
+    pattern_->clear();
+  }
+  clear_has_pattern();
+}
+inline const ::std::string& LikeFilter::pattern() const {
+  return *pattern_;
+}
+inline void LikeFilter::set_pattern(const ::std::string& value) {
+  set_has_pattern();
+  if (pattern_ == &::google::protobuf::internal::kEmptyString) {
+    pattern_ = new ::std::string;
+  }
+  pattern_->assign(value);
+}
+inline void LikeFilter::set_pattern(const char* value) {
+  set_has_pattern();
+  if (pattern_ == &::google::protobuf::internal::kEmptyString) {
+    pattern_ = new ::std::string;
+  }
+  pattern_->assign(value);
+}
+inline void LikeFilter::set_pattern(const char* value, size_t size) {
+  set_has_pattern();
+  if (pattern_ == &::google::protobuf::internal::kEmptyString) {
+    pattern_ = new ::std::string;
+  }
+  pattern_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* LikeFilter::mutable_pattern() {
+  set_has_pattern();
+  if (pattern_ == &::google::protobuf::internal::kEmptyString) {
+    pattern_ = new ::std::string;
+  }
+  return pattern_;
+}
+inline ::std::string* LikeFilter::release_pattern() {
+  clear_has_pattern();
+  if (pattern_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = pattern_;
+    pattern_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void LikeFilter::set_allocated_pattern(::std::string* pattern) {
+  if (pattern_ != &::google::protobuf::internal::kEmptyString) {
+    delete pattern_;
+  }
+  if (pattern) {
+    set_has_pattern();
+    pattern_ = pattern;
+  } else {
+    clear_has_pattern();
+    pattern_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// optional string escape = 2;
+inline bool LikeFilter::has_escape() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void LikeFilter::set_has_escape() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void LikeFilter::clear_has_escape() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void LikeFilter::clear_escape() {
+  if (escape_ != &::google::protobuf::internal::kEmptyString) {
+    escape_->clear();
+  }
+  clear_has_escape();
+}
+inline const ::std::string& LikeFilter::escape() const {
+  return *escape_;
+}
+inline void LikeFilter::set_escape(const ::std::string& value) {
+  set_has_escape();
+  if (escape_ == &::google::protobuf::internal::kEmptyString) {
+    escape_ = new ::std::string;
+  }
+  escape_->assign(value);
+}
+inline void LikeFilter::set_escape(const char* value) {
+  set_has_escape();
+  if (escape_ == &::google::protobuf::internal::kEmptyString) {
+    escape_ = new ::std::string;
+  }
+  escape_->assign(value);
+}
+inline void LikeFilter::set_escape(const char* value, size_t size) {
+  set_has_escape();
+  if (escape_ == &::google::protobuf::internal::kEmptyString) {
+    escape_ = new ::std::string;
+  }
+  escape_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* LikeFilter::mutable_escape() {
+  set_has_escape();
+  if (escape_ == &::google::protobuf::internal::kEmptyString) {
+    escape_ = new ::std::string;
+  }
+  return escape_;
+}
+inline ::std::string* LikeFilter::release_escape() {
+  clear_has_escape();
+  if (escape_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = escape_;
+    escape_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void LikeFilter::set_allocated_escape(::std::string* escape) {
+  if (escape_ != &::google::protobuf::internal::kEmptyString) {
+    delete escape_;
+  }
+  if (escape) {
+    set_has_escape();
+    escape_ = escape;
+  } else {
+    clear_has_escape();
+    escape_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// -------------------------------------------------------------------
+
+// GetCatalogsReq
+
+// optional .exec.user.LikeFilter catalog_name_filter = 1;
+inline bool GetCatalogsReq::has_catalog_name_filter() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetCatalogsReq::set_has_catalog_name_filter() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetCatalogsReq::clear_has_catalog_name_filter() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetCatalogsReq::clear_catalog_name_filter() {
+  if (catalog_name_filter_ != NULL) catalog_name_filter_->::exec::user::LikeFilter::Clear();
+  clear_has_catalog_name_filter();
+}
+inline const ::exec::user::LikeFilter& GetCatalogsReq::catalog_name_filter() const {
+  return catalog_name_filter_ != NULL ? *catalog_name_filter_ : *default_instance_->catalog_name_filter_;
+}
+inline ::exec::user::LikeFilter* GetCatalogsReq::mutable_catalog_name_filter() {
+  set_has_catalog_name_filter();
+  if (catalog_name_filter_ == NULL) catalog_name_filter_ = new ::exec::user::LikeFilter;
+  return catalog_name_filter_;
+}
+inline ::exec::user::LikeFilter* GetCatalogsReq::release_catalog_name_filter() {
+  clear_has_catalog_name_filter();
+  ::exec::user::LikeFilter* temp = catalog_name_filter_;
+  catalog_name_filter_ = NULL;
+  return temp;
+}
+inline void GetCatalogsReq::set_allocated_catalog_name_filter(::exec::user::LikeFilter* catalog_name_filter) {
+  delete catalog_name_filter_;
+  catalog_name_filter_ = catalog_name_filter;
+  if (catalog_name_filter) {
+    set_has_catalog_name_filter();
+  } else {
+    clear_has_catalog_name_filter();
+  }
+}
+
+// -------------------------------------------------------------------
+
+// CatalogMetadata
+
+// optional string catalog_name = 1;
+inline bool CatalogMetadata::has_catalog_name() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void CatalogMetadata::set_has_catalog_name() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void CatalogMetadata::clear_has_catalog_name() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void CatalogMetadata::clear_catalog_name() {
+  if (catalog_name_ != &::google::protobuf::internal::kEmptyString) {
+    catalog_name_->clear();
+  }
+  clear_has_catalog_name();
+}
+inline const ::std::string& CatalogMetadata::catalog_name() const {
+  return *catalog_name_;
+}
+inline void CatalogMetadata::set_catalog_name(const ::std::string& value) {
+  set_has_catalog_name();
+  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
+    catalog_name_ = new ::std::string;
+  }
+  catalog_name_->assign(value);
+}
+inline void CatalogMetadata::set_catalog_name(const char* value) {
+  set_has_catalog_name();
+  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
+    catalog_name_ = new ::std::string;
+  }
+  catalog_name_->assign(value);
+}
+inline void CatalogMetadata::set_catalog_name(const char* value, size_t size) {
+  set_has_catalog_name();
+  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
+    catalog_name_ = new ::std::string;
+  }
+  catalog_name_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* CatalogMetadata::mutable_catalog_name() {
+  set_has_catalog_name();
+  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
+    catalog_name_ = new ::std::string;
+  }
+  return catalog_name_;
+}
+inline ::std::string* CatalogMetadata::release_catalog_name() {
+  clear_has_catalog_name();
+  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = catalog_name_;
+    catalog_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void CatalogMetadata::set_allocated_catalog_name(::std::string* catalog_name) {
+  if (catalog_name_ != &::google::protobuf::internal::kEmptyString) {
+    delete catalog_name_;
+  }
+  if (catalog_name) {
+    set_has_catalog_name();
+    catalog_name_ = catalog_name;
+  } else {
+    clear_has_catalog_name();
+    catalog_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// optional string description = 2;
+inline bool CatalogMetadata::has_description() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void CatalogMetadata::set_has_description() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void CatalogMetadata::clear_has_description() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void CatalogMetadata::clear_description() {
+  if (description_ != &::google::protobuf::internal::kEmptyString) {
+    description_->clear();
+  }
+  clear_has_description();
+}
+inline const ::std::string& CatalogMetadata::description() const {
+  return *description_;
+}
+inline void CatalogMetadata::set_description(const ::std::string& value) {
+  set_has_description();
+  if (description_ == &::google::protobuf::internal::kEmptyString) {
+    description_ = new ::std::string;
+  }
+  description_->assign(value);
+}
+inline void CatalogMetadata::set_description(const char* value) {
+  set_has_description();
+  if (description_ == &::google::protobuf::internal::kEmptyString) {
+    description_ = new ::std::string;
+  }
+  description_->assign(value);
+}
+inline void CatalogMetadata::set_description(const char* value, size_t size) {
+  set_has_description();
+  if (description_ == &::google::protobuf::internal::kEmptyString) {
+    description_ = new ::std::string;
+  }
+  description_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* CatalogMetadata::mutable_description() {
+  set_has_description();
+  if (description_ == &::google::protobuf::internal::kEmptyString) {
+    description_ = new ::std::string;
+  }
+  return description_;
+}
+inline ::std::string* CatalogMetadata::release_description() {
+  clear_has_description();
+  if (description_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = description_;
+    description_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void CatalogMetadata::set_allocated_description(::std::string* description) {
+  if (description_ != &::google::protobuf::internal::kEmptyString) {
+    delete description_;
+  }
+  if (description) {
+    set_has_description();
+    description_ = description;
+  } else {
+    clear_has_description();
+    description_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// optional string connect = 3;
+inline bool CatalogMetadata::has_connect() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void CatalogMetadata::set_has_connect() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void CatalogMetadata::clear_has_connect() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void CatalogMetadata::clear_connect() {
+  if (connect_ != &::google::protobuf::internal::kEmptyString) {
+    connect_->clear();
+  }
+  clear_has_connect();
+}
+inline const ::std::string& CatalogMetadata::connect() const {
+  return *connect_;
+}
+inline void CatalogMetadata::set_connect(const ::std::string& value) {
+  set_has_connect();
+  if (connect_ == &::google::protobuf::internal::kEmptyString) {
+    connect_ = new ::std::string;
+  }
+  connect_->assign(value);
+}
+inline void CatalogMetadata::set_connect(const char* value) {
+  set_has_connect();
+  if (connect_ == &::google::protobuf::internal::kEmptyString) {
+    connect_ = new ::std::string;
+  }
+  connect_->assign(value);
+}
+inline void CatalogMetadata::set_connect(const char* value, size_t size) {
+  set_has_connect();
+  if (connect_ == &::google::protobuf::internal::kEmptyString) {
+    connect_ = new ::std::string;
+  }
+  connect_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* CatalogMetadata::mutable_connect() {
+  set_has_connect();
+  if (connect_ == &::google::protobuf::internal::kEmptyString) {
+    connect_ = new ::std::string;
+  }
+  return connect_;
+}
+inline ::std::string* CatalogMetadata::release_connect() {
+  clear_has_connect();
+  if (connect_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = connect_;
+    connect_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void CatalogMetadata::set_allocated_connect(::std::string* connect) {
+  if (connect_ != &::google::protobuf::internal::kEmptyString) {
+    delete connect_;
+  }
+  if (connect) {
+    set_has_connect();
+    connect_ = connect;
+  } else {
+    clear_has_connect();
+    connect_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// -------------------------------------------------------------------
+
+// GetCatalogsResp
+
+// optional .exec.user.RequestStatus status = 1;
+inline bool GetCatalogsResp::has_status() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetCatalogsResp::set_has_status() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetCatalogsResp::clear_has_status() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetCatalogsResp::clear_status() {
+  status_ = 0;
+  clear_has_status();
+}
+inline ::exec::user::RequestStatus GetCatalogsResp::status() const {
+  return static_cast< ::exec::user::RequestStatus >(status_);
+}
+inline void GetCatalogsResp::set_status(::exec::user::RequestStatus value) {
+  assert(::exec::user::RequestStatus_IsValid(value));
+  set_has_status();
+  status_ = value;
+}
+
+// repeated .exec.user.CatalogMetadata catalogs = 2;
+inline int GetCatalogsResp::catalogs_size() const {
+  return catalogs_.size();
+}
+inline void GetCatalogsResp::clear_catalogs() {
+  catalogs_.Clear();
+}
+inline const ::exec::user::CatalogMetadata& GetCatalogsResp::catalogs(int index) const {
+  return catalogs_.Get(index);
+}
+inline ::exec::user::CatalogMetadata* GetCatalogsResp::mutable_catalogs(int index) {
+  return catalogs_.Mutable(index);
+}
+inline ::exec::user::CatalogMetadata* GetCatalogsResp::add_catalogs() {
+  return catalogs_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::exec::user::CatalogMetadata >&
+GetCatalogsResp::catalogs() const {
+  return catalogs_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::exec::user::CatalogMetadata >*
+GetCatalogsResp::mutable_catalogs() {
+  return &catalogs_;
+}
+
+// optional .exec.shared.DrillPBError error = 3;
+inline bool GetCatalogsResp::has_error() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GetCatalogsResp::set_has_error() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GetCatalogsResp::clear_has_error() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GetCatalogsResp::clear_error() {
+  if (error_ != NULL) error_->::exec::shared::DrillPBError::Clear();
+  clear_has_error();
+}
+inline const ::exec::shared::DrillPBError& GetCatalogsResp::error() const {
+  return error_ != NULL ? *error_ : *default_instance_->error_;
+}
+inline ::exec::shared::DrillPBError* GetCatalogsResp::mutable_error() {
+  set_has_error();
+  if (error_ == NULL) error_ = new ::exec::shared::DrillPBError;
+  return error_;
+}
+inline ::exec::shared::DrillPBError* GetCatalogsResp::release_error() {
+  clear_has_error();
+  ::exec::shared::DrillPBError* temp = error_;
+  error_ = NULL;
+  return temp;
+}
+inline void GetCatalogsResp::set_allocated_error(::exec::shared::DrillPBError* error) {
+  delete error_;
+  error_ = error;
+  if (error) {
+    set_has_error();
+  } else {
+    clear_has_error();
+  }
+}
+
+// -------------------------------------------------------------------
+
+// GetSchemasReq
+
+// optional .exec.user.LikeFilter catalog_name_filter = 1;
+inline bool GetSchemasReq::has_catalog_name_filter() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetSchemasReq::set_has_catalog_name_filter() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetSchemasReq::clear_has_catalog_name_filter() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetSchemasReq::clear_catalog_name_filter() {
+  if (catalog_name_filter_ != NULL) catalog_name_filter_->::exec::user::LikeFilter::Clear();
+  clear_has_catalog_name_filter();
+}
+inline const ::exec::user::LikeFilter& GetSchemasReq::catalog_name_filter() const {
+  return catalog_name_filter_ != NULL ? *catalog_name_filter_ : *default_instance_->catalog_name_filter_;
+}
+inline ::exec::user::LikeFilter* GetSchemasReq::mutable_catalog_name_filter() {
+  set_has_catalog_name_filter();
+  if (catalog_name_filter_ == NULL) catalog_name_filter_ = new ::exec::user::LikeFilter;
+  return catalog_name_filter_;
+}
+inline ::exec::user::LikeFilter* GetSchemasReq::release_catalog_name_filter() {
+  clear_has_catalog_name_filter();
+  ::exec::user::LikeFilter* temp = catalog_name_filter_;
+  catalog_name_filter_ = NULL;
+  return temp;
+}
+inline void GetSchemasReq::set_allocated_catalog_name_filter(::exec::user::LikeFilter* catalog_name_filter) {
+  delete catalog_name_filter_;
+  catalog_name_filter_ = catalog_name_filter;
+  if (catalog_name_filter) {
+    set_has_catalog_name_filter();
+  } else {
+    clear_has_catalog_name_filter();
+  }
+}
+
+// optional .exec.user.LikeFilter schema_name_filter = 2;
+inline bool GetSchemasReq::has_schema_name_filter() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GetSchemasReq::set_has_schema_name_filter() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GetSchemasReq::clear_has_schema_name_filter() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GetSchemasReq::clear_schema_name_filter() {
+  if (schema_name_filter_ != NULL) schema_name_filter_->::exec::user::LikeFilter::Clear();
+  clear_has_schema_name_filter();
+}
+inline const ::exec::user::LikeFilter& GetSchemasReq::schema_name_filter() const {
+  return schema_name_filter_ != NULL ? *schema_name_filter_ : *default_instance_->schema_name_filter_;
+}
+inline ::exec::user::LikeFilter* GetSchemasReq::mutable_schema_name_filter() {
+  set_has_schema_name_filter();
+  if (schema_name_filter_ == NULL) schema_name_filter_ = new ::exec::user::LikeFilter;
+  return schema_name_filter_;
+}
+inline ::exec::user::LikeFilter* GetSchemasReq::release_schema_name_filter() {
+  clear_has_schema_name_filter();
+  ::exec::user::LikeFilter* temp = schema_name_filter_;
+  schema_name_filter_ = NULL;
+  return temp;
+}
+inline void GetSchemasReq::set_allocated_schema_name_filter(::exec::user::LikeFilter* schema_name_filter) {
+  delete schema_name_filter_;
+  schema_name_filter_ = schema_name_filter;
+  if (schema_name_filter) {
+    set_has_schema_name_filter();
+  } else {
+    clear_has_schema_name_filter();
+  }
+}
+
+// -------------------------------------------------------------------
+
+// SchemaMetadata
+
+// optional string catalog_name = 1;
+inline bool SchemaMetadata::has_catalog_name() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SchemaMetadata::set_has_catalog_name() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SchemaMetadata::clear_has_catalog_name() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SchemaMetadata::clear_catalog_name() {
+  if (catalog_name_ != &::google::protobuf::internal::kEmptyString) {
+    catalog_name_->clear();
+  }
+  clear_has_catalog_name();
+}
+inline const ::std::string& SchemaMetadata::catalog_name() const {
+  return *catalog_name_;
+}
+inline void SchemaMetadata::set_catalog_name(const ::std::string& value) {
+  set_has_catalog_name();
+  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
+    catalog_name_ = new ::std::string;
+  }
+  catalog_name_->assign(value);
+}
+inline void SchemaMetadata::set_catalog_name(const char* value) {
+  set_has_catalog_name();
+  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
+    catalog_name_ = new ::std::string;
+  }
+  catalog_name_->assign(value);
+}
+inline void SchemaMetadata::set_catalog_name(const char* value, size_t size) {
+  set_has_catalog_name();
+  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
+    catalog_name_ = new ::std::string;
+  }
+  catalog_name_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* SchemaMetadata::mutable_catalog_name() {
+  set_has_catalog_name();
+  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
+    catalog_name_ = new ::std::string;
+  }
+  return catalog_name_;
+}
+inline ::std::string* SchemaMetadata::release_catalog_name() {
+  clear_has_catalog_name();
+  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = catalog_name_;
+    catalog_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void SchemaMetadata::set_allocated_catalog_name(::std::string* catalog_name) {
+  if (catalog_name_ != &::google::protobuf::internal::kEmptyString) {
+    delete catalog_name_;
+  }
+  if (catalog_name) {
+    set_has_catalog_name();
+    catalog_name_ = catalog_name;
+  } else {
+    clear_has_catalog_name();
+    catalog_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// optional string schema_name = 2;
+inline bool SchemaMetadata::has_schema_name() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void SchemaMetadata::set_has_schema_name() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void SchemaMetadata::clear_has_schema_name() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void SchemaMetadata::clear_schema_name() {
+  if (schema_name_ != &::google::protobuf::internal::kEmptyString) {
+    schema_name_->clear();
+  }
+  clear_has_schema_name();
+}
+inline const ::std::string& SchemaMetadata::schema_name() const {
+  return *schema_name_;
+}
+inline void SchemaMetadata::set_schema_name(const ::std::string& value) {
+  set_has_schema_name();
+  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
+    schema_name_ = new ::std::string;
+  }
+  schema_name_->assign(value);
+}
+inline void SchemaMetadata::set_schema_name(const char* value) {
+  set_has_schema_name();
+  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
+    schema_name_ = new ::std::string;
+  }
+  schema_name_->assign(value);
+}
+inline void SchemaMetadata::set_schema_name(const char* value, size_t size) {
+  set_has_schema_name();
+  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
+    schema_name_ = new ::std::string;
+  }
+  schema_name_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* SchemaMetadata::mutable_schema_name() {
+  set_has_schema_name();
+  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
+    schema_name_ = new ::std::string;
+  }
+  return schema_name_;
+}
+inline ::std::string* SchemaMetadata::release_schema_name() {
+  clear_has_schema_name();
+  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = schema_name_;
+    schema_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void SchemaMetadata::set_allocated_schema_name(::std::string* schema_name) {
+  if (schema_name_ != &::google::protobuf::internal::kEmptyString) {
+    delete schema_name_;
+  }
+  if (schema_name) {
+    set_has_schema_name();
+    schema_name_ = schema_name;
+  } else {
+    clear_has_schema_name();
+    schema_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// optional string owner = 3;
+inline bool SchemaMetadata::has_owner() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void SchemaMetadata::set_has_owner() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void SchemaMetadata::clear_has_owner() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void SchemaMetadata::clear_owner() {
+  if (owner_ != &::google::protobuf::internal::kEmptyString) {
+    owner_->clear();
+  }
+  clear_has_owner();
+}
+inline const ::std::string& SchemaMetadata::owner() const {
+  return *owner_;
+}
+inline void SchemaMetadata::set_owner(const ::std::string& value) {
+  set_has_owner();
+  if (owner_ == &::google::protobuf::internal::kEmptyString) {
+    owner_ = new ::std::string;
+  }
+  owner_->assign(value);
+}
+inline void SchemaMetadata::set_owner(const char* value) {
+  set_has_owner();
+  if (owner_ == &::google::protobuf::internal::kEmptyString) {
+    owner_ = new ::std::string;
+  }
+  owner_->assign(value);
+}
+inline void SchemaMetadata::set_owner(const char* value, size_t size) {
+  set_has_owner();
+  if (owner_ == &::google::protobuf::internal::kEmptyString) {
+    owner_ = new ::std::string;
+  }
+  owner_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* SchemaMetadata::mutable_owner() {
+  set_has_owner();
+  if (owner_ == &::google::protobuf::internal::kEmptyString) {
+    owner_ = new ::std::string;
+  }
+  return owner_;
+}
+inline ::std::string* SchemaMetadata::release_owner() {
+  clear_has_owner();
+  if (owner_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = owner_;
+    owner_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void SchemaMetadata::set_allocated_owner(::std::string* owner) {
+  if (owner_ != &::google::protobuf::internal::kEmptyString) {
+    delete owner_;
+  }
+  if (owner) {
+    set_has_owner();
+    owner_ = owner;
+  } else {
+    clear_has_owner();
+    owner_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// optional string type = 4;
+inline bool SchemaMetadata::has_type() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void SchemaMetadata::set_has_type() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void SchemaMetadata::clear_has_type() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void SchemaMetadata::clear_type() {
+  if (type_ != &::google::protobuf::internal::kEmptyString) {
+    type_->clear();
+  }
+  clear_has_type();
+}
+inline const ::std::string& SchemaMetadata::type() const {
+  return *type_;
+}
+inline void SchemaMetadata::set_type(const ::std::string& value) {
+  set_has_type();
+  if (type_ == &::google::protobuf::internal::kEmptyString) {
+    type_ = new ::std::string;
+  }
+  type_->assign(value);
+}
+inline void SchemaMetadata::set_type(const char* value) {
+  set_has_type();
+  if (type_ == &::google::protobuf::internal::kEmptyString) {
+    type_ = new ::std::string;
+  }
+  type_->assign(value);
+}
+inline void SchemaMetadata::set_type(const char* value, size_t size) {
+  set_has_type();
+  if (type_ == &::google::protobuf::internal::kEmptyString) {
+    type_ = new ::std::string;
+  }
+  type_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* SchemaMetadata::mutable_type() {
+  set_has_type();
+  if (type_ == &::google::protobuf::internal::kEmptyString) {
+    type_ = new ::std::string;
+  }
+  return type_;
+}
+inline ::std::string* SchemaMetadata::release_type() {
+  clear_has_type();
+  if (type_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = type_;
+    type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void SchemaMetadata::set_allocated_type(::std::string* type) {
+  if (type_ != &::google::protobuf::internal::kEmptyString) {
+    delete type_;
+  }
+  if (type) {
+    set_has_type();
+    type_ = type;
+  } else {
+    clear_has_type();
+    type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// optional string mutable = 5;
+inline bool SchemaMetadata::has_mutable_() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void SchemaMetadata::set_has_mutable_() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void SchemaMetadata::clear_has_mutable_() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void SchemaMetadata::clear_mutable_() {
+  if (mutable__ != &::google::protobuf::internal::kEmptyString) {
+    mutable__->clear();
+  }
+  clear_has_mutable_();
+}
+inline const ::std::string& SchemaMetadata::mutable_() const {
+  return *mutable__;
+}
+inline void SchemaMetadata::set_mutable_(const ::std::string& value) {
+  set_has_mutable_();
+  if (mutable__ == &::google::protobuf::internal::kEmptyString) {
+    mutable__ = new ::std::string;
+  }
+  mutable__->assign(value);
+}
+inline void SchemaMetadata::set_mutable_(const char* value) {
+  set_has_mutable_();
+  if (mutable__ == &::google::protobuf::internal::kEmptyString) {
+    mutable__ = new ::std::string;
+  }
+  mutable__->assign(value);
+}
+inline void SchemaMetadata::set_mutable_(const char* value, size_t size) {
+  set_has_mutable_();
+  if (mutable__ == &::google::protobuf::internal::kEmptyString) {
+    mutable__ = new ::std::string;
+  }
+  mutable__->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* SchemaMetadata::mutable_mutable_() {
+  set_has_mutable_();
+  if (mutable__ == &::google::protobuf::internal::kEmptyString) {
+    mutable__ = new ::std::string;
+  }
+  return mutable__;
+}
+inline ::std::string* SchemaMetadata::release_mutable_() {
+  clear_has_mutable_();
+  if (mutable__ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = mutable__;
+    mutable__ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void SchemaMetadata::set_allocated_mutable_(::std::string* mutable_) {
+  if (mutable__ != &::google::protobuf::internal::kEmptyString) {
+    delete mutable__;
+  }
+  if (mutable_) {
+    set_has_mutable_();
+    mutable__ = mutable_;
+  } else {
+    clear_has_mutable_();
+    mutable__ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// -------------------------------------------------------------------
+
+// GetSchemasResp
+
+// optional .exec.user.RequestStatus status = 1;
+inline bool GetSchemasResp::has_status() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetSchemasResp::set_has_status() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetSchemasResp::clear_has_status() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetSchemasResp::clear_status() {
+  status_ = 0;
+  clear_has_status();
+}
+inline ::exec::user::RequestStatus GetSchemasResp::status() const {
+  return static_cast< ::exec::user::RequestStatus >(status_);
+}
+inline void GetSchemasResp::set_status(::exec::user::RequestStatus value) {
+  assert(::exec::user::RequestStatus_IsValid(value));
+  set_has_status();
+  status_ = value;
+}
+
+// repeated .exec.user.SchemaMetadata schemas = 2;
+inline int GetSchemasResp::schemas_size() const {
+  return schemas_.size();
+}
+inline void GetSchemasResp::clear_schemas() {
+  schemas_.Clear();
+}
+inline const ::exec::user::SchemaMetadata& GetSchemasResp::schemas(int index) const {
+  return schemas_.Get(index);
+}
+inline ::exec::user::SchemaMetadata* GetSchemasResp::mutable_schemas(int index) {
+  return schemas_.Mutable(index);
+}
+inline ::exec::user::SchemaMetadata* GetSchemasResp::add_schemas() {
+  return schemas_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::exec::user::SchemaMetadata >&
+GetSchemasResp::schemas() const {
+  return schemas_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::exec::user::SchemaMetadata >*
+GetSchemasResp::mutable_schemas() {
+  return &schemas_;
+}
+
+// optional .exec.shared.DrillPBError error = 3;
+inline bool GetSchemasResp::has_error() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GetSchemasResp::set_has_error() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GetSchemasResp::clear_has_error() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GetSchemasResp::clear_error() {
+  if (error_ != NULL) error_->::exec::shared::DrillPBError::Clear();
+  clear_has_error();
+}
+inline const ::exec::shared::DrillPBError& GetSchemasResp::error() const {
+  return error_ != NULL ? *error_ : *default_instance_->error_;
+}
+inline ::exec::shared::DrillPBError* GetSchemasResp::mutable_error() {
+  set_has_error();
+  if (error_ == NULL) error_ = new ::exec::shared::DrillPBError;
+  return error_;
+}
+inline ::exec::shared::DrillPBError* GetSchemasResp::release_error() {
+  clear_has_error();
+  ::exec::shared::DrillPBError* temp = error_;
+  error_ = NULL;
+  return temp;
+}
+inline void GetSchemasResp::set_allocated_error(::exec::shared::DrillPBError* error) {
+  delete error_;
+  error_ = error;
+  if (error) {
+    set_has_error();
+  } else {
+    clear_has_error();
+  }
+}
+
+// -------------------------------------------------------------------
+
+// GetTablesReq
+
+// optional .exec.user.LikeFilter catalog_name_filter = 1;
+inline bool GetTablesReq::has_catalog_name_filter() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetTablesReq::set_has_catalog_name_filter() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetTablesReq::clear_has_catalog_name_filter() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetTablesReq::clear_catalog_name_filter() {
+  if (catalog_name_filter_ != NULL) catalog_name_filter_->::exec::user::LikeFilter::Clear();
+  clear_has_catalog_name_filter();
+}
+inline const ::exec::user::LikeFilter& GetTablesReq::catalog_name_filter() const {
+  return catalog_name_filter_ != NULL ? *catalog_name_filter_ : *default_instance_->catalog_name_filter_;
+}
+inline ::exec::user::LikeFilter* GetTablesReq::mutable_catalog_name_filter() {
+  set_has_catalog_name_filter();
+  if (catalog_name_filter_ == NULL) catalog_name_filter_ = new ::exec::user::LikeFilter;
+  return catalog_name_filter_;
+}
+inline ::exec::user::LikeFilter* GetTablesReq::release_catalog_name_filter() {
+  clear_has_catalog_name_filter();
+  ::exec::user::LikeFilter* temp = catalog_name_filter_;
+  catalog_name_filter_ = NULL;
+  return temp;
+}
+inline void GetTablesReq::set_allocated_catalog_name_filter(::exec::user::LikeFilter* catalog_name_filter) {
+  delete catalog_name_filter_;
+  catalog_name_filter_ = catalog_name_filter;
+  if (catalog_name_filter) {
+    set_has_catalog_name_filter();
+  } else {
+    clear_has_catalog_name_filter();
+  }
+}
+
+// optional .exec.user.LikeFilter schema_name_filter = 2;
+inline bool GetTablesReq::has_schema_name_filter() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GetTablesReq::set_has_schema_name_filter() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GetTablesReq::clear_has_schema_name_filter() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GetTablesReq::clear_schema_name_filter() {
+  if (schema_name_filter_ != NULL) schema_name_filter_->::exec::user::LikeFilter::Clear();
+  clear_has_schema_name_filter();
+}
+inline const ::exec::user::LikeFilter& GetTablesReq::schema_name_filter() const {
+  return schema_name_filter_ != NULL ? *schema_name_filter_ : *default_instance_->schema_name_filter_;
+}
+inline ::exec::user::LikeFilter* GetTablesReq::mutable_schema_name_filter() {
+  set_has_schema_name_filter();
+  if (schema_name_filter_ == NULL) schema_name_filter_ = new ::exec::user::LikeFilter;
+  return schema_name_filter_;
+}
+inline ::exec::user::LikeFilter* GetTablesReq::release_schema_name_filter() {
+  clear_has_schema_name_filter();
+  ::exec::user::LikeFilter* temp = schema_name_filter_;
+  schema_name_filter_ = NULL;
+  return temp;
+}
+inline void GetTablesReq::set_allocated_schema_name_filter(::exec::user::LikeFilter* schema_name_filter) {
+  delete schema_name_filter_;
+  schema_name_filter_ = schema_name_filter;
+  if (schema_name_filter) {
+    set_has_schema_name_filter();
+  } else {
+    clear_has_schema_name_filter();
+  }
+}
+
+// optional .exec.user.LikeFilter table_name_filter = 3;
+inline bool GetTablesReq::has_table_name_filter() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GetTablesReq::set_has_table_name_filter() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GetTablesReq::clear_has_table_name_filter() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GetTablesReq::clear_table_name_filter() {
+  if (table_name_filter_ != NULL) table_name_filter_->::exec::user::LikeFilter::Clear();
+  clear_has_table_name_filter();
+}
+inline const ::exec::user::LikeFilter& GetTablesReq::table_name_filter() const {
+  return table_name_filter_ != NULL ? *table_name_filter_ : *default_instance_->table_name_filter_;
+}
+inline ::exec::user::LikeFilter* GetTablesReq::mutable_table_name_filter() {
+  set_has_table_name_filter();
+  if (table_name_filter_ == NULL) table_name_filter_ = new ::exec::user::LikeFilter;
+  return table_name_filter_;
+}
+inline ::exec::user::LikeFilter* GetTablesReq::release_table_name_filter() {
+  clear_has_table_name_filter();
+  ::exec::user::LikeFilter* temp = table_name_filter_;
+  table_name_filter_ = NULL;
+  return temp;
+}
+inline void GetTablesReq::set_allocated_table_name_filter(::exec::user::LikeFilter* table_name_filter) {
+  delete table_name_filter_;
+  table_name_filter_ = table_name_filter;
+  if (table_name_filter) {
+    set_has_table_name_filter();
+  } else {
+    clear_has_table_name_filter();
+  }
+}
+
+// repeated string table_type_filter = 4;
+inline int GetTablesReq::table_type_filter_size() const {
+  return table_type_filter_.size();
+}
+inline void GetTablesReq::clear_table_type_filter() {
+  table_type_filter_.Clear();
+}
+inline const ::std::string& GetTablesReq::table_type_filter(int index) const {
+  return table_type_filter_.Get(index);
+}
+inline ::std::string* GetTablesReq::mutable_table_type_filter(int index) {
+  return table_type_filter_.Mutable(index);
+}
+inline void GetTablesReq::set_table_type_filter(int index, const ::std::string& value) {
+  table_type_filter_.Mutable(index)->assign(value);
+}
+inline void GetTablesReq::set_table_type_filter(int index, const char* value) {
+  table_type_filter_.Mutable(index)->assign(value);
+}
+inline void GetTablesReq::set_table_type_filter(int index, const char* value, size_t size) {
+  table_type_filter_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* GetTablesReq::add_table_type_filter() {
+  return table_type_filter_.Add();
+}
+inline void GetTablesReq::add_table_type_filter(const ::std::string& value) {
+  table_type_filter_.Add()->assign(value);
+}
+inline void GetTablesReq::add_table_type_filter(const char* value) {
+  table_type_filter_.Add()->assign(value);
+}
+inline void GetTablesReq::add_table_type_filter(const char* value, size_t size) {
+  table_type_filter_.Add()->assign(reinterpret_cast<const char*>(value), size);
+}
+inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
+GetTablesReq::table_type_filter() const {
+  return table_type_filter_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::std::string>*
+GetTablesReq::mutable_table_type_filter() {
+  return &table_type_filter_;
+}
+
+// -------------------------------------------------------------------
+
+// TableMetadata
+
+// optional string catalog_name = 1;
+inline bool TableMetadata::has_catalog_name() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void TableMetadata::set_has_catalog_name() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void TableMetadata::clear_has_catalog_name() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void TableMetadata::clear_catalog_name() {
+  if (catalog_name_ != &::google::protobuf::internal::kEmptyString) {
+    catalog_name_->clear();
+  }
+  clear_has_catalog_name();
+}
+inline const ::std::string& TableMetadata::catalog_name() const {
+  return *catalog_name_;
+}
+inline void TableMetadata::set_catalog_name(const ::std::string& value) {
+  set_has_catalog_name();
+  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
+    catalog_name_ = new ::std::string;
+  }
+  catalog_name_->assign(value);
+}
+inline void TableMetadata::set_catalog_name(const char* value) {
+  set_has_catalog_name();
+  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
+    catalog_name_ = new ::std::string;
+  }
+  catalog_name_->assign(value);
+}
+inline void TableMetadata::set_catalog_name(const char* value, size_t size) {
+  set_has_catalog_name();
+  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
+    catalog_name_ = new ::std::string;
+  }
+  catalog_name_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* TableMetadata::mutable_catalog_name() {
+  set_has_catalog_name();
+  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
+    catalog_name_ = new ::std::string;
+  }
+  return catalog_name_;
+}
+inline ::std::string* TableMetadata::release_catalog_name() {
+  clear_has_catalog_name();
+  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = catalog_name_;
+    catalog_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void TableMetadata::set_allocated_catalog_name(::std::string* catalog_name) {
+  if (catalog_name_ != &::google::protobuf::internal::kEmptyString) {
+    delete catalog_name_;
+  }
+  if (catalog_name) {
+    set_has_catalog_name();
+    catalog_name_ = catalog_name;
+  } else {
+    clear_has_catalog_name();
+    catalog_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// optional string schema_name = 2;
+inline bool TableMetadata::has_schema_name() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void TableMetadata::set_has_schema_name() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void TableMetadata::clear_has_schema_name() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void TableMetadata::clear_schema_name() {
+  if (schema_name_ != &::google::protobuf::internal::kEmptyString) {
+    schema_name_->clear();
+  }
+  clear_has_schema_name();
+}
+inline const ::std::string& TableMetadata::schema_name() const {
+  return *schema_name_;
+}
+inline void TableMetadata::set_schema_name(const ::std::string& value) {
+  set_has_schema_name();
+  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
+    schema_name_ = new ::std::string;
+  }
+  schema_name_->assign(value);
+}
+inline void TableMetadata::set_schema_name(const char* value) {
+  set_has_schema_name();
+  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
+    schema_name_ = new ::std::string;
+  }
+  schema_name_->assign(value);
+}
+inline void TableMetadata::set_schema_name(const char* value, size_t size) {
+  set_has_schema_name();
+  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
+    schema_name_ = new ::std::string;
+  }
+  schema_name_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* TableMetadata::mutable_schema_name() {
+  set_has_schema_name();
+  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
+    schema_name_ = new ::std::string;
+  }
+  return schema_name_;
+}
+inline ::std::string* TableMetadata::release_schema_name() {
+  clear_has_schema_name();
+  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = schema_name_;
+    schema_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void TableMetadata::set_allocated_schema_name(::std::string* schema_name) {
+  if (schema_name_ != &::google::protobuf::internal::kEmptyString) {
+    delete schema_name_;
+  }
+  if (schema_name) {
+    set_has_schema_name();
+    schema_name_ = schema_name;
+  } else {
+    clear_has_schema_name();
+    schema_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// optional string table_name = 3;
+inline bool TableMetadata::has_table_name() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void TableMetadata::set_has_table_name() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void TableMetadata::clear_has_table_name() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void TableMetadata::clear_table_name() {
+  if (table_name_ != &::google::protobuf::internal::kEmptyString) {
+    table_name_->clear();
+  }
+  clear_has_table_name();
+}
+inline const ::std::string& TableMetadata::table_name() const {
+  return *table_name_;
+}
+inline void TableMetadata::set_table_name(const ::std::string& value) {
+  set_has_table_name();
+  if (table_name_ == &::google::protobuf::internal::kEmptyString) {
+    table_name_ = new ::std::string;
+  }
+  table_name_->assign(value);
+}
+inline void TableMetadata::set_table_name(const char* value) {
+  set_has_table_name();
+  if (table_name_ == &::google::protobuf::internal::kEmptyString) {
+    table_name_ = new ::std::string;
+  }
+  table_name_->assign(value);
+}
+inline void TableMetadata::set_table_name(const char* value, size_t size) {
+  set_has_table_name();
+  if (table_name_ == &::google::protobuf::internal::kEmptyString) {
+    table_name_ = new ::std::string;
+  }
+  table_name_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* TableMetadata::mutable_table_name() {
+  set_has_table_name();
+  if (table_name_ == &::google::protobuf::internal::kEmptyString) {
+    table_name_ = new ::std::string;
+  }
+  return table_name_;
+}
+inline ::std::string* TableMetadata::release_table_name() {
+  clear_has_table_name();
+  if (table_name_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = table_name_;
+    table_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void TableMetadata::set_allocated_table_name(::std::string* table_name) {
+  if (table_name_ != &::google::protobuf::internal::kEmptyString) {
+    delete table_name_;
+  }
+  if (table_name) {
+    set_has_table_name();
+    table_name_ = table_name;
+  } else {
+    clear_has_table_name();
+    table_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// optional string type = 4;
+inline bool TableMetadata::has_type() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void TableMetadata::set_has_type() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void TableMetadata::clear_has_type() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void TableMetadata::clear_type() {
+  if (type_ != &::google::protobuf::internal::kEmptyString) {
+    type_->clear();
+  }
+  clear_has_type();
+}
+inline const ::std::string& TableMetadata::type() const {
+  return *type_;
+}
+inline void TableMetadata::set_type(const ::std::string& value) {
+  set_has_type();
+  if (type_ == &::google::protobuf::internal::kEmptyString) {
+    type_ = new ::std::string;
+  }
+  type_->assign(value);
+}
+inline void TableMetadata::set_type(const char* value) {
+  set_has_type();
+  if (type_ == &::google::protobuf::internal::kEmptyString) {
+    type_ = new ::std::string;
+  }
+  type_->assign(value);
+}
+inline void TableMetadata::set_type(const char* value, size_t size) {
+  set_has_type();
+  if (type_ == &::google::protobuf::internal::kEmptyString) {
+    type_ = new ::std::string;
+  }
+  type_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* TableMetadata::mutable_type() {
+  set_has_type();
+  if (type_ == &::google::protobuf::internal::kEmptyString) {
+    type_ = new ::std::string;
+  }
+  return type_;
+}
+inline ::std::string* TableMetadata::release_type() {
+  clear_has_type();
+  if (type_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = type_;
+    type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void TableMetadata::set_allocated_type(::std::string* type) {
+  if (type_ != &::google::protobuf::internal::kEmptyString) {
+    delete type_;
+  }
+  if (type) {
+    set_has_type();
+    type_ = type;
+  } else {
+    clear_has_type();
+    type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// -------------------------------------------------------------------
+
+// GetTablesResp
+
+// optional .exec.user.RequestStatus status = 1;
+inline bool GetTablesResp::has_status() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetTablesResp::set_has_status() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetTablesResp::clear_has_status() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetTablesResp::clear_status() {
+  status_ = 0;
+  clear_has_status();
+}
+inline ::exec::user::RequestStatus GetTablesResp::status() const {
+  return static_cast< ::exec::user::RequestStatus >(status_);
+}
+inline void GetTablesResp::set_status(::exec::user::RequestStatus value) {
+  assert(::exec::user::RequestStatus_IsValid(value));
+  set_has_status();
+  status_ = value;
+}
+
+// repeated .exec.user.TableMetadata tables = 2;
+inline int GetTablesResp::tables_size() const {
+  return tables_.size();
+}
+inline void GetTablesResp::clear_tables() {
+  tables_.Clear();
+}
+inline const ::exec::user::TableMetadata& GetTablesResp::tables(int index) const {
+  return tables_.Get(index);
+}
+inline ::exec::user::TableMetadata* GetTablesResp::mutable_tables(int index) {
+  return tables_.Mutable(index);
+}
+inline ::exec::user::TableMetadata* GetTablesResp::add_tables() {
+  return tables_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::exec::user::TableMetadata >&
+GetTablesResp::tables() const {
+  return tables_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::exec::user::TableMetadata >*
+GetTablesResp::mutable_tables() {
+  return &tables_;
+}
+
+// optional .exec.shared.DrillPBError error = 3;
+inline bool GetTablesResp::has_error() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GetTablesResp::set_has_error() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GetTablesResp::clear_has_error() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GetTablesResp::clear_error() {
+  if (error_ != NULL) error_->::exec::shared::DrillPBError::Clear();
+  clear_has_error();
+}
+inline const ::exec::shared::DrillPBError& GetTablesResp::error() const {
+  return error_ != NULL ? *error_ : *default_instance_->error_;
+}
+inline ::exec::shared::DrillPBError* GetTablesResp::mutable_error() {
+  set_has_error();
+  if (error_ == NULL) error_ = new ::exec::shared::DrillPBError;
+  return error_;
+}
+inline ::exec::shared::DrillPBError* GetTablesResp::release_error() {
+  clear_has_error();
+  ::exec::shared::DrillPBError* temp = error_;
+  error_ = NULL;
+  return temp;
+}
+inline void GetTablesResp::set_allocated_error(::exec::shared::DrillPBError* error) {
+  delete error_;
+  error_ = error;
+  if (error) {
+    set_has_error();
+  } else {
+    clear_has_error();
+  }
+}
+
+// -------------------------------------------------------------------
+
+// GetColumnsReq
+
+// optional .exec.user.LikeFilter catalog_name_filter = 1;
+inline bool GetColumnsReq::has_catalog_name_filter() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetColumnsReq::set_has_catalog_name_filter() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetColumnsReq::clear_has_catalog_name_filter() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetColumnsReq::clear_catalog_name_filter() {
+  if (catalog_name_filter_ != NULL) catalog_name_filter_->::exec::user::LikeFilter::Clear();
+  clear_has_catalog_name_filter();
+}
+inline const ::exec::user::LikeFilter& GetColumnsReq::catalog_name_filter() const {
+  return catalog_name_filter_ != NULL ? *catalog_name_filter_ : *default_instance_->catalog_name_filter_;
+}
+inline ::exec::user::LikeFilter* GetColumnsReq::mutable_catalog_name_filter() {
+  set_has_catalog_name_filter();
+  if (catalog_name_filter_ == NULL) catalog_name_filter_ = new ::exec::user::LikeFilter;
+  return catalog_name_filter_;
+}
+inline ::exec::user::LikeFilter* GetColumnsReq::release_catalog_name_filter() {
+  clear_has_catalog_name_filter();
+  ::exec::user::LikeFilter* temp = catalog_name_filter_;
+  catalog_name_filter_ = NULL;
+  return temp;
+}
+inline void GetColumnsReq::set_allocated_catalog_name_filter(::exec::user::LikeFilter* catalog_name_filter) {
+  delete catalog_name_filter_;
+  catalog_name_filter_ = catalog_name_filter;
+  if (catalog_name_filter) {
+    set_has_catalog_name_filter();
+  } else {
+    clear_has_catalog_name_filter();
+  }
+}
+
+// optional .exec.user.LikeFilter schema_name_filter = 2;
+inline bool GetColumnsReq::has_schema_name_filter() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GetColumnsReq::set_has_schema_name_filter() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GetColumnsReq::clear_has_schema_name_filter() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GetColumnsReq::clear_schema_name_filter() {
+  if (schema_name_filter_ != NULL) schema_name_filter_->::exec::user::LikeFilter::Clear();
+  clear_has_schema_name_filter();
+}
+inline const ::exec::user::LikeFilter& GetColumnsReq::schema_name_filter() const {
+  return schema_name_filter_ != NULL ? *schema_name_filter_ : *default_instance_->schema_name_filter_;
+}
+inline ::exec::user::LikeFilter* GetColumnsReq::mutable_schema_name_filter() {
+  set_has_schema_name_filter();
+  if (schema_name_filter_ == NULL) schema_name_filter_ = new ::exec::user::LikeFilter;
+  return schema_name_filter_;
+}
+inline ::exec::user::LikeFilter* GetColumnsReq::release_schema_name_filter() {
+  clear_has_schema_name_filter();
+  ::exec::user::LikeFilter* temp = schema_name_filter_;
+  schema_name_filter_ = NULL;
+  return temp;
+}
+inline void GetColumnsReq::set_allocated_schema_name_filter(::exec::user::LikeFilter* schema_name_filter) {
+  delete schema_name_filter_;
+  schema_name_filter_ = schema_name_filter;
+  if (schema_name_filter) {
+    set_has_schema_name_filter();
+  } else {
+    clear_has_schema_name_filter();
+  }
+}
+
+// optional .exec.user.LikeFilter table_name_filter = 3;
+inline bool GetColumnsReq::has_table_name_filter() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GetColumnsReq::set_has_table_name_filter() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GetColumnsReq::clear_has_table_name_filter() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GetColumnsReq::clear_table_name_filter() {
+  if (table_name_filter_ != NULL) table_name_filter_->::exec::user::LikeFilter::Clear();
+  clear_has_table_name_filter();
+}
+inline const ::exec::user::LikeFilter& GetColumnsReq::table_name_filter() const {
+  return table_name_filter_ != NULL ? *table_name_filter_ : *default_instance_->table_name_filter_;
+}
+inline ::exec::user::LikeFilter* GetColumnsReq::mutable_table_name_filter() {
+  set_has_table_name_filter();
+  if (table_name_filter_ == NULL) table_name_filter_ = new ::exec::user::LikeFilter;
+  return table_name_filter_;
+}
+inline ::exec::user::LikeFilter* GetColumnsReq::release_table_name_filter() {
+  clear_has_table_name_filter();
+  ::exec::user::LikeFilter* temp = table_name_filter_;
+  table_name_filter_ = NULL;
+  return temp;
+}
+inline void GetColumnsReq::set_allocated_table_name_filter(::exec::user::LikeFilter* table_name_filter) {
+  delete table_name_filter_;
+  table_name_filter_ = table_name_filter;
+  if (table_name_filter) {
+    set_has_table_name_filter();
+  } else {
+    clear_has_table_name_filter();
+  }
+}
+
+// optional .exec.user.LikeFilter column_name_filter = 4;
+inline bool GetColumnsReq::has_column_name_filter() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void GetColumnsReq::set_has_column_name_filter() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void GetColumnsReq::clear_has_column_name_filter() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void GetColumnsReq::clear_column_name_filter() {
+  if (column_name_filter_ != NULL) column_name_filter_->::exec::user::LikeFilter::Clear();
+  clear_has_column_name_filter();
+}
+inline const ::exec::user::LikeFilter& GetColumnsReq::column_name_filter() const {
+  return column_name_filter_ != NULL ? *column_name_filter_ : *default_instance_->column_name_filter_;
+}
+inline ::exec::user::LikeFilter* GetColumnsReq::mutable_column_name_filter() {
+  set_has_column_name_filter();
+  if (column_name_filter_ == NULL) column_name_filter_ = new ::exec::user::LikeFilter;
+  return column_name_filter_;
+}
+inline ::exec::user::LikeFilter* GetColumnsReq::release_column_name_filter() {
+  clear_has_column_name_filter();
+  ::exec::user::LikeFilter* temp = column_name_filter_;
+  column_name_filter_ = NULL;
+  return temp;
+}
+inline void GetColumnsReq::set_allocated_column_name_filter(::exec::user::LikeFilter* column_name_filter) {
+  delete column_name_filter_;
+  column_name_filter_ = column_name_filter;
+  if (column_name_filter) {
+    set_has_column_name_filter();
+  } else {
+    clear_has_column_name_filter();
+  }
+}
+
+// -------------------------------------------------------------------
+
+// ColumnMetadata
+
+// optional string catalog_name = 1;
+inline bool ColumnMetadata::has_catalog_name() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ColumnMetadata::set_has_catalog_name() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ColumnMetadata::clear_has_catalog_name() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ColumnMetadata::clear_catalog_name() {
+  if (catalog_name_ != &::google::protobuf::internal::kEmptyString) {
+    catalog_name_->clear();
+  }
+  clear_has_catalog_name();
+}
+inline const ::std::string& ColumnMetadata::catalog_name() const {
+  return *catalog_name_;
+}
+inline void ColumnMetadata::set_catalog_name(const ::std::string& value) {
+  set_has_catalog_name();
+  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
+    catalog_name_ = new ::std::string;
+  }
+  catalog_name_->assign(value);
+}
+inline void ColumnMetadata::set_catalog_name(const char* value) {
+  set_has_catalog_name();
+  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
+    catalog_name_ = new ::std::string;
+  }
+  catalog_name_->assign(value);
+}
+inline void ColumnMetadata::set_catalog_name(const char* value, size_t size) {
+  set_has_catalog_name();
+  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
+    catalog_name_ = new ::std::string;
+  }
+  catalog_name_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* ColumnMetadata::mutable_catalog_name() {
+  set_has_catalog_name();
+  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
+    catalog_name_ = new ::std::string;
+  }
+  return catalog_name_;
+}
+inline ::std::string* ColumnMetadata::release_catalog_name() {
+  clear_has_catalog_name();
+  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = catalog_name_;
+    catalog_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void ColumnMetadata::set_allocated_catalog_name(::std::string* catalog_name) {
+  if (catalog_name_ != &::google::protobuf::internal::kEmptyString) {
+    delete catalog_name_;
+  }
+  if (catalog_name) {
+    set_has_catalog_name();
+    catalog_name_ = catalog_name;
+  } else {
+    clear_has_catalog_name();
+    catalog_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// optional string schema_name = 2;
+inline bool ColumnMetadata::has_schema_name() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ColumnMetadata::set_has_schema_name() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ColumnMetadata::clear_has_schema_name() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ColumnMetadata::clear_schema_name() {
+  if (schema_name_ != &::google::protobuf::internal::kEmptyString) {
+    schema_name_->clear();
+  }
+  clear_has_schema_name();
+}
+inline const ::std::string& ColumnMetadata::schema_name() const {
+  return *schema_name_;
+}
+inline void ColumnMetadata::set_schema_name(const ::std::string& value) {
+  set_has_schema_name();
+  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
+    schema_name_ = new ::std::string;
+  }
+  schema_name_->assign(value);
+}
+inline void ColumnMetadata::set_schema_name(const char* value) {
+  set_has_schema_name();
+  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
+    schema_name_ = new ::std::string;
+  }
+  schema_name_->assign(value);
+}
+inline void ColumnMetadata::set_schema_name(const char* value, size_t size) {
+  set_has_schema_name();
+  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
+    schema_name_ = new ::std::string;
+  }
+  schema_name_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* ColumnMetadata::mutable_schema_name() {
+  set_has_schema_name();
+  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
+    schema_name_ = new ::std::string;
+  }
+  return schema_name_;
+}
+inline ::std::string* ColumnMetadata::release_schema_name() {
+  clear_has_schema_name();
+  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = schema_name_;
+    schema_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void ColumnMetadata::set_allocated_schema_name(::std::string* schema_name) {
+  if (schema_name_ != &::google::protobuf::internal::kEmptyString) {
+    delete schema_name_;
+  }
+  if (schema_name) {
+    set_has_schema_name();
+    schema_name_ = schema_name;
+  } else {
+    clear_has_schema_name();
+    schema_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// optional string table_name = 3;
+inline bool ColumnMetadata::has_table_name() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ColumnMetadata::set_has_table_name() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ColumnMetadata::clear_has_table_name() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ColumnMetadata::clear_table_name() {
+  if (table_name_ != &::google::protobuf::internal::kEmptyString) {
+    table_name_->clear();
+  }
+  clear_has_table_name();
+}
+inline const ::std::string& ColumnMetadata::table_name() const {
+  return *table_name_;
+}
+inline void ColumnMetadata::set_table_name(const ::std::string& value) {
+  set_has_table_name();
+  if (table_name_ == &::google::protobuf::internal::kEmptyString) {
+    table_name_ = new ::std::string;
+  }
+  table_name_->assign(value);
+}
+inline void ColumnMetadata::set_table_name(const char* value) {
+  set_has_table_name();
+  if (table_name_ == &::google::protobuf::internal::kEmptyString) {
+    table_name_ = new ::std::string;
+  }
+  table_name_->assign(value);
+}
+inline void ColumnMetadata::set_table_name(const char* value, size_t size) {
+  set_has_table_name();
+  if (table_name_ == &::google::protobuf::internal::kEmptyString) {
+    table_name_ = new ::std::string;
+  }
+  table_name_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* ColumnMetadata::mutable_table_name() {
+  set_has_table_name();
+  if (table_name_ == &::google::protobuf::internal::kEmptyString) {
+    table_name_ = new ::std::string;
+  }
+  return table_name_;
+}
+inline ::std::string* ColumnMetadata::release_table_name() {
+  clear_has_table_name();
+  if (table_name_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = table_name_;
+    table_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void ColumnMetadata::set_allocated_table_name(::std::string* table_name) {
+  if (table_name_ != &::google::protobuf::internal::kEmptyString) {
+    delete table_name_;
+  }
+  if (table_name) {
+    set_has_table_name();
+    table_name_ = table_name;
+  } else {
+    clear_has_table_name();
+    table_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// optional string column_name = 4;
+inline bool ColumnMetadata::has_column_name() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ColumnMetadata::set_has_column_name() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ColumnMetadata::clear_has_column_name() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ColumnMetadata::clear_column_name() {
+  if (column_name_ != &::google::protobuf::internal::kEmptyString) {
+    column_name_->clear();
+  }
+  clear_has_column_name();
+}
+inline const ::std::string& ColumnMetadata::column_name() const {
+  return *column_name_;
+}
+inline void ColumnMetadata::set_column_name(const ::std::string& value) {
+  set_has_column_name();
+  if (column_name_ == &::google::protobuf::internal::kEmptyString) {
+    column_name_ = new ::std::string;
+  }
+  column_name_->assign(value);
+}
+inline void ColumnMetadata::set_column_name(const char* value) {
+  set_has_column_name();
+  if (column_name_ == &::google::protobuf::internal::kEmptyString) {
+    column_name_ = new ::std::string;
+  }
+  column_name_->assign(value);
+}
+inline void ColumnMetadata::set_column_name(const char* value, size_t size) {
+  set_has_column_name();
+  if (column_name_ == &::google::protobuf::internal::kEmptyString) {
+    column_name_ = new ::std::string;
+  }
+  column_name_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* ColumnMetadata::mutable_column_name() {
+  set_has_column_name();
+  if (column_name_ == &::google::protobuf::internal::kEmptyString) {
+    column_name_ = new ::std::string;
+  }
+  return column_name_;
+}
+inline ::std::string* ColumnMetadata::release_column_name() {
+  clear_has_column_name();
+  if (column_name_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = column_name_;
+    column_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void ColumnMetadata::set_allocated_column_name(::std::string* column_name) {
+  if (column_name_ != &::google::protobuf::internal::kEmptyString) {
+    delete column_name_;
+  }
+  if (column_name) {
+    set_has_column_name();
+    column_name_ = column_name;
+  } else {
+    clear_has_column_name();
+    column_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// optional int32 ordinal_position = 5;
+inline bool ColumnMetadata::has_ordinal_position() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void ColumnMetadata::set_has_ordinal_position() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void ColumnMetadata::clear_has_ordinal_position() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void ColumnMetadata::clear_ordinal_position() {
+  ordinal_position_ = 0;
+  clear_has_ordinal_position();
+}
+inline ::google::protobuf::int32 ColumnMetadata::ordinal_position() const {
+  return ordinal_position_;
+}
+inline void ColumnMetadata::set_ordinal_position(::google::protobuf::int32 value) {
+  set_has_ordinal_position();
+  ordinal_position_ = value;
+}
+
+// optional string default_value = 6;
+inline bool ColumnMetadata::has_default_value() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void ColumnMetadata::set_has_default_value() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void ColumnMetadata::clear_has_default_value() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void ColumnMetadata::clear_default_value() {
+  if (default_value_ != &::google::protobuf::internal::kEmptyString) {
+    default_value_->clear();
+  }
+  clear_has_default_value();
+}
+inline const ::std::string& ColumnMetadata::default_value() const {
+  return *default_value_;
+}
+inline void ColumnMetadata::set_default_value(const ::std::string& value) {
+  set_has_default_value();
+  if (default_value_ == &::google::protobuf::internal::kEmptyString) {
+    default_value_ = new ::std::string;
+  }
+  default_value_->assign(value);
+}
+inline void ColumnMetadata::set_default_value(const char* value) {
+  set_has_default_value();
+  if (default_value_ == &::google::protobuf::internal::kEmptyString) {
+    default_value_ = new ::std::string;
+  }
+  default_value_->assign(value);
+}
+inline void ColumnMetadata::set_default_value(const char* value, size_t size) {
+  set_has_default_value();
+  if (default_value_ == &::google::protobuf::internal::kEmptyString) {
+    default_value_ = new ::std::string;
+  }
+  default_value_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* ColumnMetadata::mutable_default_value() {
+  set_has_default_value();
+  if (default_value_ == &::google::protobuf::internal::kEmptyString) {
+    default_value_ = new ::std::string;
+  }
+  return default_value_;
+}
+inline ::std::string* ColumnMetadata::release_default_value() {
+  clear_has_default_value();
+  if (default_value_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = default_value_;
+    default_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void ColumnMetadata::set_allocated_default_value(::std::string* default_value) {
+  if (default_value_ != &::google::protobuf::internal::kEmptyString) {
+    delete default_value_;
+  }
+  if (default_value) {
+    set_has_default_value();
+    default_value_ = default_value;
+  } else {
+    clear_has_default_value();
+    default_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// optional bool is_nullable = 7;
+inline bool ColumnMetadata::has_is_nullable() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void ColumnMetadata::set_has_is_nullable() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void ColumnMetadata::clear_has_is_nullable() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void ColumnMetadata::clear_is_nullable() {
+  is_nullable_ = false;
+  clear_has_is_nullable();
+}
+inline bool ColumnMetadata::is_nullable() const {
+  return is_nullable_;
+}
+inline void ColumnMetadata::set_is_nullable(bool value) {
+  set_has_is_nullable();
+  is_nullable_ = value;
+}
+
+// optional string data_type = 8;
+inline bool ColumnMetadata::has_data_type() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void ColumnMetadata::set_has_data_type() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void ColumnMetadata::clear_has_data_type() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void ColumnMetadata::clear_data_type() {
+  if (data_type_ != &::google::protobuf::internal::kEmptyString) {
+    data_type_->clear();
+  }
+  clear_has_data_type();
+}
+inline const ::std::string& ColumnMetadata::data_type() const {
+  return *data_type_;
+}
+inline void ColumnMetadata::set_data_type(const ::std::string& value) {
+  set_has_data_type();
+  if (data_type_ == &::google::protobuf::internal::kEmptyString) {
+    data_type_ = new ::std::string;
+  }
+  data_type_->assign(value);
+}
+inline void ColumnMetadata::set_data_type(const char* value) {
+  set_has_data_type();
+  if (data_type_ == &::google::protobuf::internal::kEmptyString) {
+    data_type_ = new ::std::string;
+  }
+  data_type_->assign(value);
+}
+inline void ColumnMetadata::set_data_type(const char* value, size_t size) {
+  set_has_data_type();
+  if (data_type_ == &::google::protobuf::internal::kEmptyString) {
+    data_type_ = new ::std::string;
+  }
+  data_type_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* ColumnMetadata::mutable_data_type() {
+  set_has_data_type();
+  if (data_type_ == &::google::protobuf::internal::kEmptyString) {
+    data_type_ = new ::std::string;
+  }
+  return data_type_;
+}
+inline ::std::string* ColumnMetadata::release_data_type() {
+  clear_has_data_type();
+  if (data_type_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = data_type_;
+    data_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void ColumnMetadata::set_allocated_data_type(::std::string* data_type) {
+  if (data_type_ != &::google::protobuf::internal::kEmptyString) {
+    delete data_type_;
+  }
+  if (data_type) {
+    set_has_data_type();
+    data_type_ = data_type;
+  } else {
+    clear_has_data_type();
+    data_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// optional int32 char_max_length = 9;
+inline bool ColumnMetadata::has_char_max_length() const {
+  return (_has_bits_[0] & 0x00000100u) != 0;
+}
+inline void ColumnMetadata::set_has_char_max_length() {
+  _has_bits_[0] |= 0x00000100u;
+}
+inline void ColumnMetadata::clear_has_char_max_length() {
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline void ColumnMetadata::clear_char_max_length() {
+  char_max_length_ = 0;
+  clear_has_char_max_length();
+}
+inline ::google::protobuf::int32 ColumnMetadata::char_max_length() const {
+  return char_max_length_;
+}
+inline void ColumnMetadata::set_char_max_length(::google::protobuf::int32 value) {
+  set_has_char_max_length();
+  char_max_length_ = value;
+}
+
+// optional int32 char_octet_length = 10;
+inline bool ColumnMetadata::has_char_octet_length() const {
+  return (_has_bits_[0] & 0x00000200u) != 0;
+}
+inline void ColumnMetadata::set_has_char_octet_length() {
+  _has_bits_[0] |= 0x00000200u;
+}
+inline void ColumnMetadata::clear_has_char_octet_length() {
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline void ColumnMetadata::clear_char_octet_length() {
+  char_octet_length_ = 0;
+  clear_has_char_octet_length();
+}
+inline ::google::protobuf::int32 ColumnMetadata::char_octet_length() const {
+  return char_octet_length_;
+}
+inline void ColumnMetadata::set_char_octet_length(::google::protobuf::int32 value) {
+  set_has_char_octet_length();
+  char_octet_length_ = value;
+}
+
+// optional int32 numeric_precision = 11;
+inline bool ColumnMetadata::has_numeric_precision() const {
+  return (_has_bits_[0] & 0x00000400u) != 0;
+}
+inline void ColumnMetadata::set_has_numeric_precision() {
+  _has_bits_[0] |= 0x00000400u;
+}
+inline void ColumnMetadata::clear_has_numeric_precision() {
+  _has_bits_[0] &= ~0x00000400u;
+}
+inline void ColumnMetadata::clear_numeric_precision() {
+  numeric_precision_ = 0;
+  clear_has_numeric_precision();
+}
+inline ::google::protobuf::int32 ColumnMetadata::numeric_precision() const {
+  return numeric_precision_;
+}
+inline void ColumnMetadata::set_numeric_precision(::google::protobuf::int32 value) {
+  set_has_numeric_precision();
+  numeric_precision_ = value;
+}
+
+// optional int32 numeric_precision_radix = 12;
+inline bool ColumnMetadata::has_numeric_precision_radix() const {
+  return (_has_bits_[0] & 0x00000800u) != 0;
+}
+inline void ColumnMetadata::set_has_numeric_precision_radix() {
+  _has_bits_[0] |= 0x00000800u;
+}
+inline void ColumnMetadata::clear_has_numeric_precision_radix() {
+  _has_bits_[0] &= ~0x00000800u;
+}
+inline void ColumnMetadata::clear_numeric_precision_radix() {
+  numeric_precision_radix_ = 0;
+  clear_has_numeric_precision_radix();
+}
+inline ::google::protobuf::int32 ColumnMetadata::numeric_precision_radix() const {
+  return numeric_precision_radix_;
+}
+inline void ColumnMetadata::set_numeric_precision_radix(::google::protobuf::int32 value) {
+  set_has_numeric_precision_radix();
+  numeric_precision_radix_ = value;
+}
+
+// optional int32 numeric_scale = 13;
+inline bool ColumnMetadata::has_numeric_scale() const {
+  return (_has_bits_[0] & 0x00001000u) != 0;
+}
+inline void ColumnMetadata::set_has_numeric_scale() {
+  _has_bits_[0] |= 0x00001000u;
+}
+inline void ColumnMetadata::clear_has_numeric_scale() {
+  _has_bits_[0] &= ~0x00001000u;
+}
+inline void ColumnMetadata::clear_numeric_scale() {
+  numeric_scale_ = 0;
+  clear_has_numeric_scale();
+}
+inline ::google::protobuf::int32 ColumnMetadata::numeric_scale() const {
+  return numeric_scale_;
+}
+inline void ColumnMetadata::set_numeric_scale(::google::protobuf::int32 value) {
+  set_has_numeric_scale();
+  numeric_scale_ = value;
+}
+
+// optional int32 date_time_precision = 14;
+inline bool ColumnMetadata::has_date_time_precision() const {
+  return (_has_bits_[0] & 0x00002000u) != 0;
+}
+inline void ColumnMetadata::set_has_date_time_precision() {
+  _has_bits_[0] |= 0x00002000u;
+}
+inline void ColumnMetadata::clear_has_date_time_precision() {
+  _has_bits_[0] &= ~0x00002000u;
+}
+inline void ColumnMetadata::clear_date_time_precision() {
+  date_time_precision_ = 0;
+  clear_has_date_time_precision();
+}
+inline ::google::protobuf::int32 ColumnMetadata::date_time_precision() const {
+  return date_time_precision_;
+}
+inline void ColumnMetadata::set_date_time_precision(::google::protobuf::int32 value) {
+  set_has_date_time_precision();
+  date_time_precision_ = value;
+}
+
+// optional string interval_type = 15;
+inline bool ColumnMetadata::has_interval_type() const {
+  return (_has_bits_[0] & 0x00004000u) != 0;
+}
+inline void ColumnMetadata::set_has_interval_type() {
+  _has_bits_[0] |= 0x00004000u;
+}
+inline void ColumnMetadata::clear_has_interval_type() {
+  _has_bits_[0] &= ~0x00004000u;
+}
+inline void ColumnMetadata::clear_interval_type() {
+  if (interval_type_ != &::google::protobuf::internal::kEmptyString) {
+    interval_type_->clear();
+  }
+  clear_has_interval_type();
+}
+inline const ::std::string& ColumnMetadata::interval_type() const {
+  return *interval_type_;
+}
+inline void ColumnMetadata::set_interval_type(const ::std::string& value) {
+  set_has_interval_type();
+  if (interval_type_ == &::google::protobuf::internal::kEmptyString) {
+    interval_type_ = new ::std::string;
+  }
+  interval_type_->assign(value);
+}
+inline void ColumnMetadata::set_interval_type(const char* value) {
+  set_has_interval_type();
+  if (interval_type_ == &::google::protobuf::internal::kEmptyString) {
+    interval_type_ = new ::std::string;
+  }
+  interval_type_->assign(value);
+}
+inline void ColumnMetadata::set_interval_type(const char* value, size_t size) {
+  set_has_interval_type();
+  if (interval_type_ == &::google::protobuf::internal::kEmptyString) {
+    interval_type_ = new ::std::string;
+  }
+  interval_type_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* ColumnMetadata::mutable_interval_type() {
+  set_has_interval_type();
+  if (interval_type_ == &::google::protobuf::internal::kEmptyString) {
+    interval_type_ = new ::std::string;
+  }
+  return interval_type_;
+}
+inline ::std::string* ColumnMetadata::release_interval_type() {
+  clear_has_interval_type();
+  if (interval_type_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = interval_type_;
+    interval_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void ColumnMetadata::set_allocated_interval_type(::std::string* interval_type) {
+  if (interval_type_ != &::google::protobuf::internal::kEmptyString) {
+    delete interval_type_;
+  }
+  if (interval_type) {
+    set_has_interval_type();
+    interval_type_ = interval_type;
+  } else {
+    clear_has_interval_type();
+    interval_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// optional int32 interval_precision = 16;
+inline bool ColumnMetadata::has_interval_precision() const {
+  return (_has_bits_[0] & 0x00008000u) != 0;
+}
+inline void ColumnMetadata::set_has_interval_precision() {
+  _has_bits_[0] |= 0x00008000u;
+}
+inline void ColumnMetadata::clear_has_interval_precision() {
+  _has_bits_[0] &= ~0x00008000u;
+}
+inline void ColumnMetadata::clear_interval_precision() {
+  interval_precision_ = 0;
+  clear_has_interval_precision();
+}
+inline ::google::protobuf::int32 ColumnMetadata::interval_precision() const {
+  return interval_precision_;
+}
+inline void ColumnMetadata::set_interval_precision(::google::protobuf::int32 value) {
+  set_has_interval_precision();
+  interval_precision_ = value;
+}
+
+// optional int32 column_size = 17;
+inline bool ColumnMetadata::has_column_size() const {
+  return (_has_bits_[0] & 0x00010000u) != 0;
+}
+inline void ColumnMetadata::set_has_column_size() {
+  _has_bits_[0] |= 0x00010000u;
+}
+inline void ColumnMetadata::clear_has_column_size() {
+  _has_bits_[0] &= ~0x00010000u;
+}
+inline void ColumnMetadata::clear_column_size() {
+  column_size_ = 0;
+  clear_has_column_size();
+}
+inline ::google::protobuf::int32 ColumnMetadata::column_size() const {
+  return column_size_;
+}
+inline void ColumnMetadata::set_column_size(::google::protobuf::int32 value) {
+  set_has_column_size();
+  column_size_ = value;
+}
+
+// -------------------------------------------------------------------
+
+// GetColumnsResp
+
+// optional .exec.user.RequestStatus status = 1;
+inline bool GetColumnsResp::has_status() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetColumnsResp::set_has_status() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetColumnsResp::clear_has_status() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetColumnsResp::clear_status() {
+  status_ = 0;
+  clear_has_status();
+}
+inline ::exec::user::RequestStatus GetColumnsResp::status() const {
+  return static_cast< ::exec::user::RequestStatus >(status_);
+}
+inline void GetColumnsResp::set_status(::exec::user::RequestStatus value) {
+  assert(::exec::user::RequestStatus_IsValid(value));
+  set_has_status();
+  status_ = value;
+}
+
+// repeated .exec.user.ColumnMetadata columns = 2;
+inline int GetColumnsResp::columns_size() const {
+  return columns_.size();
+}
+inline void GetColumnsResp::clear_columns() {
+  columns_.Clear();
+}
+inline const ::exec::user::ColumnMetadata& GetColumnsResp::columns(int index) const {
+  return columns_.Get(index);
+}
+inline ::exec::user::ColumnMetadata* GetColumnsResp::mutable_columns(int index) {
+  return columns_.Mutable(index);
+}
+inline ::exec::user::ColumnMetadata* GetColumnsResp::add_columns() {
+  return columns_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::exec::user::ColumnMetadata >&
+GetColumnsResp::columns() const {
+  return columns_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::exec::user::ColumnMetadata >*
+GetColumnsResp::mutable_columns() {
+  return &columns_;
+}
+
+// optional .exec.shared.DrillPBError error = 3;
+inline bool GetColumnsResp::has_error() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GetColumnsResp::set_has_error() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GetColumnsResp::clear_has_error() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GetColumnsResp::clear_error() {
+  if (error_ != NULL) error_->::exec::shared::DrillPBError::Clear();
+  clear_has_error();
+}
+inline const ::exec::shared::DrillPBError& GetColumnsResp::error() const {
+  return error_ != NULL ? *error_ : *default_instance_->error_;
+}
+inline ::exec::shared::DrillPBError* GetColumnsResp::mutable_error() {
+  set_has_error();
+  if (error_ == NULL) error_ = new ::exec::shared::DrillPBError;
+  return error_;
+}
+inline ::exec::shared::DrillPBError* GetColumnsResp::release_error() {
+  clear_has_error();
+  ::exec::shared::DrillPBError* temp = error_;
+  error_ = NULL;
+  return temp;
+}
+inline void GetColumnsResp::set_allocated_error(::exec::shared::DrillPBError* error) {
+  delete error_;
+  error_ = error;
+  if (error) {
+    set_has_error();
+  } else {
+    clear_has_error();
+  }
+}
+
+// -------------------------------------------------------------------
+
+// CreatePreparedStatementReq
+
+// optional string sql_query = 1;
+inline bool CreatePreparedStatementReq::has_sql_query() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void CreatePreparedStatementReq::set_has_sql_query() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void CreatePreparedStatementReq::clear_has_sql_query() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void CreatePreparedStatementReq::clear_sql_query() {
+  if (sql_query_ != &::google::protobuf::internal::kEmptyString) {
+    sql_query_->clear();
+  }
+  clear_has_sql_query();
+}
+inline const ::std::string& CreatePreparedStatementReq::sql_query() const {
+  return *sql_query_;
+}
+inline void CreatePreparedStatementReq::set_sql_query(const ::std::string& value) {
+  set_has_sql_query();
+  if (sql_query_ == &::google::protobuf::internal::kEmptyString) {
+    sql_query_ = new ::std::string;
+  }
+  sql_query_->assign(value);
+}
+inline void CreatePreparedStatementReq::set_sql_query(const char* value) {
+  set_has_sql_query();
+  if (sql_query_ == &::google::protobuf::internal::kEmptyString) {
+    sql_query_ = new ::std::string;
+  }
+  sql_query_->assign(value);
+}
+inline void CreatePreparedStatementReq::set_sql_query(const char* value, size_t size) {
+  set_has_sql_query();
+  if (sql_query_ == &::google::protobuf::internal::kEmptyString) {
+    sql_query_ = new ::std::string;
+  }
+  sql_query_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* CreatePreparedStatementReq::mutable_sql_query() {
+  set_has_sql_query();
+  if (sql_query_ == &::google::protobuf::internal::kEmptyString) {
+    sql_query_ = new ::std::string;
+  }
+  return sql_query_;
+}
+inline ::std::string* CreatePreparedStatementReq::release_sql_query() {
+  clear_has_sql_query();
+  if (sql_query_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = sql_query_;
+    sql_query_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void CreatePreparedStatementReq::set_allocated_sql_query(::std::string* sql_query) {
+  if (sql_query_ != &::google::protobuf::internal::kEmptyString) {
+    delete sql_query_;
+  }
+  if (sql_query) {
+    set_has_sql_query();
+    sql_query_ = sql_query;
+  } else {
+    clear_has_sql_query();
+    sql_query_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// -------------------------------------------------------------------
+
+// ResultColumnMetadata
+
+// optional string catalog_name = 1;
+inline bool ResultColumnMetadata::has_catalog_name() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ResultColumnMetadata::set_has_catalog_name() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ResultColumnMetadata::clear_has_catalog_name() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ResultColumnMetadata::clear_catalog_name() {
+  if (catalog_name_ != &::google::protobuf::internal::kEmptyString) {
+    catalog_name_->clear();
+  }
+  clear_has_catalog_name();
+}
+inline const ::std::string& ResultColumnMetadata::catalog_name() const {
+  return *catalog_name_;
+}
+inline void ResultColumnMetadata::set_catalog_name(const ::std::string& value) {
+  set_has_catalog_name();
+  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
+    catalog_name_ = new ::std::string;
+  }
+  catalog_name_->assign(value);
+}
+inline void ResultColumnMetadata::set_catalog_name(const char* value) {
+  set_has_catalog_name();
+  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
+    catalog_name_ = new ::std::string;
+  }
+  catalog_name_->assign(value);
+}
+inline void ResultColumnMetadata::set_catalog_name(const char* value, size_t size) {
+  set_has_catalog_name();
+  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
+    catalog_name_ = new ::std::string;
+  }
+  catalog_name_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* ResultColumnMetadata::mutable_catalog_name() {
+  set_has_catalog_name();
+  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
+    catalog_name_ = new ::std::string;
+  }
+  return catalog_name_;
+}
+inline ::std::string* ResultColumnMetadata::release_catalog_name() {
+  clear_has_catalog_name();
+  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = catalog_name_;
+    catalog_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void ResultColumnMetadata::set_allocated_catalog_name(::std::string* catalog_name) {
+  if (catalog_name_ != &::google::protobuf::internal::kEmptyString) {
+    delete catalog_name_;
+  }
+  if (catalog_name) {
+    set_has_catalog_name();
+    catalog_name_ = catalog_name;
+  } else {
+    clear_has_catalog_name();
+    catalog_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// optional string schema_name = 2;
+inline bool ResultColumnMetadata::has_schema_name() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ResultColumnMetadata::set_has_schema_name() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ResultColumnMetadata::clear_has_schema_name() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ResultColumnMetadata::clear_schema_name() {
+  if (schema_name_ != &::google::protobuf::internal::kEmptyString) {
+    schema_name_->clear();
+  }
+  clear_has_schema_name();
+}
+inline const ::std::string& ResultColumnMetadata::schema_name() const {
+  return *schema_name_;
+}
+inline void ResultColumnMetadata::set_schema_name(const ::std::string& value) {
+  set_has_schema_name();
+  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
+    schema_name_ = new ::std::string;
+  }
+  schema_name_->assign(value);
+}
+inline void ResultColumnMetadata::set_schema_name(const char* value) {
+  set_has_schema_name();
+  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
+    schema_name_ = new ::std::string;
+  }
+  schema_name_->assign(value);
+}
+inline void ResultColumnMetadata::set_schema_name(const char* value, size_t size) {
+  set_has_schema_name();
+  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
+    schema_name_ = new ::std::string;
+  }
+  schema_name_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* ResultColumnMetadata::mutable_schema_name() {
+  set_has_schema_name();
+  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
+    schema_name_ = new ::std::string;
+  }
+  return schema_name_;
+}
+inline ::std::string* ResultColumnMetadata::release_schema_name() {
+  clear_has_schema_name();
+  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = schema_name_;
+    schema_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void ResultColumnMetadata::set_allocated_schema_name(::std::string* schema_name) {
+  if (schema_name_ != &::google::protobuf::internal::kEmptyString) {
+    delete schema_name_;
+  }
+  if (schema_name) {
+    set_has_schema_name();
+    schema_name_ = schema_name;
+  } else {
+    clear_has_schema_name();
+    schema_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// optional string table_name = 3;
+inline bool ResultColumnMetadata::has_table_name() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ResultColumnMetadata::set_has_table_name() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ResultColumnMetadata::clear_has_table_name() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ResultColumnMetadata::clear_table_name() {
+  if (table_name_ != &::google::protobuf::internal::kEmptyString) {
+    table_name_->clear();
+  }
+  clear_has_table_name();
+}
+inline const ::std::string& ResultColumnMetadata::table_name() const {
+  return *table_name_;
+}
+inline void ResultColumnMetadata::set_table_name(const ::std::string& value) {
+  set_has_table_name();
+  if (table_name_ == &::google::protobuf::internal::kEmptyString) {
+    table_name_ = new ::std::string;
+  }
+  table_name_->assign(value);
+}
+inline void ResultColumnMetadata::set_table_name(const char* value) {
+  set_has_table_name();
+  if (table_name_ == &::google::protobuf::internal::kEmptyString) {
+    table_name_ = new ::std::string;
+  }
+  table_name_->assign(value);
+}
+inline void ResultColumnMetadata::set_table_name(const char* value, size_t size) {
+  set_has_table_name();
+  if (table_name_ == &::google::protobuf::internal::kEmptyString) {
+    table_name_ = new ::std::string;
+  }
+  table_name_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* ResultColumnMetadata::mutable_table_name() {
+  set_has_table_name();
+  if (table_name_ == &::google::protobuf::internal::kEmptyString) {
+    table_name_ = new ::std::string;
+  }
+  return table_name_;
+}
+inline ::std::string* ResultColumnMetadata::release_table_name() {
+  clear_has_table_name();
+  if (table_name_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = table_name_;
+    table_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void ResultColumnMetadata::set_allocated_table_name(::std::string* table_name) {
+  if (table_name_ != &::google::protobuf::internal::kEmptyString) {
+    delete table_name_;
+  }
+  if (table_name) {
+    set_has_table_name();
+    table_name_ = table_name;
+  } else {
+    clear_has_table_name();
+    table_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// optional string column_name = 4;
+inline bool ResultColumnMetadata::has_column_name() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ResultColumnMetadata::set_has_column_name() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ResultColumnMetadata::clear_has_column_name() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ResultColumnMetadata::clear_column_name() {
+  if (column_name_ != &::google::protobuf::internal::kEmptyString) {
+    column_name_->clear();
+  }
+  clear_has_column_name();
+}
+inline const ::std::string& ResultColumnMetadata::column_name() const {
+  return *column_name_;
+}
+inline void ResultColumnMetadata::set_column_name(const ::std::string& value) {
+  set_has_column_name();
+  if (column_name_ == &::google::protobuf::internal::kEmptyString) {
+    column_name_ = new ::std::string;
+  }
+  column_name_->assign(value);
+}
+inline void ResultColumnMetadata::set_column_name(const char* value) {
+  set_has_column_name();
+  if (column_name_ == &::google::protobuf::internal::kEmptyString) {
+    column_name_ = new ::std::string;
+  }
+  column_name_->assign(value);
+}
+inline void ResultColumnMetadata::set_column_name(const char* value, size_t size) {
+  set_has_column_name();
+  if (column_name_ == &::google::protobuf::internal::kEmptyString) {
+    column_name_ = new ::std::string;
+  }
+  column_name_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* ResultColumnMetadata::mutable_column_name() {
+  set_has_column_name();
+  if (column_name_ == &::google::protobuf::internal::kEmptyString) {
+    column_name_ = new ::std::string;
+  }
+  return column_name_;
+}
+inline ::std::string* ResultColumnMetadata::release_column_name() {
+  clear_has_column_name();
+  if (column_name_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = column_name_;
+    column_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void ResultColumnMetadata::set_allocated_column_name(::std::string* column_name) {
+  if (column_name_ != &::google::protobuf::internal::kEmptyString) {
+    delete column_name_;
+  }
+  if (column_name) {
+    set_has_column_name();
+    column_name_ = column_name;
+  } else {
+    clear_has_column_name();
+    column_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// optional string label = 5;
+inline bool ResultColumnMetadata::has_label() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void ResultColumnMetadata::set_has_label() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void ResultColumnMetadata::clear_has_label() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void ResultColumnMetadata::clear_label() {
+  if (label_ != &::google::protobuf::internal::kEmptyString) {
+    label_->clear();
+  }
+  clear_has_label();
+}
+inline const ::std::string& ResultColumnMetadata::label() const {
+  return *label_;
+}
+inline void ResultColumnMetadata::set_label(const ::std::string& value) {
+  set_has_label();
+  if (label_ == &::google::protobuf::internal::kEmptyString) {
+    label_ = new ::std::string;
+  }
+  label_->assign(value);
+}
+inline void ResultColumnMetadata::set_label(const char* value) {
+  set_has_label();
+  if (label_ == &::google::protobuf::internal::kEmptyString) {
+    label_ = new ::std::string;
+  }
+  label_->assign(value);
+}
+inline void ResultColumnMetadata::set_label(const char* value, size_t size) {
+  set_has_label();
+  if (label_ == &::google::protobuf::internal::kEmptyString) {
+    label_ = new ::std::string;
+  }
+  label_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* ResultColumnMetadata::mutable_label() {
+  set_has_label();
+  if (label_ == &::google::protobuf::internal::kEmptyString) {
+    label_ = new ::std::string;
+  }
+  return label_;
+}
+inline ::std::string* ResultColumnMetadata::release_label() {
+  clear_has_label();
+  if (label_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = label_;
+    label_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void ResultColumnMetadata::set_allocated_label(::std::string* label) {
+  if (label_ != &::google::protobuf::internal::kEmptyString) {
+    delete label_;
+  }
+  if (label) {
+    set_has_label();
+    label_ = label;
+  } else {
+    clear_has_label();
+    label_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// optional string data_type = 6;
+inline bool ResultColumnMetadata::has_data_type() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void ResultColumnMetadata::set_has_data_type() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void ResultColumnMetadata::clear_has_data_type() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void ResultColumnMetadata::clear_data_type() {
+  if (data_type_ != &::google::protobuf::internal::kEmptyString) {
+    data_type_->clear();
+  }
+  clear_has_data_type();
+}
+inline const ::std::string& ResultColumnMetadata::data_type() const {
+  return *data_type_;
+}
+inline void ResultColumnMetadata::set_data_type(const ::std::string& value) {
+  set_has_data_type();
+  if (data_type_ == &::google::protobuf::internal::kEmptyString) {
+    data_type_ = new ::std::string;
+  }
+  data_type_->assign(value);
+}
+inline void ResultColumnMetadata::set_data_type(const char* value) {
+  set_has_data_type();
+  if (data_type_ == &::google::protobuf::internal::kEmptyString) {
+    data_type_ = new ::std::string;
+  }
+  data_type_->assign(value);
+}
+inline void ResultColumnMetadata::set_data_type(const char* value, size_t size) {
+  set_has_data_type();
+  if (data_type_ == &::google::protobuf::internal::kEmptyString) {
+    data_type_ = new ::std::string;
+  }
+  data_type_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* ResultColumnMetadata::mutable_data_type() {
+  set_has_data_type();
+  if (data_type_ == &::google::protobuf::internal::kEmptyString) {
+    data_type_ = new ::std::string;
+  }
+  return data_type_;
+}
+inline ::std::string* ResultColumnMetadata::release_data_type() {
+  clear_has_data_type();
+  if (data_type_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = data_type_;
+    data_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void ResultColumnMetadata::set_allocated_data_type(::std::string* data_type) {
+  if (data_type_ != &::google::protobuf::internal::kEmptyString) {
+    delete data_type_;
+  }
+  if (data_type) {
+    set_has_data_type();
+    data_type_ = data_type;
+  } else {
+    clear_has_data_type();
+    data_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// optional bool is_nullable = 7;
+inline bool ResultColumnMetadata::has_is_nullable() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void ResultColumnMetadata::set_has_is_nullable() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void ResultColumnMetadata::clear_has_is_nullable() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void ResultColumnMetadata::clear_is_nullable() {
+  is_nullable_ = false;
+  clear_has_is_nullable();
+}
+inline bool ResultColumnMetadata::is_nullable() const {
+  return is_nullable_;
+}
+inline void ResultColumnMetadata::set_is_nullable(bool value) {
+  set_has_is_nullable();
+  is_nullable_ = value;
+}
+
+// optional int32 precision = 8;
+inline bool ResultColumnMetadata::has_precision() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void ResultColumnMetadata::set_has_precision() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void ResultColumnMetadata::clear_has_precision() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void ResultColumnMetadata::clear_precision() {
+  precision_ = 0;
+  clear_has_precision();
+}
+inline ::google::protobuf::int32 ResultColumnMetadata::precision() const {
+  return precision_;
+}
+inline void ResultColumnMetadata::set_precision(::google::protobuf::int32 value) {
+  set_has_precision();
+  precision_ = value;
+}
+
+// optional int32 scale = 9;
+inline bool ResultColumnMetadata::has_scale() const {
+  return (_has_bits_[0] & 0x00000100u) != 0;
+}
+inline void ResultColumnMetadata::set_has_scale() {
+  _has_bits_[0] |= 0x00000100u;
+}
+inline void ResultColumnMetadata::clear_has_scale() {
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline void ResultColumnMetadata::clear_scale() {
+  scale_ = 0;
+  clear_has_scale();
+}
+inline ::google::protobuf::int32 ResultColumnMetadata::scale() const {
+  return scale_;
+}
+inline void ResultColumnMetadata::set_scale(::google::protobuf::int32 value) {
+  set_has_scale();
+  scale_ = value;
+}
+
+// optional bool signed = 10;
+inline bool ResultColumnMetadata::has_signed_() const {
+  return (_has_bits_[0] & 0x00000200u) != 0;
+}
+inline void ResultColumnMetadata::set_has_signed_() {
+  _has_bits_[0] |= 0x00000200u;
+}
+inline void ResultColumnMetadata::clear_has_signed_() {
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline void ResultColumnMetadata::clear_signed_() {
+  signed__ = false;
+  clear_has_signed_();
+}
+inline bool ResultColumnMetadata::signed_() const {
+  return signed__;
+}
+inline void ResultColumnMetadata::set_signed_(bool value) {
+  set_has_signed_();
+  signed__ = value;
+}
+
+// optional int32 display_size = 11;
+inline bool ResultColumnMetadata::has_display_size() const {
+  return (_has_bits_[0] & 0x00000400u) != 0;
+}
+inline void ResultColumnMetadata::set_has_display_size() {
+  _has_bits_[0] |= 0x00000400u;
+}
+inline void ResultColumnMetadata::clear_has_display_size() {
+  _has_bits_[0] &= ~0x00000400u;
+}
+inline void ResultColumnMetadata::clear_display_size() {
+  display_size_ = 0;
+  clear_has_display_size();
+}
+inline ::google::protobuf::int32 ResultColumnMetadata::display_size() const {
+  return display_size_;
+}
+inline void ResultColumnMetadata::set_display_size(::google::protobuf::int32 value) {
+  set_has_display_size();
+  display_size_ = value;
+}
+
+// optional bool is_aliased = 12;
+inline bool ResultColumnMetadata::has_is_aliased() const {
+  return (_has_bits_[0] & 0x00000800u) != 0;
+}
+inline void ResultColumnMetadata::set_has_is_aliased() {
+  _has_bits_[0] |= 0x00000800u;
+}
+inline void ResultColumnMetadata::clear_has_is_aliased() {
+  _has_bits_[0] &= ~0x00000800u;
+}
+inline void ResultColumnMetadata::clear_is_aliased() {
+  is_aliased_ = false;
+  clear_has_is_aliased();
+}
+inline bool ResultColumnMetadata::is_aliased() const {
+  return is_aliased_;
+}
+inline void ResultColumnMetadata::set_is_aliased(bool value) {
+  set_has_is_aliased();
+  is_aliased_ = value;
+}
+
+// optional .exec.user.ColumnSearchability searchability = 13;
+inline bool ResultColumnMetadata::has_searchability() const {
+  return (_has_bits_[0] & 0x00001000u) != 0;
+}
+inline void ResultColumnMetadata::set_has_searchability() {
+  _has_bits_[0] |= 0x00001000u;
+}
+inline void ResultColumnMetadata::clear_has_searchability() {
+  _has_bits_[0] &= ~0x00001000u;
+}
+inline void ResultColumnMetadata::clear_searchability() {
+  searchability_ = 0;
+  clear_has_searchability();
+}
+inline ::exec::user::ColumnSearchability ResultColumnMetadata::searchability() const {
+  return static_cast< ::exec::user::ColumnSearchability >(searchability_);
+}
+inline void ResultColumnMetadata::set_searchability(::exec::user::ColumnSearchability value) {
+  assert(::exec::user::ColumnSearchability_IsValid(value));
+  set_has_searchability();
+  searchability_ = value;
+}
+
+// optional .exec.user.ColumnUpdatability updatability = 14;
+inline bool ResultColumnMetadata::has_updatability() const {
+  return (_has_bits_[0] & 0x00002000u) != 0;
+}
+inline void ResultColumnMetadata::set_has_updatability() {
+  _has_bits_[0] |= 0x00002000u;
+}
+inline void ResultColumnMetadata::clear_has_updatability() {
+  _has_bits_[0] &= ~0x00002000u;
+}
+inline void ResultColumnMetadata::clear_updatability() {
+  updatability_ = 0;
+  clear_has_updatability();
+}
+inline ::exec::user::ColumnUpdatability ResultColumnMetadata::updatability() const {
+  return static_cast< ::exec::user::ColumnUpdatability >(updatability_);
+}
+inline void ResultColumnMetadata::set_updatability(::exec::user::ColumnUpdatability value) {
+  assert(::exec::user::ColumnUpdatability_IsValid(value));
+  set_has_updatability();
+  updatability_ = value;
+}
+
+// optional bool auto_increment = 15;
+inline bool ResultColumnMetadata::has_auto_increment() const {
+  return (_has_bits_[0] & 0x00004000u) != 0;
+}
+inline void ResultColumnMetadata::set_has_auto_increment() {
+  _has_bits_[0] |= 0x00004000u;
+}
+inline void ResultColumnMetadata::clear_has_auto_increment() {
+  _has_bits_[0] &= ~0x00004000u;
+}
+inline void ResultColumnMetadata::clear_auto_increment() {
+  auto_increment_ = false;
+  clear_has_auto_increment();
+}
+inline bool ResultColumnMetadata::auto_increment() const {
+  return auto_increment_;
+}
+inline void ResultColumnMetadata::set_auto_increment(bool value) {
+  set_has_auto_increment();
+  auto_increment_ = value;
+}
+
+// optional bool case_sensitivity = 16;
+inline bool ResultColumnMetadata::has_case_sensitivity() const {
+  return (_has_bits_[0] & 0x00008000u) != 0;
+}
+inline void ResultColumnMetadata::set_has_case_sensitivity() {
+  _has_bits_[0] |= 0x00008000u;
+}
+inline void ResultColumnMetadata::clear_has_case_sensitivity() {
+  _has_bits_[0] &= ~0x00008000u;
+}
+inline void ResultColumnMetadata::clear_case_sensitivity() {
+  case_sensitivity_ = false;
+  clear_has_case_sensitivity();
+}
+inline bool ResultColumnMetadata::case_sensitivity() const {
+  return case_sensitivity_;
+}
+inline void ResultColumnMetadata::set_case_sensitivity(bool value) {
+  set_has_case_sensitivity();
+  case_sensitivity_ = value;
+}
+
+// optional bool sortable = 17;
+inline bool ResultColumnMetadata::has_sortable() const {
+  return (_has_bits_[0] & 0x00010000u) != 0;
+}
+inline void ResultColumnMetadata::set_has_sortable() {
+  _has_bits_[0] |= 0x00010000u;
+}
+inline void ResultColumnMetadata::clear_has_sortable() {
+  _has_bits_[0] &= ~0x00010000u;
+}
+inline void ResultColumnMetadata::clear_sortable() {
+  sortable_ = false;
+  clear_has_sortable();
+}
+inline bool ResultColumnMetadata::sortable() const {
+  return sortable_;
+}
+inline void ResultColumnMetadata::set_sortable(bool value) {
+  set_has_sortable();
+  sortable_ = value;
+}
+
+// optional string class_name = 18;
+inline bool ResultColumnMetadata::has_class_name() const {
+  return (_has_bits_[0] & 0x00020000u) != 0;
+}
+inline void ResultColumnMetadata::set_has_class_name() {
+  _has_bits_[0] |= 0x00020000u;
+}
+inline void ResultColumnMetadata::clear_has_class_name() {
+  _has_bits_[0] &= ~0x00020000u;
+}
+inline void ResultColumnMetadata::clear_class_name() {
+  if (class_name_ != &::google::protobuf::internal::kEmptyString) {
+    class_name_->clear();
+  }
+  clear_has_class_name();
+}
+inline const ::std::string& ResultColumnMetadata::class_name() const {
+  return *class_name_;
+}
+inline void ResultColumnMetadata::set_class_name(const ::std::string& value) {
+  set_has_class_name();
+  if (class_name_ == &::google::protobuf::internal::kEmptyString) {
+    class_name_ = new ::std::string;
+  }
+  class_name_->assign(value);
+}
+inline void ResultColumnMetadata::set_class_name(const char* value) {
+  set_has_class_name();
+  if (class_name_ == &::google::protobuf::internal::kEmptyString) {
+    class_name_ = new ::std::string;
+  }
+  class_name_->assign(value);
+}
+inline void ResultColumnMetadata::set_class_name(const char* value, size_t size) {
+  set_has_class_name();
+  if (class_name_ == &::google::protobuf::internal::kEmptyString) {
+    class_name_ = new ::std::string;
+  }
+  class_name_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* ResultColumnMetadata::mutable_class_name() {
+  set_has_class_name();
+  if (class_name_ == &::google::protobuf::internal::kEmptyString) {
+    class_name_ = new ::std::string;
+  }
+  return class_name_;
+}
+inline ::std::string* ResultColumnMetadata::release_class_name() {
+  clear_has_class_name();
+  if (class_name_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = class_name_;
+    class_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void ResultColumnMetadata::set_allocated_class_name(::std::string* class_name) {
+  if (class_name_ != &::google::protobuf::internal::kEmptyString) {
+    delete class_name_;
+  }
+  if (class_name) {
+    set_has_class_name();
+    class_name_ = class_name;
+  } else {
+    clear_has_class_name();
+    class_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// optional bool is_currency = 20;
+inline bool ResultColumnMetadata::has_is_currency() const {
+  return (_has_bits_[0] & 0x00040000u) != 0;
+}
+inline void ResultColumnMetadata::set_has_is_currency() {
+  _has_bits_[0] |= 0x00040000u;
+}
+inline void ResultColumnMetadata::clear_has_is_currency() {
+  _has_bits_[0] &= ~0x00040000u;
+}
+inline void ResultColumnMetadata::clear_is_currency() {
+  is_currency_ = false;
+  clear_has_is_currency();
+}
+inline bool ResultColumnMetadata::is_currency() const {
+  return is_currency_;
+}
+inline void ResultColumnMetadata::set_is_currency(bool value) {
+  set_has_is_currency();
+  is_currency_ = value;
+}
+
+// -------------------------------------------------------------------
+
+// PreparedStatementHandle
+
+// optional bytes server_info = 1;
+inline bool PreparedStatementHandle::has_server_info() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void PreparedStatementHandle::set_has_server_info() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void PreparedStatementHandle::clear_has_server_info() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void PreparedStatementHandle::clear_server_info() {
+  if (server_info_ != &::google::protobuf::internal::kEmptyString) {
+    server_info_->clear();
+  }
+  clear_has_server_info();
+}
+inline const ::std::string& PreparedStatementHandle::server_info() const {
+  return *server_info_;
+}
+inline void PreparedStatementHandle::set_server_info(const ::std::string& value) {
+  set_has_server_info();
+  if (server_info_ == &::google::protobuf::internal::kEmptyString) {
+    server_info_ = new ::std::string;
+  }
+  server_info_->assign(value);
+}
+inline void PreparedStatementHandle::set_server_info(const char* value) {
+  set_has_server_info();
+  if (server_info_ == &::google::protobuf::internal::kEmptyString) {
+    server_info_ = new ::std::string;
+  }
+  server_info_->assign(value);
+}
+inline void PreparedStatementHandle::set_server_info(const void* value, size_t size) {
+  set_has_server_info();
+  if (server_info_ == &::google::protobuf::internal::kEmptyString) {
+    server_info_ = new ::std::string;
+  }
+  server_info_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* PreparedStatementHandle::mutable_server_info() {
+  set_has_server_info();
+  if (server_info_ == &::google::protobuf::internal::kEmptyString) {
+    server_info_ = new ::std::string;
+  }
+  return server_info_;
+}
+inline ::std::string* PreparedStatementHandle::release_server_info() {
+  clear_has_server_info();
+  if (server_info_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = server_info_;
+    server_info_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void PreparedStatementHandle::set_allocated_server_info(::std::string* server_info) {
+  if (server_info_ != &::google::protobuf::internal::kEmptyString) {
+    delete server_info_;
+  }
+  if (server_info) {
+    set_has_server_info();
+    server_info_ = server_info;
+  } else {
+    clear_has_server_info();
+    server_info_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// -------------------------------------------------------------------
+
+// PreparedStatement
+
+// repeated .exec.user.ResultColumnMetadata columns = 1;
+inline int PreparedStatement::columns_size() const {
+  return columns_.size();
+}
+inline void PreparedStatement::clear_columns() {
+  columns_.Clear();
+}
+inline const ::exec::user::ResultColumnMetadata& PreparedStatement::columns(int index) const {
+  return columns_.Get(index);
+}
+inline ::exec::user::ResultColumnMetadata* PreparedStatement::mutable_columns(int index) {
+  return columns_.Mutable(index);
+}
+inline ::exec::user::ResultColumnMetadata* PreparedStatement::add_columns() {
+  return columns_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::exec::user::ResultColumnMetadata >&
+PreparedStatement::columns() const {
+  return columns_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::exec::user::ResultColumnMetadata >*
+PreparedStatement::mutable_columns() {
+  return &columns_;
+}
+
+// optional .exec.user.PreparedStatementHandle server_handle = 2;
+inline bool PreparedStatement::has_server_handle() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void PreparedStatement::set_has_server_handle() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void PreparedStatement::clear_has_server_handle() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void PreparedStatement::clear_server_handle() {
+  if (server_handle_ != NULL) server_handle_->::exec::user::PreparedStatementHandle::Clear();
+  clear_has_server_handle();
+}
+inline const ::exec::user::PreparedStatementHandle& PreparedStatement::server_handle() const {
+  return server_handle_ != NULL ? *server_handle_ : *default_instance_->server_handle_;
+}
+inline ::exec::user::PreparedStatementHandle* PreparedStatement::mutable_server_handle() {
+  set_has_server_handle();
+  if (server_handle_ == NULL) server_handle_ = new ::exec::user::PreparedStatementHandle;
+  return server_handle_;
+}
+inline ::exec::user::PreparedStatementHandle* PreparedStatement::release_server_handle() {
+  clear_has_server_handle();
+  ::exec::user::PreparedStatementHandle* temp = server_handle_;
+  server_handle_ = NULL;
+  return temp;
+}
+inline void PreparedStatement::set_allocated_server_handle(::exec::user::PreparedStatementHandle* server_handle) {
+  delete server_handle_;
+  server_handle_ = server_handle;
+  if (server_handle) {
+    set_has_server_handle();
+  } else {
+    clear_has_server_handle();
+  }
+}
+
+// -------------------------------------------------------------------
+
+// CreatePreparedStatementResp
+
+// optional .exec.user.RequestStatus status = 1;
+inline bool CreatePreparedStatementResp::has_status() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void CreatePreparedStatementResp::set_has_status() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void CreatePreparedStatementResp::clear_has_status() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void CreatePreparedStatementResp::clear_status() {
+  status_ = 0;
+  clear_has_status();
+}
+inline ::exec::user::RequestStatus CreatePreparedStatementResp::status() const {
+  return static_cast< ::exec::user::RequestStatus >(status_);
+}
+inline void CreatePreparedStatementResp::set_status(::exec::user::RequestStatus value) {
+  assert(::exec::user::RequestStatus_IsValid(value));
+  set_has_status();
+  status_ = value;
+}
+
+// optional .exec.user.PreparedStatement prepared_statement = 2;
+inline bool CreatePreparedStatementResp::has_prepared_statement() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void CreatePreparedStatementResp::set_has_prepared_statement() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void CreatePreparedStatementResp::clear_has_prepared_statement() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void CreatePreparedStatementResp::clear_prepared_statement() {
+  if (prepared_statement_ != NULL) prepared_statement_->::exec::user::PreparedStatement::Clear();
+  clear_has_prepared_statement();
+}
+inline const ::exec::user::PreparedStatement& CreatePreparedStatementResp::prepared_statement() const {
+  return prepared_statement_ != NULL ? *prepared_statement_ : *default_instance_->prepared_statement_;
+}
+inline ::exec::user::PreparedStatement* CreatePreparedStatementResp::mutable_prepared_statement() {
+  set_has_prepared_statement();
+  if (prepared_statement_ == NULL) prepared_statement_ = new ::exec::user::PreparedStatement;
+  return prepared_statement_;
+}
+inline ::exec::user::PreparedStatement* CreatePreparedStatementResp::release_prepared_statement() {
+  clear_has_prepared_statement();
+  ::exec::user::PreparedStatement* temp = prepared_statement_;
+  prepared_statement_ = NULL;
+  return temp;
+}
+inline void CreatePreparedStatementResp::set_allocated_prepared_statement(::exec::user::PreparedStatement* prepared_statement) {
+  delete prepared_statement_;
+  prepared_statement_ = prepared_statement;
+  if (prepared_statement) {
+    set_has_prepared_statement();
+  } else {
+    clear_has_prepared_statement();
+  }
+}
+
+// optional .exec.shared.DrillPBError error = 3;
+inline bool CreatePreparedStatementResp::has_error() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void CreatePreparedStatementResp::set_has_error() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void CreatePreparedStatementResp::clear_has_error() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void CreatePreparedStatementResp::clear_error() {
+  if (error_ != NULL) error_->::exec::shared::DrillPBError::Clear();
+  clear_has_error();
+}
+inline const ::exec::shared::DrillPBError& CreatePreparedStatementResp::error() const {
+  return error_ != NULL ? *error_ : *default_instance_->error_;
+}
+inline ::exec::shared::DrillPBError* CreatePreparedStatementResp::mutable_error() {
+  set_has_error();
+  if (error_ == NULL) error_ = new ::exec::shared::DrillPBError;
+  return error_;
+}
+inline ::exec::shared::DrillPBError* CreatePreparedStatementResp::release_error() {
+  clear_has_error();
+  ::exec::shared::DrillPBError* temp = error_;
+  error_ = NULL;
+  return temp;
+}
+inline void CreatePreparedStatementResp::set_allocated_error(::exec::shared::DrillPBError* error) {
+  delete error_;
+  error_ = error;
+  if (error) {
+    set_has_error();
+  } else {
+    clear_has_error();
+  }
+}
+
+// -------------------------------------------------------------------
+
+// RunQuery
+
+// optional .exec.user.QueryResultsMode results_mode = 1;
+inline bool RunQuery::has_results_mode() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void RunQuery::set_has_results_mode() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void RunQuery::clear_has_results_mode() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void RunQuery::clear_results_mode() {
+  results_mode_ = 1;
+  clear_has_results_mode();
+}
+inline ::exec::user::QueryResultsMode RunQuery::results_mode() const {
+  return static_cast< ::exec::user::QueryResultsMode >(results_mode_);
+}
+inline void RunQuery::set_results_mode(::exec::user::QueryResultsMode value) {
+  assert(::exec::user::QueryResultsMode_IsValid(value));
+  set_has_results_mode();
+  results_mode_ = value;
+}
+
+// optional .exec.shared.QueryType type = 2;
+inline bool RunQuery::has_type() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void RunQuery::set_has_type() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void RunQuery::clear_has_type() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void RunQuery::clear_type() {
+  type_ = 1;
+  clear_has_type();
+}
+inline ::exec::shared::QueryType RunQuery::type() const {
+  return static_cast< ::exec::shared::QueryType >(type_);
+}
+inline void RunQuery::set_type(::exec::shared::QueryType value) {
+  assert(::exec::shared::QueryType_IsValid(value));
+  set_has_type();
+  type_ = value;
+}
+
+// optional string plan = 3;
+inline bool RunQuery::has_plan() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void RunQuery::set_has_plan() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void RunQuery::clear_has_plan() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void RunQuery::clear_plan() {
+  if (plan_ != &::google::protobuf::internal::kEmptyString) {
+    plan_->clear();
+  }
+  clear_has_plan();
+}
+inline const ::std::string& RunQuery::plan() const {
+  return *plan_;
+}
+inline void RunQuery::set_plan(const ::std::string& value) {
+  set_has_plan();
+  if (plan_ == &::google::protobuf::internal::kEmptyString) {
+    plan_ = new ::std::string;
+  }
+  plan_->assign(value);
+}
+inline void RunQuery::set_plan(const char* value) {
+  set_has_plan();
+  if (plan_ == &::google::protobuf::internal::kEmptyString) {
+    plan_ = new ::std::string;
+  }
+  plan_->assign(value);
+}
+inline void RunQuery::set_plan(const char* value, size_t size) {
+  set_has_plan();
+  if (plan_ == &::google::protobuf::internal::kEmptyString) {
+    plan_ = new ::std::string;
+  }
+  plan_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* RunQuery::mutable_plan() {
+  set_has_plan();
+  if (plan_ == &::google::protobuf::internal::kEmptyString) {
+    plan_ = new ::std::string;
+  }
+  return plan_;
+}
+inline ::std::string* RunQuery::release_plan() {
+  clear_has_plan();
+  if (plan_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = plan_;
+    plan_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void RunQuery::set_allocated_plan(::std::string* plan) {
+  if (plan_ != &::google::protobuf::internal::kEmptyString) {
+    delete plan_;
+  }
+  if (plan) {
+    set_has_plan();
+    plan_ = plan;
+  } else {
+    clear_has_plan();
+    plan_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// repeated .exec.bit.control.PlanFragment fragments = 4;
+inline int RunQuery::fragments_size() const {
+  return fragments_.size();
+}
+inline void RunQuery::clear_fragments() {
+  fragments_.Clear();
+}
+inline const ::exec::bit::control::PlanFragment& RunQuery::fragments(int index) const {
+  return fragments_.Get(index);
+}
+inline ::exec::bit::control::PlanFragment* RunQuery::mutable_fragments(int index) {
+  return fragments_.Mutable(index);
+}
+inline ::exec::bit::control::PlanFragment* RunQuery::add_fragments() {
+  return fragments_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::exec::bit::control::PlanFragment >&
+RunQuery::fragments() const {
+  return fragments_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::exec::bit::control::PlanFragment >*
+RunQuery::mutable_fragments() {
+  return &fragments_;
+}
+
+// optional .exec.user.PreparedStatementHandle prepared_statement_handle = 5;
+inline bool RunQuery::has_prepared_statement_handle() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void RunQuery::set_has_prepared_statement_handle() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void RunQuery::clear_has_prepared_statement_handle() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void RunQuery::clear_prepared_statement_handle() {
+  if (prepared_statement_handle_ != NULL) prepared_statement_handle_->::exec::user::PreparedStatementHandle::Clear();
+  clear_has_prepared_statement_handle();
+}
+inline const ::exec::user::PreparedStatementHandle& RunQuery::prepared_statement_handle() const {
+  return prepared_statement_handle_ != NULL ? *prepared_statement_handle_ : *default_instance_->prepared_statement_handle_;
+}
+inline ::exec::user::PreparedStatementHandle* RunQuery::mutable_prepared_statement_handle() {
+  set_has_prepared_statement_handle();
+  if (prepared_statement_handle_ == NULL) prepared_statement_handle_ = new ::exec::user::PreparedStatementHandle;
+  return prepared_statement_handle_;
+}
+inline ::exec::user::PreparedStatementHandle* RunQuery::release_prepared_statement_handle() {
+  clear_has_prepared_statement_handle();
+  ::exec::user::PreparedStatementHandle* temp = prepared_statement_handle_;
+  prepared_statement_handle_ = NULL;
+  return temp;
+}
+inline void RunQuery::set_allocated_prepared_statement_handle(::exec::user::PreparedStatementHandle* prepared_statement_handle) {
+  delete prepared_statement_handle_;
+  prepared_statement_handle_ = prepared_statement_handle;
+  if (prepared_statement_handle) {
+    set_has_prepared_statement_handle();
+  } else {
+    clear_has_prepared_statement_handle();
+  }
+}
+
 
 // @@protoc_insertion_point(namespace_scope)
 
@@ -1530,6 +8607,18 @@ template <>
 inline const EnumDescriptor* GetEnumDescriptor< ::exec::user::HandshakeStatus>() {
   return ::exec::user::HandshakeStatus_descriptor();
 }
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::exec::user::RequestStatus>() {
+  return ::exec::user::RequestStatus_descriptor();
+}
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::exec::user::ColumnSearchability>() {
+  return ::exec::user::ColumnSearchability_descriptor();
+}
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::exec::user::ColumnUpdatability>() {
+  return ::exec::user::ColumnUpdatability_descriptor();
+}
 
 }  // namespace google
 }  // namespace protobuf
diff --git a/contrib/native/client/src/protobuf/UserBitShared.pb.cc b/contrib/native/client/src/protobuf/UserBitShared.pb.cc
index c314a1da3..abd6b4ea1 100644
--- a/contrib/native/client/src/protobuf/UserBitShared.pb.cc
+++ b/contrib/native/client/src/protobuf/UserBitShared.pb.cc
@@ -81,6 +81,12 @@ const ::google::protobuf::internal::GeneratedMessageReflection*
 const ::google::protobuf::Descriptor* MetricValue_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   MetricValue_reflection_ = NULL;
+const ::google::protobuf::Descriptor* Registry_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  Registry_reflection_ = NULL;
+const ::google::protobuf::Descriptor* Jar_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  Jar_reflection_ = NULL;
 const ::google::protobuf::EnumDescriptor* RpcChannel_descriptor_ = NULL;
 const ::google::protobuf::EnumDescriptor* QueryType_descriptor_ = NULL;
 const ::google::protobuf::EnumDescriptor* FragmentState_descriptor_ = NULL;
@@ -454,6 +460,37 @@ void protobuf_AssignDesc_UserBitShared_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(MetricValue));
+  Registry_descriptor_ = file->message_type(19);
+  static const int Registry_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Registry, jar_),
+  };
+  Registry_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      Registry_descriptor_,
+      Registry::default_instance_,
+      Registry_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Registry, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Registry, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(Registry));
+  Jar_descriptor_ = file->message_type(20);
+  static const int Jar_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Jar, name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Jar, function_signature_),
+  };
+  Jar_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      Jar_descriptor_,
+      Jar::default_instance_,
+      Jar_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Jar, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Jar, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(Jar));
   RpcChannel_descriptor_ = file->enum_type(0);
   QueryType_descriptor_ = file->enum_type(1);
   FragmentState_descriptor_ = file->enum_type(2);
@@ -508,6 +545,10 @@ void protobuf_RegisterTypes(const ::std::string&) {
     StreamProfile_descriptor_, &StreamProfile::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     MetricValue_descriptor_, &MetricValue::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    Registry_descriptor_, &Registry::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    Jar_descriptor_, &Jar::default_instance());
 }
 
 }  // namespace
@@ -553,6 +594,10 @@ void protobuf_ShutdownFile_UserBitShared_2eproto() {
   delete StreamProfile_reflection_;
   delete MetricValue::default_instance_;
   delete MetricValue_reflection_;
+  delete Registry::default_instance_;
+  delete Registry_reflection_;
+  delete Jar::default_instance_;
+  delete Jar_reflection_;
 }
 
 void protobuf_AddDesc_UserBitShared_2eproto() {
@@ -650,32 +695,36 @@ void protobuf_AddDesc_UserBitShared_2eproto() {
     "\017\n\007records\030\001 \001(\003\022\017\n\007batches\030\002 \001(\003\022\017\n\007sch"
     "emas\030\003 \001(\003\"J\n\013MetricValue\022\021\n\tmetric_id\030\001"
     " \001(\005\022\022\n\nlong_value\030\002 \001(\003\022\024\n\014double_value"
-    "\030\003 \001(\001*5\n\nRpcChannel\022\017\n\013BIT_CONTROL\020\000\022\014\n"
-    "\010BIT_DATA\020\001\022\010\n\004USER\020\002*/\n\tQueryType\022\007\n\003SQ"
-    "L\020\001\022\013\n\007LOGICAL\020\002\022\014\n\010PHYSICAL\020\003*\207\001\n\rFragm"
-    "entState\022\013\n\007SENDING\020\000\022\027\n\023AWAITING_ALLOCA"
-    "TION\020\001\022\013\n\007RUNNING\020\002\022\014\n\010FINISHED\020\003\022\r\n\tCAN"
-    "CELLED\020\004\022\n\n\006FAILED\020\005\022\032\n\026CANCELLATION_REQ"
-    "UESTED\020\006*\335\005\n\020CoreOperatorType\022\021\n\rSINGLE_"
-    "SENDER\020\000\022\024\n\020BROADCAST_SENDER\020\001\022\n\n\006FILTER"
-    "\020\002\022\022\n\016HASH_AGGREGATE\020\003\022\r\n\tHASH_JOIN\020\004\022\016\n"
-    "\nMERGE_JOIN\020\005\022\031\n\025HASH_PARTITION_SENDER\020\006"
-    "\022\t\n\005LIMIT\020\007\022\024\n\020MERGING_RECEIVER\020\010\022\034\n\030ORD"
-    "ERED_PARTITION_SENDER\020\t\022\013\n\007PROJECT\020\n\022\026\n\022"
-    "UNORDERED_RECEIVER\020\013\022\020\n\014RANGE_SENDER\020\014\022\n"
-    "\n\006SCREEN\020\r\022\034\n\030SELECTION_VECTOR_REMOVER\020\016"
-    "\022\027\n\023STREAMING_AGGREGATE\020\017\022\016\n\nTOP_N_SORT\020"
-    "\020\022\021\n\rEXTERNAL_SORT\020\021\022\t\n\005TRACE\020\022\022\t\n\005UNION"
-    "\020\023\022\014\n\010OLD_SORT\020\024\022\032\n\026PARQUET_ROW_GROUP_SC"
-    "AN\020\025\022\021\n\rHIVE_SUB_SCAN\020\026\022\025\n\021SYSTEM_TABLE_"
-    "SCAN\020\027\022\021\n\rMOCK_SUB_SCAN\020\030\022\022\n\016PARQUET_WRI"
-    "TER\020\031\022\023\n\017DIRECT_SUB_SCAN\020\032\022\017\n\013TEXT_WRITE"
-    "R\020\033\022\021\n\rTEXT_SUB_SCAN\020\034\022\021\n\rJSON_SUB_SCAN\020"
-    "\035\022\030\n\024INFO_SCHEMA_SUB_SCAN\020\036\022\023\n\017COMPLEX_T"
-    "O_JSON\020\037\022\025\n\021PRODUCER_CONSUMER\020 \022\022\n\016HBASE"
-    "_SUB_SCAN\020!\022\n\n\006WINDOW\020\"\022\024\n\020NESTED_LOOP_J"
-    "OIN\020#\022\021\n\rAVRO_SUB_SCAN\020$B.\n\033org.apache.d"
-    "rill.exec.protoB\rUserBitSharedH\001", 4432);
+    "\030\003 \001(\001\")\n\010Registry\022\035\n\003jar\030\001 \003(\0132\020.exec.s"
+    "hared.Jar\"/\n\003Jar\022\014\n\004name\030\001 \001(\t\022\032\n\022functi"
+    "on_signature\030\002 \003(\t*5\n\nRpcChannel\022\017\n\013BIT_"
+    "CONTROL\020\000\022\014\n\010BIT_DATA\020\001\022\010\n\004USER\020\002*V\n\tQue"
+    "ryType\022\007\n\003SQL\020\001\022\013\n\007LOGICAL\020\002\022\014\n\010PHYSICAL"
+    "\020\003\022\r\n\tEXECUTION\020\004\022\026\n\022PREPARED_STATEMENT\020"
+    "\005*\207\001\n\rFragmentState\022\013\n\007SENDING\020\000\022\027\n\023AWAI"
+    "TING_ALLOCATION\020\001\022\013\n\007RUNNING\020\002\022\014\n\010FINISH"
+    "ED\020\003\022\r\n\tCANCELLED\020\004\022\n\n\006FAILED\020\005\022\032\n\026CANCE"
+    "LLATION_REQUESTED\020\006*\335\005\n\020CoreOperatorType"
+    "\022\021\n\rSINGLE_SENDER\020\000\022\024\n\020BROADCAST_SENDER\020"
+    "\001\022\n\n\006FILTER\020\002\022\022\n\016HASH_AGGREGATE\020\003\022\r\n\tHAS"
+    "H_JOIN\020\004\022\016\n\nMERGE_JOIN\020\005\022\031\n\025HASH_PARTITI"
+    "ON_SENDER\020\006\022\t\n\005LIMIT\020\007\022\024\n\020MERGING_RECEIV"
+    "ER\020\010\022\034\n\030ORDERED_PARTITION_SENDER\020\t\022\013\n\007PR"
+    "OJECT\020\n\022\026\n\022UNORDERED_RECEIVER\020\013\022\020\n\014RANGE"
+    "_SENDER\020\014\022\n\n\006SCREEN\020\r\022\034\n\030SELECTION_VECTO"
+    "R_REMOVER\020\016\022\027\n\023STREAMING_AGGREGATE\020\017\022\016\n\n"
+    "TOP_N_SORT\020\020\022\021\n\rEXTERNAL_SORT\020\021\022\t\n\005TRACE"
+    "\020\022\022\t\n\005UNION\020\023\022\014\n\010OLD_SORT\020\024\022\032\n\026PARQUET_R"
+    "OW_GROUP_SCAN\020\025\022\021\n\rHIVE_SUB_SCAN\020\026\022\025\n\021SY"
+    "STEM_TABLE_SCAN\020\027\022\021\n\rMOCK_SUB_SCAN\020\030\022\022\n\016"
+    "PARQUET_WRITER\020\031\022\023\n\017DIRECT_SUB_SCAN\020\032\022\017\n"
+    "\013TEXT_WRITER\020\033\022\021\n\rTEXT_SUB_SCAN\020\034\022\021\n\rJSO"
+    "N_SUB_SCAN\020\035\022\030\n\024INFO_SCHEMA_SUB_SCAN\020\036\022\023"
+    "\n\017COMPLEX_TO_JSON\020\037\022\025\n\021PRODUCER_CONSUMER"
+    "\020 \022\022\n\016HBASE_SUB_SCAN\020!\022\n\n\006WINDOW\020\"\022\024\n\020NE"
+    "STED_LOOP_JOIN\020#\022\021\n\rAVRO_SUB_SCAN\020$B.\n\033o"
+    "rg.apache.drill.exec.protoB\rUserBitShare"
+    "dH\001", 4563);
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
     "UserBitShared.proto", &protobuf_RegisterTypes);
   UserCredentials::default_instance_ = new UserCredentials();
@@ -701,6 +750,8 @@ void protobuf_AddDesc_UserBitShared_2eproto() {
   OperatorProfile::default_instance_ = new OperatorProfile();
   StreamProfile::default_instance_ = new StreamProfile();
   MetricValue::default_instance_ = new MetricValue();
+  Registry::default_instance_ = new Registry();
+  Jar::default_instance_ = new Jar();
   UserCredentials::default_instance_->InitAsDefaultInstance();
   QueryId::default_instance_->InitAsDefaultInstance();
   DrillPBError::default_instance_->InitAsDefaultInstance();
@@ -720,6 +771,8 @@ void protobuf_AddDesc_UserBitShared_2eproto() {
   OperatorProfile::default_instance_->InitAsDefaultInstance();
   StreamProfile::default_instance_->InitAsDefaultInstance();
   MetricValue::default_instance_->InitAsDefaultInstance();
+  Registry::default_instance_->InitAsDefaultInstance();
+  Jar::default_instance_->InitAsDefaultInstance();
   ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_UserBitShared_2eproto);
 }
 
@@ -753,6 +806,8 @@ bool QueryType_IsValid(int value) {
     case 1:
     case 2:
     case 3:
+    case 4:
+    case 5:
       return true;
     default:
       return false;
@@ -8134,6 +8189,482 @@ void MetricValue::Swap(MetricValue* other) {
 }
 
 
+// ===================================================================
+
+#ifndef _MSC_VER
+const int Registry::kJarFieldNumber;
+#endif  // !_MSC_VER
+
+Registry::Registry()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void Registry::InitAsDefaultInstance() {
+}
+
+Registry::Registry(const Registry& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void Registry::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+Registry::~Registry() {
+  SharedDtor();
+}
+
+void Registry::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void Registry::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* Registry::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return Registry_descriptor_;
+}
+
+const Registry& Registry::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_UserBitShared_2eproto();
+  return *default_instance_;
+}
+
+Registry* Registry::default_instance_ = NULL;
+
+Registry* Registry::New() const {
+  return new Registry;
+}
+
+void Registry::Clear() {
+  jar_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool Registry::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .exec.shared.Jar jar = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_jar:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_jar()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(10)) goto parse_jar;
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void Registry::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // repeated .exec.shared.Jar jar = 1;
+  for (int i = 0; i < this->jar_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->jar(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* Registry::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // repeated .exec.shared.Jar jar = 1;
+  for (int i = 0; i < this->jar_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->jar(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int Registry::ByteSize() const {
+  int total_size = 0;
+
+  // repeated .exec.shared.Jar jar = 1;
+  total_size += 1 * this->jar_size();
+  for (int i = 0; i < this->jar_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->jar(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void Registry::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const Registry* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const Registry*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void Registry::MergeFrom(const Registry& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  jar_.MergeFrom(from.jar_);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void Registry::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void Registry::CopyFrom(const Registry& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Registry::IsInitialized() const {
+
+  return true;
+}
+
+void Registry::Swap(Registry* other) {
+  if (other != this) {
+    jar_.Swap(&other->jar_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata Registry::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = Registry_descriptor_;
+  metadata.reflection = Registry_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int Jar::kNameFieldNumber;
+const int Jar::kFunctionSignatureFieldNumber;
+#endif  // !_MSC_VER
+
+Jar::Jar()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void Jar::InitAsDefaultInstance() {
+}
+
+Jar::Jar(const Jar& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void Jar::SharedCtor() {
+  _cached_size_ = 0;
+  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+Jar::~Jar() {
+  SharedDtor();
+}
+
+void Jar::SharedDtor() {
+  if (name_ != &::google::protobuf::internal::kEmptyString) {
+    delete name_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void Jar::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* Jar::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return Jar_descriptor_;
+}
+
+const Jar& Jar::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_UserBitShared_2eproto();
+  return *default_instance_;
+}
+
+Jar* Jar::default_instance_ = NULL;
+
+Jar* Jar::New() const {
+  return new Jar;
+}
+
+void Jar::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (has_name()) {
+      if (name_ != &::google::protobuf::internal::kEmptyString) {
+        name_->clear();
+      }
+    }
+  }
+  function_signature_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool Jar::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string name = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->name().data(), this->name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(18)) goto parse_function_signature;
+        break;
+      }
+
+      // repeated string function_signature = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_function_signature:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->add_function_signature()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->function_signature(this->function_signature_size() - 1).data(),
+            this->function_signature(this->function_signature_size() - 1).length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(18)) goto parse_function_signature;
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void Jar::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // optional string name = 1;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      1, this->name(), output);
+  }
+
+  // repeated string function_signature = 2;
+  for (int i = 0; i < this->function_signature_size(); i++) {
+  ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+    this->function_signature(i).data(), this->function_signature(i).length(),
+    ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      2, this->function_signature(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* Jar::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // optional string name = 1;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->name(), target);
+  }
+
+  // repeated string function_signature = 2;
+  for (int i = 0; i < this->function_signature_size(); i++) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->function_signature(i).data(), this->function_signature(i).length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteStringToArray(2, this->function_signature(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int Jar::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string name = 1;
+    if (has_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->name());
+    }
+
+  }
+  // repeated string function_signature = 2;
+  total_size += 1 * this->function_signature_size();
+  for (int i = 0; i < this->function_signature_size(); i++) {
+    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
+      this->function_signature(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void Jar::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const Jar* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const Jar*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void Jar::MergeFrom(const Jar& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  function_signature_.MergeFrom(from.function_signature_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_name()) {
+      set_name(from.name());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void Jar::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void Jar::CopyFrom(const Jar& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Jar::IsInitialized() const {
+
+  return true;
+}
+
+void Jar::Swap(Jar* other) {
+  if (other != this) {
+    std::swap(name_, other->name_);
+    function_signature_.Swap(&other->function_signature_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata Jar::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = Jar_descriptor_;
+  metadata.reflection = Jar_reflection_;
+  return metadata;
+}
+
+
 // @@protoc_insertion_point(namespace_scope)
 
 }  // namespace shared
diff --git a/contrib/native/client/src/protobuf/UserBitShared.pb.h b/contrib/native/client/src/protobuf/UserBitShared.pb.h
index 41279ca18..82db444d4 100644
--- a/contrib/native/client/src/protobuf/UserBitShared.pb.h
+++ b/contrib/native/client/src/protobuf/UserBitShared.pb.h
@@ -57,6 +57,8 @@ class MinorFragmentProfile;
 class OperatorProfile;
 class StreamProfile;
 class MetricValue;
+class Registry;
+class Jar;
 
 enum DrillPBError_ErrorType {
   DrillPBError_ErrorType_CONNECTION = 0,
@@ -152,11 +154,13 @@ inline bool RpcChannel_Parse(
 enum QueryType {
   SQL = 1,
   LOGICAL = 2,
-  PHYSICAL = 3
+  PHYSICAL = 3,
+  EXECUTION = 4,
+  PREPARED_STATEMENT = 5
 };
 bool QueryType_IsValid(int value);
 const QueryType QueryType_MIN = SQL;
-const QueryType QueryType_MAX = PHYSICAL;
+const QueryType QueryType_MAX = PREPARED_STATEMENT;
 const int QueryType_ARRAYSIZE = QueryType_MAX + 1;
 
 const ::google::protobuf::EnumDescriptor* QueryType_descriptor();
@@ -2751,6 +2755,195 @@ class MetricValue : public ::google::protobuf::Message {
   void InitAsDefaultInstance();
   static MetricValue* default_instance_;
 };
+// -------------------------------------------------------------------
+
+class Registry : public ::google::protobuf::Message {
+ public:
+  Registry();
+  virtual ~Registry();
+
+  Registry(const Registry& from);
+
+  inline Registry& operator=(const Registry& 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 Registry& default_instance();
+
+  void Swap(Registry* other);
+
+  // implements Message ----------------------------------------------
+
+  Registry* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const Registry& from);
+  void MergeFrom(const Registry& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .exec.shared.Jar jar = 1;
+  inline int jar_size() const;
+  inline void clear_jar();
+  static const int kJarFieldNumber = 1;
+  inline const ::exec::shared::Jar& jar(int index) const;
+  inline ::exec::shared::Jar* mutable_jar(int index);
+  inline ::exec::shared::Jar* add_jar();
+  inline const ::google::protobuf::RepeatedPtrField< ::exec::shared::Jar >&
+      jar() const;
+  inline ::google::protobuf::RepeatedPtrField< ::exec::shared::Jar >*
+      mutable_jar();
+
+  // @@protoc_insertion_point(class_scope:exec.shared.Registry)
+ private:
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::RepeatedPtrField< ::exec::shared::Jar > jar_;
+
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
+
+  friend void  protobuf_AddDesc_UserBitShared_2eproto();
+  friend void protobuf_AssignDesc_UserBitShared_2eproto();
+  friend void protobuf_ShutdownFile_UserBitShared_2eproto();
+
+  void InitAsDefaultInstance();
+  static Registry* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class Jar : public ::google::protobuf::Message {
+ public:
+  Jar();
+  virtual ~Jar();
+
+  Jar(const Jar& from);
+
+  inline Jar& operator=(const Jar& 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 Jar& default_instance();
+
+  void Swap(Jar* other);
+
+  // implements Message ----------------------------------------------
+
+  Jar* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const Jar& from);
+  void MergeFrom(const Jar& 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);
+
+  // repeated string function_signature = 2;
+  inline int function_signature_size() const;
+  inline void clear_function_signature();
+  static const int kFunctionSignatureFieldNumber = 2;
+  inline const ::std::string& function_signature(int index) const;
+  inline ::std::string* mutable_function_signature(int index);
+  inline void set_function_signature(int index, const ::std::string& value);
+  inline void set_function_signature(int index, const char* value);
+  inline void set_function_signature(int index, const char* value, size_t size);
+  inline ::std::string* add_function_signature();
+  inline void add_function_signature(const ::std::string& value);
+  inline void add_function_signature(const char* value);
+  inline void add_function_signature(const char* value, size_t size);
+  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& function_signature() const;
+  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_function_signature();
+
+  // @@protoc_insertion_point(class_scope:exec.shared.Jar)
+ private:
+  inline void set_has_name();
+  inline void clear_has_name();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::std::string* name_;
+  ::google::protobuf::RepeatedPtrField< ::std::string> function_signature_;
+
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
+
+  friend void  protobuf_AddDesc_UserBitShared_2eproto();
+  friend void protobuf_AssignDesc_UserBitShared_2eproto();
+  friend void protobuf_ShutdownFile_UserBitShared_2eproto();
+
+  void InitAsDefaultInstance();
+  static Jar* default_instance_;
+};
 // ===================================================================
 
 
@@ -5935,6 +6128,153 @@ inline void MetricValue::set_double_value(double value) {
   double_value_ = value;
 }
 
+// -------------------------------------------------------------------
+
+// Registry
+
+// repeated .exec.shared.Jar jar = 1;
+inline int Registry::jar_size() const {
+  return jar_.size();
+}
+inline void Registry::clear_jar() {
+  jar_.Clear();
+}
+inline const ::exec::shared::Jar& Registry::jar(int index) const {
+  return jar_.Get(index);
+}
+inline ::exec::shared::Jar* Registry::mutable_jar(int index) {
+  return jar_.Mutable(index);
+}
+inline ::exec::shared::Jar* Registry::add_jar() {
+  return jar_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::exec::shared::Jar >&
+Registry::jar() const {
+  return jar_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::exec::shared::Jar >*
+Registry::mutable_jar() {
+  return &jar_;
+}
+
+// -------------------------------------------------------------------
+
+// Jar
+
+// optional string name = 1;
+inline bool Jar::has_name() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void Jar::set_has_name() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void Jar::clear_has_name() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void Jar::clear_name() {
+  if (name_ != &::google::protobuf::internal::kEmptyString) {
+    name_->clear();
+  }
+  clear_has_name();
+}
+inline const ::std::string& Jar::name() const {
+  return *name_;
+}
+inline void Jar::set_name(const ::std::string& value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::kEmptyString) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+}
+inline void Jar::set_name(const char* value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::kEmptyString) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+}
+inline void Jar::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* Jar::mutable_name() {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::kEmptyString) {
+    name_ = new ::std::string;
+  }
+  return name_;
+}
+inline ::std::string* Jar::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 Jar::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);
+  }
+}
+
+// repeated string function_signature = 2;
+inline int Jar::function_signature_size() const {
+  return function_signature_.size();
+}
+inline void Jar::clear_function_signature() {
+  function_signature_.Clear();
+}
+inline const ::std::string& Jar::function_signature(int index) const {
+  return function_signature_.Get(index);
+}
+inline ::std::string* Jar::mutable_function_signature(int index) {
+  return function_signature_.Mutable(index);
+}
+inline void Jar::set_function_signature(int index, const ::std::string& value) {
+  function_signature_.Mutable(index)->assign(value);
+}
+inline void Jar::set_function_signature(int index, const char* value) {
+  function_signature_.Mutable(index)->assign(value);
+}
+inline void Jar::set_function_signature(int index, const char* value, size_t size) {
+  function_signature_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* Jar::add_function_signature() {
+  return function_signature_.Add();
+}
+inline void Jar::add_function_signature(const ::std::string& value) {
+  function_signature_.Add()->assign(value);
+}
+inline void Jar::add_function_signature(const char* value) {
+  function_signature_.Add()->assign(value);
+}
+inline void Jar::add_function_signature(const char* value, size_t size) {
+  function_signature_.Add()->assign(reinterpret_cast<const char*>(value), size);
+}
+inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
+Jar::function_signature() const {
+  return function_signature_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::std::string>*
+Jar::mutable_function_signature() {
+  return &function_signature_;
+}
+
 
 // @@protoc_insertion_point(namespace_scope)