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

#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
#include "User.pb.h"

#include <algorithm>

#include <google/protobuf/stubs/common.h>
#include <google/protobuf/stubs/once.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/wire_format_lite_inl.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/reflection_ops.h>
#include <google/protobuf/wire_format.h>
// @@protoc_insertion_point(includes)

namespace exec {
namespace user {

namespace {

const ::google::protobuf::Descriptor* Property_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Property_reflection_ = NULL;
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* GetQueryPlanFragments_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  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* GetServerMetaReq_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  GetServerMetaReq_reflection_ = NULL;
const ::google::protobuf::Descriptor* ConvertSupport_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  ConvertSupport_reflection_ = NULL;
const ::google::protobuf::Descriptor* GetServerMetaResp_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  GetServerMetaResp_reflection_ = NULL;
const ::google::protobuf::Descriptor* ServerMeta_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  ServerMeta_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* SaslSupport_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;
const ::google::protobuf::EnumDescriptor* CollateSupport_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* CorrelationNamesSupport_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* DateTimeLiteralsSupport_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* GroupBySupport_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* IdentifierCasing_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* NullCollation_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* OrderBySupport_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* OuterJoinSupport_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* SubQuerySupport_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* UnionSupport_descriptor_ = NULL;

}  // namespace


void protobuf_AssignDesc_User_2eproto() {
  protobuf_AddDesc_User_2eproto();
  const ::google::protobuf::FileDescriptor* file =
    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
      "User.proto");
  GOOGLE_CHECK(file != NULL);
  Property_descriptor_ = file->message_type(0);
  static const int Property_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Property, key_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Property, value_),
  };
  Property_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      Property_descriptor_,
      Property::default_instance_,
      Property_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Property, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Property, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(Property));
  UserProperties_descriptor_ = file->message_type(1);
  static const int UserProperties_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserProperties, properties_),
  };
  UserProperties_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      UserProperties_descriptor_,
      UserProperties::default_instance_,
      UserProperties_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserProperties, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserProperties, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(UserProperties));
  RpcEndpointInfos_descriptor_ = file->message_type(2);
  static const int RpcEndpointInfos_offsets_[8] = {
    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_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RpcEndpointInfos, buildnumber_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RpcEndpointInfos, versionqualifier_),
  };
  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_[9] = {
    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_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserToBitHandshake, credentials_),
    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_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserToBitHandshake, sasl_support_),
  };
  UserToBitHandshake_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      UserToBitHandshake_descriptor_,
      UserToBitHandshake::default_instance_,
      UserToBitHandshake_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserToBitHandshake, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserToBitHandshake, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(UserToBitHandshake));
  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_),
  };
  RequestResults_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      RequestResults_descriptor_,
      RequestResults::default_instance_,
      RequestResults_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RequestResults, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RequestResults, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(RequestResults));
  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_),
  };
  GetQueryPlanFragments_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      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(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_[9] = {
    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_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BitToUserHandshake, authenticationmechanisms_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BitToUserHandshake, supported_methods_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BitToUserHandshake, encrypted_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BitToUserHandshake, maxwrappedsize_),
  };
  BitToUserHandshake_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      BitToUserHandshake_descriptor_,
      BitToUserHandshake::default_instance_,
      BitToUserHandshake_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BitToUserHandshake, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BitToUserHandshake, _unknown_fields_),
      -1,
      ::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));
  GetServerMetaReq_descriptor_ = file->message_type(26);
  static const int GetServerMetaReq_offsets_[1] = {
  };
  GetServerMetaReq_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      GetServerMetaReq_descriptor_,
      GetServerMetaReq::default_instance_,
      GetServerMetaReq_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetServerMetaReq, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetServerMetaReq, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(GetServerMetaReq));
  ConvertSupport_descriptor_ = file->message_type(27);
  static const int ConvertSupport_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConvertSupport, from_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConvertSupport, to_),
  };
  ConvertSupport_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      ConvertSupport_descriptor_,
      ConvertSupport::default_instance_,
      ConvertSupport_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConvertSupport, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConvertSupport, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(ConvertSupport));
  GetServerMetaResp_descriptor_ = file->message_type(28);
  static const int GetServerMetaResp_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetServerMetaResp, status_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetServerMetaResp, server_meta_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetServerMetaResp, error_),
  };
  GetServerMetaResp_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      GetServerMetaResp_descriptor_,
      GetServerMetaResp::default_instance_,
      GetServerMetaResp_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetServerMetaResp, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetServerMetaResp, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(GetServerMetaResp));
  ServerMeta_descriptor_ = file->message_type(29);
  static const int ServerMeta_offsets_[49] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, all_tables_selectable_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, blob_included_in_max_row_size_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, catalog_at_start_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, catalog_separator_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, catalog_term_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, collate_support_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, column_aliasing_supported_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, convert_support_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, correlation_names_support_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, date_time_functions_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, date_time_literals_support_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, group_by_support_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, identifier_casing_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, identifier_quote_string_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, like_escape_clause_supported_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, max_binary_literal_length_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, max_catalog_name_length_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, max_char_literal_length_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, max_column_name_length_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, max_columns_in_group_by_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, max_columns_in_order_by_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, max_columns_in_select_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, max_cursor_name_length_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, max_logical_lob_size_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, max_row_size_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, max_schema_name_length_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, max_statement_length_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, max_statements_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, max_table_name_length_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, max_tables_in_select_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, max_user_name_length_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, null_collation_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, null_plus_non_null_equals_null_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, numeric_functions_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, order_by_support_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, outer_join_support_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, quoted_identifier_casing_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, read_only_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, schema_term_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, search_escape_string_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, select_for_update_supported_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, special_characters_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, sql_keywords_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, string_functions_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, subquery_support_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, system_functions_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, table_term_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, transaction_supported_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, union_support_),
  };
  ServerMeta_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      ServerMeta_descriptor_,
      ServerMeta::default_instance_,
      ServerMeta_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(ServerMeta));
  RunQuery_descriptor_ = file->message_type(30);
  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);
  SaslSupport_descriptor_ = file->enum_type(1);
  QueryResultsMode_descriptor_ = file->enum_type(2);
  HandshakeStatus_descriptor_ = file->enum_type(3);
  RequestStatus_descriptor_ = file->enum_type(4);
  ColumnSearchability_descriptor_ = file->enum_type(5);
  ColumnUpdatability_descriptor_ = file->enum_type(6);
  CollateSupport_descriptor_ = file->enum_type(7);
  CorrelationNamesSupport_descriptor_ = file->enum_type(8);
  DateTimeLiteralsSupport_descriptor_ = file->enum_type(9);
  GroupBySupport_descriptor_ = file->enum_type(10);
  IdentifierCasing_descriptor_ = file->enum_type(11);
  NullCollation_descriptor_ = file->enum_type(12);
  OrderBySupport_descriptor_ = file->enum_type(13);
  OuterJoinSupport_descriptor_ = file->enum_type(14);
  SubQuerySupport_descriptor_ = file->enum_type(15);
  UnionSupport_descriptor_ = file->enum_type(16);
}

namespace {

GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
inline void protobuf_AssignDescriptorsOnce() {
  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
                 &protobuf_AssignDesc_User_2eproto);
}

void protobuf_RegisterTypes(const ::std::string&) {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    Property_descriptor_, &Property::default_instance());
  ::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(
    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(
    GetServerMetaReq_descriptor_, &GetServerMetaReq::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    ConvertSupport_descriptor_, &ConvertSupport::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    GetServerMetaResp_descriptor_, &GetServerMetaResp::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    ServerMeta_descriptor_, &ServerMeta::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    RunQuery_descriptor_, &RunQuery::default_instance());
}

}  // namespace

void protobuf_ShutdownFile_User_2eproto() {
  delete Property::default_instance_;
  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 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 GetServerMetaReq::default_instance_;
  delete GetServerMetaReq_reflection_;
  delete ConvertSupport::default_instance_;
  delete ConvertSupport_reflection_;
  delete GetServerMetaResp::default_instance_;
  delete GetServerMetaResp_reflection_;
  delete ServerMeta::default_instance_;
  delete ServerMeta_reflection_;
  delete RunQuery::default_instance_;
  delete RunQuery_reflection_;
}

void protobuf_AddDesc_User_2eproto() {
  static bool already_here = false;
  if (already_here) return;
  already_here = true;
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  ::exec::protobuf_AddDesc_SchemaDef_2eproto();
  ::common::protobuf_AddDesc_Types_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\013Types.proto\032\023UserBitShared.proto\032\rBitD"
    "ata.proto\032\020BitControl.proto\032\025ExecutionPr"
    "otos.proto\"&\n\010Property\022\013\n\003key\030\001 \002(\t\022\r\n\005v"
    "alue\030\002 \002(\t\"9\n\016UserProperties\022\'\n\nproperti"
    "es\030\001 \003(\0132\023.exec.user.Property\"\267\001\n\020RpcEnd"
    "pointInfos\022\014\n\004name\030\001 \001(\t\022\017\n\007version\030\002 \001("
    "\t\022\024\n\014majorVersion\030\003 \001(\r\022\024\n\014minorVersion\030"
    "\004 \001(\r\022\024\n\014patchVersion\030\005 \001(\r\022\023\n\013applicati"
    "on\030\006 \001(\t\022\023\n\013buildNumber\030\007 \001(\r\022\030\n\020version"
    "Qualifier\030\010 \001(\t\"\375\002\n\022UserToBitHandshake\022."
    "\n\007channel\030\001 \001(\0162\027.exec.shared.RpcChannel"
    ":\004USER\022\031\n\021support_listening\030\002 \001(\010\022\023\n\013rpc"
    "_version\030\003 \001(\005\0221\n\013credentials\030\004 \001(\0132\034.ex"
    "ec.shared.UserCredentials\022-\n\nproperties\030"
    "\005 \001(\0132\031.exec.user.UserProperties\022$\n\025supp"
    "ort_complex_types\030\006 \001(\010:\005false\022\036\n\017suppor"
    "t_timeout\030\007 \001(\010:\005false\0221\n\014client_infos\030\010"
    " \001(\0132\033.exec.user.RpcEndpointInfos\022,\n\014sas"
    "l_support\030\t \001(\0162\026.exec.user.SaslSupport\""
    "S\n\016RequestResults\022&\n\010query_id\030\001 \001(\0132\024.ex"
    "ec.shared.QueryId\022\031\n\021maximum_responses\030\002"
    " \001(\005\"g\n\025GetQueryPlanFragments\022\r\n\005query\030\001"
    " \002(\t\022$\n\004type\030\002 \001(\0162\026.exec.shared.QueryTy"
    "pe\022\031\n\nsplit_plan\030\003 \001(\010:\005false\"\316\001\n\022QueryP"
    "lanFragments\0223\n\006status\030\001 \002(\0162#.exec.shar"
    "ed.QueryResult.QueryState\022&\n\010query_id\030\002 "
    "\001(\0132\024.exec.shared.QueryId\0221\n\tfragments\030\003"
    " \003(\0132\036.exec.bit.control.PlanFragment\022(\n\005"
    "error\030\004 \001(\0132\031.exec.shared.DrillPBError\"\253"
    "\002\n\022BitToUserHandshake\022\023\n\013rpc_version\030\002 \001"
    "(\005\022*\n\006status\030\003 \001(\0162\032.exec.user.Handshake"
    "Status\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\022 \n\030authenticationMechan"
    "isms\030\007 \003(\t\022-\n\021supported_methods\030\010 \003(\0162\022."
    "exec.user.RpcType\022\021\n\tencrypted\030\t \001(\010\022\026\n\016"
    "maxWrappedSize\030\n \001(\005\"-\n\nLikeFilter\022\017\n\007pa"
    "ttern\030\001 \001(\t\022\016\n\006escape\030\002 \001(\t\"D\n\016GetCatalo"
    "gsReq\0222\n\023catalog_name_filter\030\001 \001(\0132\025.exe"
    "c.user.LikeFilter\"M\n\017CatalogMetadata\022\024\n\014"
    "catalog_name\030\001 \001(\t\022\023\n\013description\030\002 \001(\t\022"
    "\017\n\007connect\030\003 \001(\t\"\223\001\n\017GetCatalogsResp\022(\n\006"
    "status\030\001 \001(\0162\030.exec.user.RequestStatus\022,"
    "\n\010catalogs\030\002 \003(\0132\032.exec.user.CatalogMeta"
    "data\022(\n\005error\030\003 \001(\0132\031.exec.shared.DrillP"
    "BError\"v\n\rGetSchemasReq\0222\n\023catalog_name_"
    "filter\030\001 \001(\0132\025.exec.user.LikeFilter\0221\n\022s"
    "chema_name_filter\030\002 \001(\0132\025.exec.user.Like"
    "Filter\"i\n\016SchemaMetadata\022\024\n\014catalog_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\016Ge"
    "tSchemasResp\022(\n\006status\030\001 \001(\0162\030.exec.user"
    ".RequestStatus\022*\n\007schemas\030\002 \003(\0132\031.exec.u"
    "ser.SchemaMetadata\022(\n\005error\030\003 \001(\0132\031.exec"
    ".shared.DrillPBError\"\302\001\n\014GetTablesReq\0222\n"
    "\023catalog_name_filter\030\001 \001(\0132\025.exec.user.L"
    "ikeFilter\0221\n\022schema_name_filter\030\002 \001(\0132\025."
    "exec.user.LikeFilter\0220\n\021table_name_filte"
    "r\030\003 \001(\0132\025.exec.user.LikeFilter\022\031\n\021table_"
    "type_filter\030\004 \003(\t\"\\\n\rTableMetadata\022\024\n\014ca"
    "talog_name\030\001 \001(\t\022\023\n\013schema_name\030\002 \001(\t\022\022\n"
    "\ntable_name\030\003 \001(\t\022\014\n\004type\030\004 \001(\t\"\215\001\n\rGetT"
    "ablesResp\022(\n\006status\030\001 \001(\0162\030.exec.user.Re"
    "questStatus\022(\n\006tables\030\002 \003(\0132\030.exec.user."
    "TableMetadata\022(\n\005error\030\003 \001(\0132\031.exec.shar"
    "ed.DrillPBError\"\333\001\n\rGetColumnsReq\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\0220\n\021table_name_filter\030\003 "
    "\001(\0132\025.exec.user.LikeFilter\0221\n\022column_nam"
    "e_filter\030\004 \001(\0132\025.exec.user.LikeFilter\"\251\003"
    "\n\016ColumnMetadata\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\030\n\020ordinal_position"
    "\030\005 \001(\005\022\025\n\rdefault_value\030\006 \001(\t\022\023\n\013is_null"
    "able\030\007 \001(\010\022\021\n\tdata_type\030\010 \001(\t\022\027\n\017char_ma"
    "x_length\030\t \001(\005\022\031\n\021char_octet_length\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\rnumeric_scale\030\r"
    " \001(\005\022\033\n\023date_time_precision\030\016 \001(\005\022\025\n\rint"
    "erval_type\030\017 \001(\t\022\032\n\022interval_precision\030\020"
    " \001(\005\022\023\n\013column_size\030\021 \001(\005\"\220\001\n\016GetColumns"
    "Resp\022(\n\006status\030\001 \001(\0162\030.exec.user.Request"
    "Status\022*\n\007columns\030\002 \003(\0132\031.exec.user.Colu"
    "mnMetadata\022(\n\005error\030\003 \001(\0132\031.exec.shared."
    "DrillPBError\"/\n\032CreatePreparedStatementR"
    "eq\022\021\n\tsql_query\030\001 \001(\t\"\326\003\n\024ResultColumnMe"
    "tadata\022\024\n\014catalog_name\030\001 \001(\t\022\023\n\013schema_n"
    "ame\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\tdata_type\030\006"
    " \001(\t\022\023\n\013is_nullable\030\007 \001(\010\022\021\n\tprecision\030\010"
    " \001(\005\022\r\n\005scale\030\t \001(\005\022\016\n\006signed\030\n \001(\010\022\024\n\014d"
    "isplay_size\030\013 \001(\005\022\022\n\nis_aliased\030\014 \001(\010\0225\n"
    "\rsearchability\030\r \001(\0162\036.exec.user.ColumnS"
    "earchability\0223\n\014updatability\030\016 \001(\0162\035.exe"
    "c.user.ColumnUpdatability\022\026\n\016auto_increm"
    "ent\030\017 \001(\010\022\030\n\020case_sensitivity\030\020 \001(\010\022\020\n\010s"
    "ortable\030\021 \001(\010\022\022\n\nclass_name\030\022 \001(\t\022\023\n\013is_"
    "currency\030\024 \001(\010\".\n\027PreparedStatementHandl"
    "e\022\023\n\013server_info\030\001 \001(\014\"\200\001\n\021PreparedState"
    "ment\0220\n\007columns\030\001 \003(\0132\037.exec.user.Result"
    "ColumnMetadata\0229\n\rserver_handle\030\002 \001(\0132\"."
    "exec.user.PreparedStatementHandle\"\253\001\n\033Cr"
    "eatePreparedStatementResp\022(\n\006status\030\001 \001("
    "\0162\030.exec.user.RequestStatus\0228\n\022prepared_"
    "statement\030\002 \001(\0132\034.exec.user.PreparedStat"
    "ement\022(\n\005error\030\003 \001(\0132\031.exec.shared.Drill"
    "PBError\"\022\n\020GetServerMetaReq\"P\n\016ConvertSu"
    "pport\022\037\n\004from\030\001 \002(\0162\021.common.MinorType\022\035"
    "\n\002to\030\002 \002(\0162\021.common.MinorType\"\223\001\n\021GetSer"
    "verMetaResp\022(\n\006status\030\001 \001(\0162\030.exec.user."
    "RequestStatus\022*\n\013server_meta\030\002 \001(\0132\025.exe"
    "c.user.ServerMeta\022(\n\005error\030\003 \001(\0132\031.exec."
    "shared.DrillPBError\"\377\r\n\nServerMeta\022\035\n\025al"
    "l_tables_selectable\030\001 \001(\010\022%\n\035blob_includ"
    "ed_in_max_row_size\030\002 \001(\010\022\030\n\020catalog_at_s"
    "tart\030\003 \001(\010\022\031\n\021catalog_separator\030\004 \001(\t\022\024\n"
    "\014catalog_term\030\005 \001(\t\0222\n\017collate_support\030\006"
    " \003(\0162\031.exec.user.CollateSupport\022!\n\031colum"
    "n_aliasing_supported\030\007 \001(\010\0222\n\017convert_su"
    "pport\030\010 \003(\0132\031.exec.user.ConvertSupport\022E"
    "\n\031correlation_names_support\030\t \001(\0162\".exec"
    ".user.CorrelationNamesSupport\022\033\n\023date_ti"
    "me_functions\030\n \003(\t\022F\n\032date_time_literals"
    "_support\030\013 \003(\0162\".exec.user.DateTimeLiter"
    "alsSupport\0223\n\020group_by_support\030\014 \001(\0162\031.e"
    "xec.user.GroupBySupport\0226\n\021identifier_ca"
    "sing\030\r \001(\0162\033.exec.user.IdentifierCasing\022"
    "\037\n\027identifier_quote_string\030\016 \001(\t\022$\n\034like"
    "_escape_clause_supported\030\017 \001(\010\022!\n\031max_bi"
    "nary_literal_length\030\020 \001(\r\022\037\n\027max_catalog"
    "_name_length\030\021 \001(\r\022\037\n\027max_char_literal_l"
    "ength\030\022 \001(\r\022\036\n\026max_column_name_length\030\023 "
    "\001(\r\022\037\n\027max_columns_in_group_by\030\024 \001(\r\022\037\n\027"
    "max_columns_in_order_by\030\025 \001(\r\022\035\n\025max_col"
    "umns_in_select\030\026 \001(\r\022\036\n\026max_cursor_name_"
    "length\030\027 \001(\r\022\034\n\024max_logical_lob_size\030\030 \001"
    "(\r\022\024\n\014max_row_size\030\031 \001(\r\022\036\n\026max_schema_n"
    "ame_length\030\032 \001(\r\022\034\n\024max_statement_length"
    "\030\033 \001(\r\022\026\n\016max_statements\030\034 \001(\r\022\035\n\025max_ta"
    "ble_name_length\030\035 \001(\r\022\034\n\024max_tables_in_s"
    "elect\030\036 \001(\r\022\034\n\024max_user_name_length\030\037 \001("
    "\r\0220\n\016null_collation\030  \001(\0162\030.exec.user.Nu"
    "llCollation\022&\n\036null_plus_non_null_equals"
    "_null\030! \001(\010\022\031\n\021numeric_functions\030\" \003(\t\0223"
    "\n\020order_by_support\030# \003(\0162\031.exec.user.Ord"
    "erBySupport\0227\n\022outer_join_support\030$ \003(\0162"
    "\033.exec.user.OuterJoinSupport\022=\n\030quoted_i"
    "dentifier_casing\030% \001(\0162\033.exec.user.Ident"
    "ifierCasing\022\021\n\tread_only\030& \001(\010\022\023\n\013schema"
    "_term\030\' \001(\t\022\034\n\024search_escape_string\030( \001("
    "\t\022#\n\033select_for_update_supported\030) \001(\010\022\032"
    "\n\022special_characters\030* \001(\t\022\024\n\014sql_keywor"
    "ds\030+ \003(\t\022\030\n\020string_functions\030, \003(\t\0224\n\020su"
    "bquery_support\030- \003(\0162\032.exec.user.SubQuer"
    "ySupport\022\030\n\020system_functions\030. \003(\t\022\022\n\nta"
    "ble_term\030/ \001(\t\022\035\n\025transaction_supported\030"
    "0 \001(\010\022.\n\runion_support\0301 \003(\0162\027.exec.user"
    ".UnionSupport\"\353\001\n\010RunQuery\0221\n\014results_mo"
    "de\030\001 \001(\0162\033.exec.user.QueryResultsMode\022$\n"
    "\004type\030\002 \001(\0162\026.exec.shared.QueryType\022\014\n\004p"
    "lan\030\003 \001(\t\0221\n\tfragments\030\004 \003(\0132\036.exec.bit."
    "control.PlanFragment\022E\n\031prepared_stateme"
    "nt_handle\030\005 \001(\0132\".exec.user.PreparedStat"
    "ementHandle*\320\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\014C"
    "ANCEL_QUERY\020\004\022\023\n\017REQUEST_RESULTS\020\005\022\027\n\023RE"
    "SUME_PAUSED_QUERY\020\013\022\034\n\030GET_QUERY_PLAN_FR"
    "AGMENTS\020\014\022\020\n\014GET_CATALOGS\020\016\022\017\n\013GET_SCHEM"
    "AS\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\023\n\017GET_SERV"
    "ER_META\020\010\022\016\n\nQUERY_DATA\020\006\022\020\n\014QUERY_HANDL"
    "E\020\007\022\030\n\024QUERY_PLAN_FRAGMENTS\020\r\022\014\n\010CATALOG"
    "S\020\022\022\013\n\007SCHEMAS\020\023\022\n\n\006TABLES\020\024\022\013\n\007COLUMNS\020"
    "\025\022\026\n\022PREPARED_STATEMENT\020\027\022\017\n\013SERVER_META"
    "\020\t\022\020\n\014QUERY_RESULT\020\n\022\020\n\014SASL_MESSAGE\020\030*H"
    "\n\013SaslSupport\022\030\n\024UNKNOWN_SASL_SUPPORT\020\000\022"
    "\r\n\tSASL_AUTH\020\001\022\020\n\014SASL_PRIVACY\020\002*#\n\020Quer"
    "yResultsMode\022\017\n\013STREAM_FULL\020\001*q\n\017Handsha"
    "keStatus\022\013\n\007SUCCESS\020\001\022\030\n\024RPC_VERSION_MIS"
    "MATCH\020\002\022\017\n\013AUTH_FAILED\020\003\022\023\n\017UNKNOWN_FAIL"
    "URE\020\004\022\021\n\rAUTH_REQUIRED\020\005*D\n\rRequestStatu"
    "s\022\022\n\016UNKNOWN_STATUS\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_SEARCHABILITY\020\000\022\010\n\004NONE\020\001\022\010\n\004CH"
    "AR\020\002\022\n\n\006NUMBER\020\003\022\007\n\003ALL\020\004*K\n\022ColumnUpdat"
    "ability\022\030\n\024UNKNOWN_UPDATABILITY\020\000\022\r\n\tREA"
    "D_ONLY\020\001\022\014\n\010WRITABLE\020\002*1\n\016CollateSupport"
    "\022\016\n\nCS_UNKNOWN\020\000\022\017\n\013CS_GROUP_BY\020\001*J\n\027Cor"
    "relationNamesSupport\022\013\n\007CN_NONE\020\001\022\026\n\022CN_"
    "DIFFERENT_NAMES\020\002\022\n\n\006CN_ANY\020\003*\271\003\n\027DateTi"
    "meLiteralsSupport\022\016\n\nDL_UNKNOWN\020\000\022\013\n\007DL_"
    "DATE\020\001\022\013\n\007DL_TIME\020\002\022\020\n\014DL_TIMESTAMP\020\003\022\024\n"
    "\020DL_INTERVAL_YEAR\020\004\022\025\n\021DL_INTERVAL_MONTH"
    "\020\005\022\023\n\017DL_INTERVAL_DAY\020\006\022\024\n\020DL_INTERVAL_H"
    "OUR\020\007\022\026\n\022DL_INTERVAL_MINUTE\020\010\022\026\n\022DL_INTE"
    "RVAL_SECOND\020\t\022\035\n\031DL_INTERVAL_YEAR_TO_MON"
    "TH\020\n\022\033\n\027DL_INTERVAL_DAY_TO_HOUR\020\013\022\035\n\031DL_"
    "INTERVAL_DAY_TO_MINUTE\020\014\022\035\n\031DL_INTERVAL_"
    "DAY_TO_SECOND\020\r\022\036\n\032DL_INTERVAL_HOUR_TO_M"
    "INUTE\020\016\022\036\n\032DL_INTERVAL_HOUR_TO_SECOND\020\017\022"
    " \n\034DL_INTERVAL_MINUTE_TO_SECOND\020\020*Y\n\016Gro"
    "upBySupport\022\013\n\007GB_NONE\020\001\022\022\n\016GB_SELECT_ON"
    "LY\020\002\022\024\n\020GB_BEYOND_SELECT\020\003\022\020\n\014GB_UNRELAT"
    "ED\020\004*x\n\020IdentifierCasing\022\016\n\nIC_UNKNOWN\020\000"
    "\022\023\n\017IC_STORES_LOWER\020\001\022\023\n\017IC_STORES_MIXED"
    "\020\002\022\023\n\017IC_STORES_UPPER\020\003\022\025\n\021IC_SUPPORTS_M"
    "IXED\020\004*X\n\rNullCollation\022\016\n\nNC_UNKNOWN\020\000\022"
    "\017\n\013NC_AT_START\020\001\022\r\n\tNC_AT_END\020\002\022\013\n\007NC_HI"
    "GH\020\003\022\n\n\006NC_LOW\020\004*E\n\016OrderBySupport\022\016\n\nOB"
    "_UNKNOWN\020\000\022\020\n\014OB_UNRELATED\020\001\022\021\n\rOB_EXPRE"
    "SSION\020\002*\226\001\n\020OuterJoinSupport\022\016\n\nOJ_UNKNO"
    "WN\020\000\022\013\n\007OJ_LEFT\020\001\022\014\n\010OJ_RIGHT\020\002\022\013\n\007OJ_FU"
    "LL\020\003\022\r\n\tOJ_NESTED\020\004\022\022\n\016OJ_NOT_ORDERED\020\005\022"
    "\014\n\010OJ_INNER\020\006\022\031\n\025OJ_ALL_COMPARISON_OPS\020\007"
    "*\204\001\n\017SubQuerySupport\022\016\n\nSQ_UNKNOWN\020\000\022\021\n\r"
    "SQ_CORRELATED\020\001\022\024\n\020SQ_IN_COMPARISON\020\002\022\020\n"
    "\014SQ_IN_EXISTS\020\003\022\020\n\014SQ_IN_INSERT\020\004\022\024\n\020SQ_"
    "IN_QUANTIFIED\020\005*;\n\014UnionSupport\022\r\n\tU_UNK"
    "NOWN\020\000\022\013\n\007U_UNION\020\001\022\017\n\013U_UNION_ALL\020\002B+\n\033"
    "org.apache.drill.exec.protoB\nUserProtosH"
    "\001", 8881);
  ::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();
  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();
  GetServerMetaReq::default_instance_ = new GetServerMetaReq();
  ConvertSupport::default_instance_ = new ConvertSupport();
  GetServerMetaResp::default_instance_ = new GetServerMetaResp();
  ServerMeta::default_instance_ = new ServerMeta();
  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();
  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();
  GetServerMetaReq::default_instance_->InitAsDefaultInstance();
  ConvertSupport::default_instance_->InitAsDefaultInstance();
  GetServerMetaResp::default_instance_->InitAsDefaultInstance();
  ServerMeta::default_instance_->InitAsDefaultInstance();
  RunQuery::default_instance_->InitAsDefaultInstance();
  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_User_2eproto);
}

// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_User_2eproto {
  StaticDescriptorInitializer_User_2eproto() {
    protobuf_AddDesc_User_2eproto();
  }
} static_descriptor_initializer_User_2eproto_;
const ::google::protobuf::EnumDescriptor* RpcType_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return RpcType_descriptor_;
}
bool RpcType_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    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:
    case 24:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* SaslSupport_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return SaslSupport_descriptor_;
}
bool SaslSupport_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* QueryResultsMode_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return QueryResultsMode_descriptor_;
}
bool QueryResultsMode_IsValid(int value) {
  switch(value) {
    case 1:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* HandshakeStatus_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return HandshakeStatus_descriptor_;
}
bool HandshakeStatus_IsValid(int value) {
  switch(value) {
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
      return true;
    default:
      return false;
  }
}

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;
  }
}

const ::google::protobuf::EnumDescriptor* CollateSupport_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CollateSupport_descriptor_;
}
bool CollateSupport_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* CorrelationNamesSupport_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CorrelationNamesSupport_descriptor_;
}
bool CorrelationNamesSupport_IsValid(int value) {
  switch(value) {
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* DateTimeLiteralsSupport_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return DateTimeLiteralsSupport_descriptor_;
}
bool DateTimeLiteralsSupport_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
    case 11:
    case 12:
    case 13:
    case 14:
    case 15:
    case 16:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* GroupBySupport_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return GroupBySupport_descriptor_;
}
bool GroupBySupport_IsValid(int value) {
  switch(value) {
    case 1:
    case 2:
    case 3:
    case 4:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* IdentifierCasing_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return IdentifierCasing_descriptor_;
}
bool IdentifierCasing_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* NullCollation_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return NullCollation_descriptor_;
}
bool NullCollation_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* OrderBySupport_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return OrderBySupport_descriptor_;
}
bool OrderBySupport_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* OuterJoinSupport_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return OuterJoinSupport_descriptor_;
}
bool OuterJoinSupport_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* SubQuerySupport_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return SubQuerySupport_descriptor_;
}
bool SubQuerySupport_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* UnionSupport_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return UnionSupport_descriptor_;
}
bool UnionSupport_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}


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

#ifndef _MSC_VER
const int Property::kKeyFieldNumber;
const int Property::kValueFieldNumber;
#endif  // !_MSC_VER

Property::Property()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void Property::InitAsDefaultInstance() {
}

Property::Property(const Property& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void Property::SharedCtor() {
  _cached_size_ = 0;
  key_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

Property::~Property() {
  SharedDtor();
}

void Property::SharedDtor() {
  if (key_ != &::google::protobuf::internal::kEmptyString) {
    delete key_;
  }
  if (value_ != &::google::protobuf::internal::kEmptyString) {
    delete value_;
  }
  if (this != default_instance_) {
  }
}

void Property::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* Property::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return Property_descriptor_;
}

const Property& Property::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_User_2eproto();
  return *default_instance_;
}

Property* Property::default_instance_ = NULL;

Property* Property::New() const {
  return new Property;
}

void Property::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_key()) {
      if (key_ != &::google::protobuf::internal::kEmptyString) {
        key_->clear();
      }
    }
    if (has_value()) {
      if (value_ != &::google::protobuf::internal::kEmptyString) {
        value_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool Property::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 string key = 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_key()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->key().data(), this->key().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_value;
        break;
      }

      // required string value = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_value:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_value()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->value().data(), this->value().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 Property::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required string key = 1;
  if (has_key()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->key().data(), this->key().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->key(), output);
  }

  // required string value = 2;
  if (has_value()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->value().data(), this->value().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      2, this->value(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* Property::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required string key = 1;
  if (has_key()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->key().data(), this->key().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->key(), target);
  }

  // required string value = 2;
  if (has_value()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->value().data(), this->value().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        2, this->value(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int Property::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required string key = 1;
    if (has_key()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->key());
    }

    // required string value = 2;
    if (has_value()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->value());
    }

  }
  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 Property::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const Property* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const Property*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void Property::MergeFrom(const Property& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_key()) {
      set_key(from.key());
    }
    if (from.has_value()) {
      set_value(from.value());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void Property::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Property::CopyFrom(const Property& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Property::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void Property::Swap(Property* other) {
  if (other != this) {
    std::swap(key_, other->key_);
    std::swap(value_, other->value_);
    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 Property::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Property_descriptor_;
  metadata.reflection = Property_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int UserProperties::kPropertiesFieldNumber;
#endif  // !_MSC_VER

UserProperties::UserProperties()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void UserProperties::InitAsDefaultInstance() {
}

UserProperties::UserProperties(const UserProperties& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void UserProperties::SharedCtor() {
  _cached_size_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

UserProperties::~UserProperties() {
  SharedDtor();
}

void UserProperties::SharedDtor() {
  if (this != default_instance_) {
  }
}

void UserProperties::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* UserProperties::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return UserProperties_descriptor_;
}

const UserProperties& UserProperties::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_User_2eproto();
  return *default_instance_;
}

UserProperties* UserProperties::default_instance_ = NULL;

UserProperties* UserProperties::New() const {
  return new UserProperties;
}

void UserProperties::Clear() {
  properties_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool UserProperties::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.Property properties = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_properties:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_properties()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(10)) goto parse_properties;
        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 UserProperties::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // repeated .exec.user.Property properties = 1;
  for (int i = 0; i < this->properties_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->properties(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* UserProperties::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // repeated .exec.user.Property properties = 1;
  for (int i = 0; i < this->properties_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->properties(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int UserProperties::ByteSize() const {
  int total_size = 0;

  // repeated .exec.user.Property properties = 1;
  total_size += 1 * this->properties_size();
  for (int i = 0; i < this->properties_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->properties(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 UserProperties::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const UserProperties* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const UserProperties*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void UserProperties::MergeFrom(const UserProperties& from) {
  GOOGLE_CHECK_NE(&from, this);
  properties_.MergeFrom(from.properties_);
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void UserProperties::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void UserProperties::CopyFrom(const UserProperties& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool UserProperties::IsInitialized() const {

  for (int i = 0; i < properties_size(); i++) {
    if (!this->properties(i).IsInitialized()) return false;
  }
  return true;
}

void UserProperties::Swap(UserProperties* other) {
  if (other != this) {
    properties_.Swap(&other->properties_);
    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 UserProperties::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = UserProperties_descriptor_;
  metadata.reflection = UserProperties_reflection_;
  return metadata;
}


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

#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;
const int RpcEndpointInfos::kBuildNumberFieldNumber;
const int RpcEndpointInfos::kVersionQualifierFieldNumber;
#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);
  buildnumber_ = 0u;
  versionqualifier_ = 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 (versionqualifier_ != &::google::protobuf::internal::kEmptyString) {
    delete versionqualifier_;
  }
  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();
      }
    }
    buildnumber_ = 0u;
    if (has_versionqualifier()) {
      if (versionqualifier_ != &::google::protobuf::internal::kEmptyString) {
        versionqualifier_->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->ExpectTag(56)) goto parse_buildNumber;
        break;
      }

      // optional uint32 buildNumber = 7;
      case 7: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_buildNumber:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &buildnumber_)));
          set_has_buildnumber();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(66)) goto parse_versionQualifier;
        break;
      }

      // optional string versionQualifier = 8;
      case 8: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_versionQualifier:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_versionqualifier()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->versionqualifier().data(), this->versionqualifier().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);
  }

  // optional uint32 buildNumber = 7;
  if (has_buildnumber()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(7, this->buildnumber(), output);
  }

  // optional string versionQualifier = 8;
  if (has_versionqualifier()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->versionqualifier().data(), this->versionqualifier().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      8, this->versionqualifier(), 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);
  }

  // optional uint32 buildNumber = 7;
  if (has_buildnumber()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(7, this->buildnumber(), target);
  }

  // optional string versionQualifier = 8;
  if (has_versionqualifier()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->versionqualifier().data(), this->versionqualifier().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        8, this->versionqualifier(), 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());
    }

    // optional uint32 buildNumber = 7;
    if (has_buildnumber()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->buildnumber());
    }

    // optional string versionQualifier = 8;
    if (has_versionqualifier()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->versionqualifier());
    }

  }
  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());
    }
    if (from.has_buildnumber()) {
      set_buildnumber(from.buildnumber());
    }
    if (from.has_versionqualifier()) {
      set_versionqualifier(from.versionqualifier());
    }
  }
  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(buildnumber_, other->buildnumber_);
    std::swap(versionqualifier_, other->versionqualifier_);
    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;
const int UserToBitHandshake::kCredentialsFieldNumber;
const int UserToBitHandshake::kPropertiesFieldNumber;
const int UserToBitHandshake::kSupportComplexTypesFieldNumber;
const int UserToBitHandshake::kSupportTimeoutFieldNumber;
const int UserToBitHandshake::kClientInfosFieldNumber;
const int UserToBitHandshake::kSaslSupportFieldNumber;
#endif  // !_MSC_VER

UserToBitHandshake::UserToBitHandshake()
  : ::google::protobuf::Message() {
  SharedCtor();
}

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)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void UserToBitHandshake::SharedCtor() {
  _cached_size_ = 0;
  channel_ = 2;
  support_listening_ = false;
  rpc_version_ = 0;
  credentials_ = NULL;
  properties_ = NULL;
  support_complex_types_ = false;
  support_timeout_ = false;
  client_infos_ = NULL;
  sasl_support_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

UserToBitHandshake::~UserToBitHandshake() {
  SharedDtor();
}

void UserToBitHandshake::SharedDtor() {
  if (this != default_instance_) {
    delete credentials_;
    delete properties_;
    delete client_infos_;
  }
}

void UserToBitHandshake::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* UserToBitHandshake::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return UserToBitHandshake_descriptor_;
}

const UserToBitHandshake& UserToBitHandshake::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_User_2eproto();
  return *default_instance_;
}

UserToBitHandshake* UserToBitHandshake::default_instance_ = NULL;

UserToBitHandshake* UserToBitHandshake::New() const {
  return new UserToBitHandshake;
}

void UserToBitHandshake::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    channel_ = 2;
    support_listening_ = false;
    rpc_version_ = 0;
    if (has_credentials()) {
      if (credentials_ != NULL) credentials_->::exec::shared::UserCredentials::Clear();
    }
    if (has_properties()) {
      if (properties_ != NULL) properties_->::exec::user::UserProperties::Clear();
    }
    support_complex_types_ = false;
    support_timeout_ = false;
    if (has_client_infos()) {
      if (client_infos_ != NULL) client_infos_->::exec::user::RpcEndpointInfos::Clear();
    }
  }
  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    sasl_support_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool UserToBitHandshake::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.shared.RpcChannel channel = 1 [default = USER];
      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::RpcChannel_IsValid(value)) {
            set_channel(static_cast< ::exec::shared::RpcChannel >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_support_listening;
        break;
      }

      // optional bool support_listening = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_support_listening:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &support_listening_)));
          set_has_support_listening();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_rpc_version;
        break;
      }

      // optional int32 rpc_version = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_rpc_version:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &rpc_version_)));
          set_has_rpc_version();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(34)) goto parse_credentials;
        break;
      }

      // optional .exec.shared.UserCredentials credentials = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_credentials:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_credentials()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(42)) goto parse_properties;
        break;
      }

      // optional .exec.user.UserProperties properties = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_properties:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_properties()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(48)) goto parse_support_complex_types;
        break;
      }

      // optional bool support_complex_types = 6 [default = false];
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_support_complex_types:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &support_complex_types_)));
          set_has_support_complex_types();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(56)) goto parse_support_timeout;
        break;
      }

      // optional bool support_timeout = 7 [default = false];
      case 7: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_support_timeout:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &support_timeout_)));
          set_has_support_timeout();
        } 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->ExpectTag(72)) goto parse_sasl_support;
        break;
      }

      // optional .exec.user.SaslSupport sasl_support = 9;
      case 9: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_sasl_support:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::exec::user::SaslSupport_IsValid(value)) {
            set_sasl_support(static_cast< ::exec::user::SaslSupport >(value));
          } else {
            mutable_unknown_fields()->AddVarint(9, value);
          }
        } 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 UserToBitHandshake::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional .exec.shared.RpcChannel channel = 1 [default = USER];
  if (has_channel()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->channel(), output);
  }

  // optional bool support_listening = 2;
  if (has_support_listening()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->support_listening(), output);
  }

  // optional int32 rpc_version = 3;
  if (has_rpc_version()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->rpc_version(), output);
  }

  // optional .exec.shared.UserCredentials credentials = 4;
  if (has_credentials()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      4, this->credentials(), output);
  }

  // optional .exec.user.UserProperties properties = 5;
  if (has_properties()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      5, this->properties(), output);
  }

  // optional bool support_complex_types = 6 [default = false];
  if (has_support_complex_types()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->support_complex_types(), output);
  }

  // optional bool support_timeout = 7 [default = false];
  if (has_support_timeout()) {
    ::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);
  }

  // optional .exec.user.SaslSupport sasl_support = 9;
  if (has_sasl_support()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      9, this->sasl_support(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* UserToBitHandshake::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional .exec.shared.RpcChannel channel = 1 [default = USER];
  if (has_channel()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->channel(), target);
  }

  // optional bool support_listening = 2;
  if (has_support_listening()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->support_listening(), target);
  }

  // optional int32 rpc_version = 3;
  if (has_rpc_version()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->rpc_version(), target);
  }

  // optional .exec.shared.UserCredentials credentials = 4;
  if (has_credentials()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        4, this->credentials(), target);
  }

  // optional .exec.user.UserProperties properties = 5;
  if (has_properties()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        5, this->properties(), target);
  }

  // optional bool support_complex_types = 6 [default = false];
  if (has_support_complex_types()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->support_complex_types(), target);
  }

  // optional bool support_timeout = 7 [default = false];
  if (has_support_timeout()) {
    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);
  }

  // optional .exec.user.SaslSupport sasl_support = 9;
  if (has_sasl_support()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      9, this->sasl_support(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int UserToBitHandshake::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .exec.shared.RpcChannel channel = 1 [default = USER];
    if (has_channel()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->channel());
    }

    // optional bool support_listening = 2;
    if (has_support_listening()) {
      total_size += 1 + 1;
    }

    // optional int32 rpc_version = 3;
    if (has_rpc_version()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->rpc_version());
    }

    // optional .exec.shared.UserCredentials credentials = 4;
    if (has_credentials()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->credentials());
    }

    // optional .exec.user.UserProperties properties = 5;
    if (has_properties()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->properties());
    }

    // optional bool support_complex_types = 6 [default = false];
    if (has_support_complex_types()) {
      total_size += 1 + 1;
    }

    // optional bool support_timeout = 7 [default = false];
    if (has_support_timeout()) {
      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 (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    // optional .exec.user.SaslSupport sasl_support = 9;
    if (has_sasl_support()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->sasl_support());
    }

  }
  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 UserToBitHandshake::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const UserToBitHandshake* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const UserToBitHandshake*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void UserToBitHandshake::MergeFrom(const UserToBitHandshake& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_channel()) {
      set_channel(from.channel());
    }
    if (from.has_support_listening()) {
      set_support_listening(from.support_listening());
    }
    if (from.has_rpc_version()) {
      set_rpc_version(from.rpc_version());
    }
    if (from.has_credentials()) {
      mutable_credentials()->::exec::shared::UserCredentials::MergeFrom(from.credentials());
    }
    if (from.has_properties()) {
      mutable_properties()->::exec::user::UserProperties::MergeFrom(from.properties());
    }
    if (from.has_support_complex_types()) {
      set_support_complex_types(from.support_complex_types());
    }
    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());
    }
  }
  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    if (from.has_sasl_support()) {
      set_sasl_support(from.sasl_support());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void UserToBitHandshake::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void UserToBitHandshake::CopyFrom(const UserToBitHandshake& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool UserToBitHandshake::IsInitialized() const {

  if (has_properties()) {
    if (!this->properties().IsInitialized()) return false;
  }
  return true;
}

void UserToBitHandshake::Swap(UserToBitHandshake* other) {
  if (other != this) {
    std::swap(channel_, other->channel_);
    std::swap(support_listening_, other->support_listening_);
    std::swap(rpc_version_, other->rpc_version_);
    std::swap(credentials_, other->credentials_);
    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(sasl_support_, other->sasl_support_);
    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 UserToBitHandshake::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = UserToBitHandshake_descriptor_;
  metadata.reflection = UserToBitHandshake_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int RequestResults::kQueryIdFieldNumber;
const int RequestResults::kMaximumResponsesFieldNumber;
#endif  // !_MSC_VER

RequestResults::RequestResults()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void RequestResults::InitAsDefaultInstance() {
  query_id_ = const_cast< ::exec::shared::QueryId*>(&::exec::shared::QueryId::default_instance());
}

RequestResults::RequestResults(const RequestResults& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void RequestResults::SharedCtor() {
  _cached_size_ = 0;
  query_id_ = NULL;
  maximum_responses_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

RequestResults::~RequestResults() {
  SharedDtor();
}

void RequestResults::SharedDtor() {
  if (this != default_instance_) {
    delete query_id_;
  }
}

void RequestResults::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* RequestResults::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return RequestResults_descriptor_;
}

const RequestResults& RequestResults::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_User_2eproto();
  return *default_instance_;
}

RequestResults* RequestResults::default_instance_ = NULL;

RequestResults* RequestResults::New() const {
  return new RequestResults;
}

void RequestResults::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_query_id()) {
      if (query_id_ != NULL) query_id_->::exec::shared::QueryId::Clear();
    }
    maximum_responses_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool RequestResults::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.shared.QueryId query_id = 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_query_id()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_maximum_responses;
        break;
      }

      // optional int32 maximum_responses = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_maximum_responses:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &maximum_responses_)));
          set_has_maximum_responses();
        } 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 RequestResults::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional .exec.shared.QueryId query_id = 1;
  if (has_query_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->query_id(), output);
  }

  // optional int32 maximum_responses = 2;
  if (has_maximum_responses()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->maximum_responses(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* RequestResults::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional .exec.shared.QueryId query_id = 1;
  if (has_query_id()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->query_id(), target);
  }

  // optional int32 maximum_responses = 2;
  if (has_maximum_responses()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->maximum_responses(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int RequestResults::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .exec.shared.QueryId query_id = 1;
    if (has_query_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->query_id());
    }

    // optional int32 maximum_responses = 2;
    if (has_maximum_responses()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->maximum_responses());
    }

  }
  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 RequestResults::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const RequestResults* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const RequestResults*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void RequestResults::MergeFrom(const RequestResults& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_query_id()) {
      mutable_query_id()->::exec::shared::QueryId::MergeFrom(from.query_id());
    }
    if (from.has_maximum_responses()) {
      set_maximum_responses(from.maximum_responses());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void RequestResults::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RequestResults::CopyFrom(const RequestResults& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RequestResults::IsInitialized() const {

  return true;
}

void RequestResults::Swap(RequestResults* other) {
  if (other != this) {
    std::swap(query_id_, other->query_id_);
    std::swap(maximum_responses_, other->maximum_responses_);
    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 RequestResults::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = RequestResults_descriptor_;
  metadata.reflection = RequestResults_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int GetQueryPlanFragments::kQueryFieldNumber;
const int GetQueryPlanFragments::kTypeFieldNumber;
const int GetQueryPlanFragments::kSplitPlanFieldNumber;
#endif  // !_MSC_VER

GetQueryPlanFragments::GetQueryPlanFragments()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void GetQueryPlanFragments::InitAsDefaultInstance() {
}

GetQueryPlanFragments::GetQueryPlanFragments(const GetQueryPlanFragments& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void GetQueryPlanFragments::SharedCtor() {
  _cached_size_ = 0;
  query_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  type_ = 1;
  split_plan_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

GetQueryPlanFragments::~GetQueryPlanFragments() {
  SharedDtor();
}

void GetQueryPlanFragments::SharedDtor() {
  if (query_ != &::google::protobuf::internal::kEmptyString) {
    delete query_;
  }
  if (this != default_instance_) {
  }
}

void GetQueryPlanFragments::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* GetQueryPlanFragments::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return GetQueryPlanFragments_descriptor_;
}

const GetQueryPlanFragments& GetQueryPlanFragments::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_User_2eproto();
  return *default_instance_;
}

GetQueryPlanFragments* GetQueryPlanFragments::default_instance_ = NULL;

GetQueryPlanFragments* GetQueryPlanFragments::New() const {
  return new GetQueryPlanFragments;
}

void GetQueryPlanFragments::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    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 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)) {
      // required string 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_query()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->query().data(), this->query().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } 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(24)) goto parse_split_plan;
        break;
      }

      // optional bool split_plan = 3 [default = false];
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::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;
        }
        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 GetQueryPlanFragments::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // 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;
  if (has_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->type(), 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()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* GetQueryPlanFragments::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // 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;
  if (has_type()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      2, this->type(), 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()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int GetQueryPlanFragments::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required string query = 1;
    if (has_query()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->query());
    }

    // optional .exec.shared.QueryType type = 2;
    if (has_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
    }

    // optional bool split_plan = 3 [default = false];
    if (has_split_plan()) {
      total_size += 1 + 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 GetQueryPlanFragments::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const GetQueryPlanFragments* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const GetQueryPlanFragments*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void GetQueryPlanFragments::MergeFrom(const GetQueryPlanFragments& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_query()) {
      set_query(from.query());
    }
    if (from.has_type()) {
      set_type(from.type());
    }
    if (from.has_split_plan()) {
      set_split_plan(from.split_plan());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void GetQueryPlanFragments::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void GetQueryPlanFragments::CopyFrom(const GetQueryPlanFragments& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GetQueryPlanFragments::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  return true;
}

void GetQueryPlanFragments::Swap(GetQueryPlanFragments* other) {
  if (other != this) {
    std::swap(query_, other->query_);
    std::swap(type_, other->type_);
    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 GetQueryPlanFragments::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  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;
}


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

#ifndef _MSC_VER
const int BitToUserHandshake::kRpcVersionFieldNumber;
const int BitToUserHandshake::kStatusFieldNumber;
const int BitToUserHandshake::kErrorIdFieldNumber;
const int BitToUserHandshake::kErrorMessageFieldNumber;
const int BitToUserHandshake::kServerInfosFieldNumber;
const int BitToUserHandshake::kAuthenticationMechanismsFieldNumber;
const int BitToUserHandshake::kSupportedMethodsFieldNumber;
const int BitToUserHandshake::kEncryptedFieldNumber;
const int BitToUserHandshake::kMaxWrappedSizeFieldNumber;
#endif  // !_MSC_VER

BitToUserHandshake::BitToUserHandshake()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void BitToUserHandshake::InitAsDefaultInstance() {
  server_infos_ = const_cast< ::exec::user::RpcEndpointInfos*>(&::exec::user::RpcEndpointInfos::default_instance());
}

BitToUserHandshake::BitToUserHandshake(const BitToUserHandshake& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void BitToUserHandshake::SharedCtor() {
  _cached_size_ = 0;
  rpc_version_ = 0;
  status_ = 1;
  errorid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  errormessage_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  server_infos_ = NULL;
  encrypted_ = false;
  maxwrappedsize_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

BitToUserHandshake::~BitToUserHandshake() {
  SharedDtor();
}

void BitToUserHandshake::SharedDtor() {
  if (errorid_ != &::google::protobuf::internal::kEmptyString) {
    delete errorid_;
  }
  if (errormessage_ != &::google::protobuf::internal::kEmptyString) {
    delete errormessage_;
  }
  if (this != default_instance_) {
    delete server_infos_;
  }
}

void BitToUserHandshake::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* BitToUserHandshake::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return BitToUserHandshake_descriptor_;
}

const BitToUserHandshake& BitToUserHandshake::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_User_2eproto();
  return *default_instance_;
}

BitToUserHandshake* BitToUserHandshake::default_instance_ = NULL;

BitToUserHandshake* BitToUserHandshake::New() const {
  return new BitToUserHandshake;
}

void BitToUserHandshake::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    rpc_version_ = 0;
    status_ = 1;
    if (has_errorid()) {
      if (errorid_ != &::google::protobuf::internal::kEmptyString) {
        errorid_->clear();
      }
    }
    if (has_errormessage()) {
      if (errormessage_ != &::google::protobuf::internal::kEmptyString) {
        errormessage_->clear();
      }
    }
    if (has_server_infos()) {
      if (server_infos_ != NULL) server_infos_->::exec::user::RpcEndpointInfos::Clear();
    }
    encrypted_ = false;
  }
  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    maxwrappedsize_ = 0;
  }
  authenticationmechanisms_.Clear();
  supported_methods_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool BitToUserHandshake::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 int32 rpc_version = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &rpc_version_)));
          set_has_rpc_version();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_status;
        break;
      }

      // optional .exec.user.HandshakeStatus status = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_status:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::exec::user::HandshakeStatus_IsValid(value)) {
            set_status(static_cast< ::exec::user::HandshakeStatus >(value));
          } else {
            mutable_unknown_fields()->AddVarint(3, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(34)) goto parse_errorId;
        break;
      }

      // optional string errorId = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_errorId:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_errorid()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->errorid().data(), this->errorid().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(42)) goto parse_errorMessage;
        break;
      }

      // optional string errorMessage = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_errorMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_errormessage()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->errormessage().data(), this->errormessage().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } 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->ExpectTag(58)) goto parse_authenticationMechanisms;
        break;
      }

      // repeated string authenticationMechanisms = 7;
      case 7: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_authenticationMechanisms:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->add_authenticationmechanisms()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->authenticationmechanisms(this->authenticationmechanisms_size() - 1).data(),
            this->authenticationmechanisms(this->authenticationmechanisms_size() - 1).length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(58)) goto parse_authenticationMechanisms;
        if (input->ExpectTag(64)) goto parse_supported_methods;
        break;
      }

      // repeated .exec.user.RpcType supported_methods = 8;
      case 8: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_supported_methods:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::exec::user::RpcType_IsValid(value)) {
            add_supported_methods(static_cast< ::exec::user::RpcType >(value));
          } else {
            mutable_unknown_fields()->AddVarint(8, value);
          }
        } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag)
                   == ::google::protobuf::internal::WireFormatLite::
                      WIRETYPE_LENGTH_DELIMITED) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedEnumNoInline(
                 input,
                 &::exec::user::RpcType_IsValid,
                 this->mutable_supported_methods())));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(64)) goto parse_supported_methods;
        if (input->ExpectTag(72)) goto parse_encrypted;
        break;
      }

      // optional bool encrypted = 9;
      case 9: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_encrypted:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &encrypted_)));
          set_has_encrypted();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(80)) goto parse_maxWrappedSize;
        break;
      }

      // optional int32 maxWrappedSize = 10;
      case 10: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_maxWrappedSize:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &maxwrappedsize_)));
          set_has_maxwrappedsize();
        } 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 BitToUserHandshake::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional int32 rpc_version = 2;
  if (has_rpc_version()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->rpc_version(), output);
  }

  // optional .exec.user.HandshakeStatus status = 3;
  if (has_status()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      3, this->status(), output);
  }

  // optional string errorId = 4;
  if (has_errorid()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->errorid().data(), this->errorid().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      4, this->errorid(), output);
  }

  // optional string errorMessage = 5;
  if (has_errormessage()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->errormessage().data(), this->errormessage().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      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);
  }

  // repeated string authenticationMechanisms = 7;
  for (int i = 0; i < this->authenticationmechanisms_size(); i++) {
  ::google::protobuf::internal::WireFormat::VerifyUTF8String(
    this->authenticationmechanisms(i).data(), this->authenticationmechanisms(i).length(),
    ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      7, this->authenticationmechanisms(i), output);
  }

  // repeated .exec.user.RpcType supported_methods = 8;
  for (int i = 0; i < this->supported_methods_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      8, this->supported_methods(i), output);
  }

  // optional bool encrypted = 9;
  if (has_encrypted()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(9, this->encrypted(), output);
  }

  // optional int32 maxWrappedSize = 10;
  if (has_maxwrappedsize()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(10, this->maxwrappedsize(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* BitToUserHandshake::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional int32 rpc_version = 2;
  if (has_rpc_version()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->rpc_version(), target);
  }

  // optional .exec.user.HandshakeStatus status = 3;
  if (has_status()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      3, this->status(), target);
  }

  // optional string errorId = 4;
  if (has_errorid()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->errorid().data(), this->errorid().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        4, this->errorid(), target);
  }

  // optional string errorMessage = 5;
  if (has_errormessage()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->errormessage().data(), this->errormessage().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        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);
  }

  // repeated string authenticationMechanisms = 7;
  for (int i = 0; i < this->authenticationmechanisms_size(); i++) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->authenticationmechanisms(i).data(), this->authenticationmechanisms(i).length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target = ::google::protobuf::internal::WireFormatLite::
      WriteStringToArray(7, this->authenticationmechanisms(i), target);
  }

  // repeated .exec.user.RpcType supported_methods = 8;
  for (int i = 0; i < this->supported_methods_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      8, this->supported_methods(i), target);
  }

  // optional bool encrypted = 9;
  if (has_encrypted()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(9, this->encrypted(), target);
  }

  // optional int32 maxWrappedSize = 10;
  if (has_maxwrappedsize()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(10, this->maxwrappedsize(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int BitToUserHandshake::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional int32 rpc_version = 2;
    if (has_rpc_version()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->rpc_version());
    }

    // optional .exec.user.HandshakeStatus status = 3;
    if (has_status()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->status());
    }

    // optional string errorId = 4;
    if (has_errorid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->errorid());
    }

    // optional string errorMessage = 5;
    if (has_errormessage()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->errormessage());
    }

    // optional .exec.user.RpcEndpointInfos server_infos = 6;
    if (has_server_infos()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->server_infos());
    }

    // optional bool encrypted = 9;
    if (has_encrypted()) {
      total_size += 1 + 1;
    }

  }
  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    // optional int32 maxWrappedSize = 10;
    if (has_maxwrappedsize()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->maxwrappedsize());
    }

  }
  // repeated string authenticationMechanisms = 7;
  total_size += 1 * this->authenticationmechanisms_size();
  for (int i = 0; i < this->authenticationmechanisms_size(); i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
      this->authenticationmechanisms(i));
  }

  // repeated .exec.user.RpcType supported_methods = 8;
  {
    int data_size = 0;
    for (int i = 0; i < this->supported_methods_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::EnumSize(
        this->supported_methods(i));
    }
    total_size += 1 * this->supported_methods_size() + data_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 BitToUserHandshake::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const BitToUserHandshake* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const BitToUserHandshake*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void BitToUserHandshake::MergeFrom(const BitToUserHandshake& from) {
  GOOGLE_CHECK_NE(&from, this);
  authenticationmechanisms_.MergeFrom(from.authenticationmechanisms_);
  supported_methods_.MergeFrom(from.supported_methods_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_rpc_version()) {
      set_rpc_version(from.rpc_version());
    }
    if (from.has_status()) {
      set_status(from.status());
    }
    if (from.has_errorid()) {
      set_errorid(from.errorid());
    }
    if (from.has_errormessage()) {
      set_errormessage(from.errormessage());
    }
    if (from.has_server_infos()) {
      mutable_server_infos()->::exec::user::RpcEndpointInfos::MergeFrom(from.server_infos());
    }
    if (from.has_encrypted()) {
      set_encrypted(from.encrypted());
    }
  }
  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    if (from.has_maxwrappedsize()) {
      set_maxwrappedsize(from.maxwrappedsize());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void BitToUserHandshake::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void BitToUserHandshake::CopyFrom(const BitToUserHandshake& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool BitToUserHandshake::IsInitialized() const {

  return true;
}

void BitToUserHandshake::Swap(BitToUserHandshake* other) {
  if (other != this) {
    std::swap(rpc_version_, other->rpc_version_);
    std::swap(status_, other->status_);
    std::swap(errorid_, other->errorid_);
    std::swap(errormessage_, other->errormessage_);
    std::swap(server_infos_, other->server_infos_);
    authenticationmechanisms_.Swap(&other->authenticationmechanisms_);
    supported_methods_.Swap(&other->supported_methods_);
    std::swap(encrypted_, other->encrypted_);
    std::swap(maxwrappedsize_, other->maxwrappedsize_);
    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 BitToUserHandshake::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = BitToUserHandshake_descriptor_;
  metadata.reflection = BitToUserHandshake_reflection_;
  return metadata;
}


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

#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
#endif  // !_MSC_VER

GetServerMetaReq::GetServerMetaReq()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void GetServerMetaReq::InitAsDefaultInstance() {
}

GetServerMetaReq::GetServerMetaReq(const GetServerMetaReq& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void GetServerMetaReq::SharedCtor() {
  _cached_size_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

GetServerMetaReq::~GetServerMetaReq() {
  SharedDtor();
}

void GetServerMetaReq::SharedDtor() {
  if (this != default_instance_) {
  }
}

void GetServerMetaReq::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* GetServerMetaReq::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return GetServerMetaReq_descriptor_;
}

const GetServerMetaReq& GetServerMetaReq::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_User_2eproto();
  return *default_instance_;
}

GetServerMetaReq* GetServerMetaReq::default_instance_ = NULL;

GetServerMetaReq* GetServerMetaReq::New() const {
  return new GetServerMetaReq;
}

void GetServerMetaReq::Clear() {
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool GetServerMetaReq::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    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()));
  }
  return true;
#undef DO_
}

void GetServerMetaReq::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* GetServerMetaReq::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int GetServerMetaReq::ByteSize() const {
  int total_size = 0;

  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 GetServerMetaReq::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const GetServerMetaReq* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const GetServerMetaReq*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void GetServerMetaReq::MergeFrom(const GetServerMetaReq& from) {
  GOOGLE_CHECK_NE(&from, this);
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void GetServerMetaReq::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void GetServerMetaReq::CopyFrom(const GetServerMetaReq& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GetServerMetaReq::IsInitialized() const {

  return true;
}

void GetServerMetaReq::Swap(GetServerMetaReq* other) {
  if (other != this) {
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata GetServerMetaReq::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = GetServerMetaReq_descriptor_;
  metadata.reflection = GetServerMetaReq_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int ConvertSupport::kFromFieldNumber;
const int ConvertSupport::kToFieldNumber;
#endif  // !_MSC_VER

ConvertSupport::ConvertSupport()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void ConvertSupport::InitAsDefaultInstance() {
}

ConvertSupport::ConvertSupport(const ConvertSupport& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void ConvertSupport::SharedCtor() {
  _cached_size_ = 0;
  from_ = 0;
  to_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ConvertSupport::~ConvertSupport() {
  SharedDtor();
}

void ConvertSupport::SharedDtor() {
  if (this != default_instance_) {
  }
}

void ConvertSupport::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ConvertSupport::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return ConvertSupport_descriptor_;
}

const ConvertSupport& ConvertSupport::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_User_2eproto();
  return *default_instance_;
}

ConvertSupport* ConvertSupport::default_instance_ = NULL;

ConvertSupport* ConvertSupport::New() const {
  return new ConvertSupport;
}

void ConvertSupport::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    from_ = 0;
    to_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool ConvertSupport::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 .common.MinorType from = 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 (::common::MinorType_IsValid(value)) {
            set_from(static_cast< ::common::MinorType >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_to;
        break;
      }

      // required .common.MinorType to = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_to:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::common::MinorType_IsValid(value)) {
            set_to(static_cast< ::common::MinorType >(value));
          } else {
            mutable_unknown_fields()->AddVarint(2, value);
          }
        } 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 ConvertSupport::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .common.MinorType from = 1;
  if (has_from()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->from(), output);
  }

  // required .common.MinorType to = 2;
  if (has_to()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->to(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* ConvertSupport::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .common.MinorType from = 1;
  if (has_from()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->from(), target);
  }

  // required .common.MinorType to = 2;
  if (has_to()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      2, this->to(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int ConvertSupport::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .common.MinorType from = 1;
    if (has_from()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->from());
    }

    // required .common.MinorType to = 2;
    if (has_to()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->to());
    }

  }
  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 ConvertSupport::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const ConvertSupport* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const ConvertSupport*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void ConvertSupport::MergeFrom(const ConvertSupport& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_from()) {
      set_from(from.from());
    }
    if (from.has_to()) {
      set_to(from.to());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void ConvertSupport::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ConvertSupport::CopyFrom(const ConvertSupport& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ConvertSupport::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void ConvertSupport::Swap(ConvertSupport* other) {
  if (other != this) {
    std::swap(from_, other->from_);
    std::swap(to_, other->to_);
    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 ConvertSupport::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = ConvertSupport_descriptor_;
  metadata.reflection = ConvertSupport_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int GetServerMetaResp::kStatusFieldNumber;
const int GetServerMetaResp::kServerMetaFieldNumber;
const int GetServerMetaResp::kErrorFieldNumber;
#endif  // !_MSC_VER

GetServerMetaResp::GetServerMetaResp()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void GetServerMetaResp::InitAsDefaultInstance() {
  server_meta_ = const_cast< ::exec::user::ServerMeta*>(&::exec::user::ServerMeta::default_instance());
  error_ = const_cast< ::exec::shared::DrillPBError*>(&::exec::shared::DrillPBError::default_instance());
}

GetServerMetaResp::GetServerMetaResp(const GetServerMetaResp& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void GetServerMetaResp::SharedCtor() {
  _cached_size_ = 0;
  status_ = 0;
  server_meta_ = NULL;
  error_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

GetServerMetaResp::~GetServerMetaResp() {
  SharedDtor();
}

void GetServerMetaResp::SharedDtor() {
  if (this != default_instance_) {
    delete server_meta_;
    delete error_;
  }
}

void GetServerMetaResp::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* GetServerMetaResp::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return GetServerMetaResp_descriptor_;
}

const GetServerMetaResp& GetServerMetaResp::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_User_2eproto();
  return *default_instance_;
}

GetServerMetaResp* GetServerMetaResp::default_instance_ = NULL;

GetServerMetaResp* GetServerMetaResp::New() const {
  return new GetServerMetaResp;
}

void GetServerMetaResp::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    status_ = 0;
    if (has_server_meta()) {
      if (server_meta_ != NULL) server_meta_->::exec::user::ServerMeta::Clear();
    }
    if (has_error()) {
      if (error_ != NULL) error_->::exec::shared::DrillPBError::Clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool GetServerMetaResp::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_server_meta;
        break;
      }

      // optional .exec.user.ServerMeta server_meta = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_server_meta:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_server_meta()));
        } 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 GetServerMetaResp::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.ServerMeta server_meta = 2;
  if (has_server_meta()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->server_meta(), 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* GetServerMetaResp::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.ServerMeta server_meta = 2;
  if (has_server_meta()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->server_meta(), 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 GetServerMetaResp::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.ServerMeta server_meta = 2;
    if (has_server_meta()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->server_meta());
    }

    // 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 GetServerMetaResp::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const GetServerMetaResp* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const GetServerMetaResp*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void GetServerMetaResp::MergeFrom(const GetServerMetaResp& 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_server_meta()) {
      mutable_server_meta()->::exec::user::ServerMeta::MergeFrom(from.server_meta());
    }
    if (from.has_error()) {
      mutable_error()->::exec::shared::DrillPBError::MergeFrom(from.error());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void GetServerMetaResp::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void GetServerMetaResp::CopyFrom(const GetServerMetaResp& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GetServerMetaResp::IsInitialized() const {

  if (has_server_meta()) {
    if (!this->server_meta().IsInitialized()) return false;
  }
  return true;
}

void GetServerMetaResp::Swap(GetServerMetaResp* other) {
  if (other != this) {
    std::swap(status_, other->status_);
    std::swap(server_meta_, other->server_meta_);
    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 GetServerMetaResp::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = GetServerMetaResp_descriptor_;
  metadata.reflection = GetServerMetaResp_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int ServerMeta::kAllTablesSelectableFieldNumber;
const int ServerMeta::kBlobIncludedInMaxRowSizeFieldNumber;
const int ServerMeta::kCatalogAtStartFieldNumber;
const int ServerMeta::kCatalogSeparatorFieldNumber;
const int ServerMeta::kCatalogTermFieldNumber;
const int ServerMeta::kCollateSupportFieldNumber;
const int ServerMeta::kColumnAliasingSupportedFieldNumber;
const int ServerMeta::kConvertSupportFieldNumber;
const int ServerMeta::kCorrelationNamesSupportFieldNumber;
const int ServerMeta::kDateTimeFunctionsFieldNumber;
const int ServerMeta::kDateTimeLiteralsSupportFieldNumber;
const int ServerMeta::kGroupBySupportFieldNumber;
const int ServerMeta::kIdentifierCasingFieldNumber;
const int ServerMeta::kIdentifierQuoteStringFieldNumber;
const int ServerMeta::kLikeEscapeClauseSupportedFieldNumber;
const int ServerMeta::kMaxBinaryLiteralLengthFieldNumber;
const int ServerMeta::kMaxCatalogNameLengthFieldNumber;
const int ServerMeta::kMaxCharLiteralLengthFieldNumber;
const int ServerMeta::kMaxColumnNameLengthFieldNumber;
const int ServerMeta::kMaxColumnsInGroupByFieldNumber;
const int ServerMeta::kMaxColumnsInOrderByFieldNumber;
const int ServerMeta::kMaxColumnsInSelectFieldNumber;
const int ServerMeta::kMaxCursorNameLengthFieldNumber;
const int ServerMeta::kMaxLogicalLobSizeFieldNumber;
const int ServerMeta::kMaxRowSizeFieldNumber;
const int ServerMeta::kMaxSchemaNameLengthFieldNumber;
const int ServerMeta::kMaxStatementLengthFieldNumber;
const int ServerMeta::kMaxStatementsFieldNumber;
const int ServerMeta::kMaxTableNameLengthFieldNumber;
const int ServerMeta::kMaxTablesInSelectFieldNumber;
const int ServerMeta::kMaxUserNameLengthFieldNumber;
const int ServerMeta::kNullCollationFieldNumber;
const int ServerMeta::kNullPlusNonNullEqualsNullFieldNumber;
const int ServerMeta::kNumericFunctionsFieldNumber;
const int ServerMeta::kOrderBySupportFieldNumber;
const int ServerMeta::kOuterJoinSupportFieldNumber;
const int ServerMeta::kQuotedIdentifierCasingFieldNumber;
const int ServerMeta::kReadOnlyFieldNumber;
const int ServerMeta::kSchemaTermFieldNumber;
const int ServerMeta::kSearchEscapeStringFieldNumber;
const int ServerMeta::kSelectForUpdateSupportedFieldNumber;
const int ServerMeta::kSpecialCharactersFieldNumber;
const int ServerMeta::kSqlKeywordsFieldNumber;
const int ServerMeta::kStringFunctionsFieldNumber;
const int ServerMeta::kSubquerySupportFieldNumber;
const int ServerMeta::kSystemFunctionsFieldNumber;
const int ServerMeta::kTableTermFieldNumber;
const int ServerMeta::kTransactionSupportedFieldNumber;
const int ServerMeta::kUnionSupportFieldNumber;
#endif  // !_MSC_VER

ServerMeta::ServerMeta()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void ServerMeta::InitAsDefaultInstance() {
}

ServerMeta::ServerMeta(const ServerMeta& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void ServerMeta::SharedCtor() {
  _cached_size_ = 0;
  all_tables_selectable_ = false;
  blob_included_in_max_row_size_ = false;
  catalog_at_start_ = false;
  catalog_separator_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  catalog_term_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  column_aliasing_supported_ = false;
  correlation_names_support_ = 1;
  group_by_support_ = 1;
  identifier_casing_ = 0;
  identifier_quote_string_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  like_escape_clause_supported_ = false;
  max_binary_literal_length_ = 0u;
  max_catalog_name_length_ = 0u;
  max_char_literal_length_ = 0u;
  max_column_name_length_ = 0u;
  max_columns_in_group_by_ = 0u;
  max_columns_in_order_by_ = 0u;
  max_columns_in_select_ = 0u;
  max_cursor_name_length_ = 0u;
  max_logical_lob_size_ = 0u;
  max_row_size_ = 0u;
  max_schema_name_length_ = 0u;
  max_statement_length_ = 0u;
  max_statements_ = 0u;
  max_table_name_length_ = 0u;
  max_tables_in_select_ = 0u;
  max_user_name_length_ = 0u;
  null_collation_ = 0;
  null_plus_non_null_equals_null_ = false;
  quoted_identifier_casing_ = 0;
  read_only_ = false;
  schema_term_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  search_escape_string_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  select_for_update_supported_ = false;
  special_characters_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  table_term_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  transaction_supported_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ServerMeta::~ServerMeta() {
  SharedDtor();
}

void ServerMeta::SharedDtor() {
  if (catalog_separator_ != &::google::protobuf::internal::kEmptyString) {
    delete catalog_separator_;
  }
  if (catalog_term_ != &::google::protobuf::internal::kEmptyString) {
    delete catalog_term_;
  }
  if (identifier_quote_string_ != &::google::protobuf::internal::kEmptyString) {
    delete identifier_quote_string_;
  }
  if (schema_term_ != &::google::protobuf::internal::kEmptyString) {
    delete schema_term_;
  }
  if (search_escape_string_ != &::google::protobuf::internal::kEmptyString) {
    delete search_escape_string_;
  }
  if (special_characters_ != &::google::protobuf::internal::kEmptyString) {
    delete special_characters_;
  }
  if (table_term_ != &::google::protobuf::internal::kEmptyString) {
    delete table_term_;
  }
  if (this != default_instance_) {
  }
}

void ServerMeta::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ServerMeta::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return ServerMeta_descriptor_;
}

const ServerMeta& ServerMeta::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_User_2eproto();
  return *default_instance_;
}

ServerMeta* ServerMeta::default_instance_ = NULL;

ServerMeta* ServerMeta::New() const {
  return new ServerMeta;
}

void ServerMeta::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    all_tables_selectable_ = false;
    blob_included_in_max_row_size_ = false;
    catalog_at_start_ = false;
    if (has_catalog_separator()) {
      if (catalog_separator_ != &::google::protobuf::internal::kEmptyString) {
        catalog_separator_->clear();
      }
    }
    if (has_catalog_term()) {
      if (catalog_term_ != &::google::protobuf::internal::kEmptyString) {
        catalog_term_->clear();
      }
    }
    column_aliasing_supported_ = false;
  }
  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    correlation_names_support_ = 1;
    group_by_support_ = 1;
    identifier_casing_ = 0;
    if (has_identifier_quote_string()) {
      if (identifier_quote_string_ != &::google::protobuf::internal::kEmptyString) {
        identifier_quote_string_->clear();
      }
    }
    like_escape_clause_supported_ = false;
    max_binary_literal_length_ = 0u;
  }
  if (_has_bits_[16 / 32] & (0xffu << (16 % 32))) {
    max_catalog_name_length_ = 0u;
    max_char_literal_length_ = 0u;
    max_column_name_length_ = 0u;
    max_columns_in_group_by_ = 0u;
    max_columns_in_order_by_ = 0u;
    max_columns_in_select_ = 0u;
    max_cursor_name_length_ = 0u;
    max_logical_lob_size_ = 0u;
  }
  if (_has_bits_[24 / 32] & (0xffu << (24 % 32))) {
    max_row_size_ = 0u;
    max_schema_name_length_ = 0u;
    max_statement_length_ = 0u;
    max_statements_ = 0u;
    max_table_name_length_ = 0u;
    max_tables_in_select_ = 0u;
    max_user_name_length_ = 0u;
    null_collation_ = 0;
  }
  if (_has_bits_[32 / 32] & (0xffu << (32 % 32))) {
    null_plus_non_null_equals_null_ = false;
    quoted_identifier_casing_ = 0;
    read_only_ = false;
    if (has_schema_term()) {
      if (schema_term_ != &::google::protobuf::internal::kEmptyString) {
        schema_term_->clear();
      }
    }
    if (has_search_escape_string()) {
      if (search_escape_string_ != &::google::protobuf::internal::kEmptyString) {
        search_escape_string_->clear();
      }
    }
  }
  if (_has_bits_[40 / 32] & (0xffu << (40 % 32))) {
    select_for_update_supported_ = false;
    if (has_special_characters()) {
      if (special_characters_ != &::google::protobuf::internal::kEmptyString) {
        special_characters_->clear();
      }
    }
    if (has_table_term()) {
      if (table_term_ != &::google::protobuf::internal::kEmptyString) {
        table_term_->clear();
      }
    }
    transaction_supported_ = false;
  }
  collate_support_.Clear();
  convert_support_.Clear();
  date_time_functions_.Clear();
  date_time_literals_support_.Clear();
  numeric_functions_.Clear();
  order_by_support_.Clear();
  outer_join_support_.Clear();
  sql_keywords_.Clear();
  string_functions_.Clear();
  subquery_support_.Clear();
  system_functions_.Clear();
  union_support_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool ServerMeta::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 bool all_tables_selectable = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &all_tables_selectable_)));
          set_has_all_tables_selectable();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_blob_included_in_max_row_size;
        break;
      }

      // optional bool blob_included_in_max_row_size = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_blob_included_in_max_row_size:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &blob_included_in_max_row_size_)));
          set_has_blob_included_in_max_row_size();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_catalog_at_start;
        break;
      }

      // optional bool catalog_at_start = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_catalog_at_start:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &catalog_at_start_)));
          set_has_catalog_at_start();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(34)) goto parse_catalog_separator;
        break;
      }

      // optional string catalog_separator = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_catalog_separator:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_catalog_separator()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->catalog_separator().data(), this->catalog_separator().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(42)) goto parse_catalog_term;
        break;
      }

      // optional string catalog_term = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_catalog_term:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_catalog_term()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->catalog_term().data(), this->catalog_term().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(48)) goto parse_collate_support;
        break;
      }

      // repeated .exec.user.CollateSupport collate_support = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_collate_support:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::exec::user::CollateSupport_IsValid(value)) {
            add_collate_support(static_cast< ::exec::user::CollateSupport >(value));
          } else {
            mutable_unknown_fields()->AddVarint(6, value);
          }
        } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag)
                   == ::google::protobuf::internal::WireFormatLite::
                      WIRETYPE_LENGTH_DELIMITED) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedEnumNoInline(
                 input,
                 &::exec::user::CollateSupport_IsValid,
                 this->mutable_collate_support())));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(48)) goto parse_collate_support;
        if (input->ExpectTag(56)) goto parse_column_aliasing_supported;
        break;
      }

      // optional bool column_aliasing_supported = 7;
      case 7: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_column_aliasing_supported:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &column_aliasing_supported_)));
          set_has_column_aliasing_supported();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(66)) goto parse_convert_support;
        break;
      }

      // repeated .exec.user.ConvertSupport convert_support = 8;
      case 8: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_convert_support:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_convert_support()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(66)) goto parse_convert_support;
        if (input->ExpectTag(72)) goto parse_correlation_names_support;
        break;
      }

      // optional .exec.user.CorrelationNamesSupport correlation_names_support = 9;
      case 9: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_correlation_names_support:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::exec::user::CorrelationNamesSupport_IsValid(value)) {
            set_correlation_names_support(static_cast< ::exec::user::CorrelationNamesSupport >(value));
          } else {
            mutable_unknown_fields()->AddVarint(9, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(82)) goto parse_date_time_functions;
        break;
      }

      // repeated string date_time_functions = 10;
      case 10: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_date_time_functions:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->add_date_time_functions()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->date_time_functions(this->date_time_functions_size() - 1).data(),
            this->date_time_functions(this->date_time_functions_size() - 1).length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(82)) goto parse_date_time_functions;
        if (input->ExpectTag(88)) goto parse_date_time_literals_support;
        break;
      }

      // repeated .exec.user.DateTimeLiteralsSupport date_time_literals_support = 11;
      case 11: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_date_time_literals_support:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::exec::user::DateTimeLiteralsSupport_IsValid(value)) {
            add_date_time_literals_support(static_cast< ::exec::user::DateTimeLiteralsSupport >(value));
          } else {
            mutable_unknown_fields()->AddVarint(11, value);
          }
        } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag)
                   == ::google::protobuf::internal::WireFormatLite::
                      WIRETYPE_LENGTH_DELIMITED) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedEnumNoInline(
                 input,
                 &::exec::user::DateTimeLiteralsSupport_IsValid,
                 this->mutable_date_time_literals_support())));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(88)) goto parse_date_time_literals_support;
        if (input->ExpectTag(96)) goto parse_group_by_support;
        break;
      }

      // optional .exec.user.GroupBySupport group_by_support = 12;
      case 12: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_group_by_support:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::exec::user::GroupBySupport_IsValid(value)) {
            set_group_by_support(static_cast< ::exec::user::GroupBySupport >(value));
          } else {
            mutable_unknown_fields()->AddVarint(12, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(104)) goto parse_identifier_casing;
        break;
      }

      // optional .exec.user.IdentifierCasing identifier_casing = 13;
      case 13: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_identifier_casing:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::exec::user::IdentifierCasing_IsValid(value)) {
            set_identifier_casing(static_cast< ::exec::user::IdentifierCasing >(value));
          } else {
            mutable_unknown_fields()->AddVarint(13, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(114)) goto parse_identifier_quote_string;
        break;
      }

      // optional string identifier_quote_string = 14;
      case 14: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_identifier_quote_string:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_identifier_quote_string()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->identifier_quote_string().data(), this->identifier_quote_string().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(120)) goto parse_like_escape_clause_supported;
        break;
      }

      // optional bool like_escape_clause_supported = 15;
      case 15: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_like_escape_clause_supported:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &like_escape_clause_supported_)));
          set_has_like_escape_clause_supported();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(128)) goto parse_max_binary_literal_length;
        break;
      }

      // optional uint32 max_binary_literal_length = 16;
      case 16: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_max_binary_literal_length:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &max_binary_literal_length_)));
          set_has_max_binary_literal_length();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(136)) goto parse_max_catalog_name_length;
        break;
      }

      // optional uint32 max_catalog_name_length = 17;
      case 17: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_max_catalog_name_length:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &max_catalog_name_length_)));
          set_has_max_catalog_name_length();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(144)) goto parse_max_char_literal_length;
        break;
      }

      // optional uint32 max_char_literal_length = 18;
      case 18: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_max_char_literal_length:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &max_char_literal_length_)));
          set_has_max_char_literal_length();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(152)) goto parse_max_column_name_length;
        break;
      }

      // optional uint32 max_column_name_length = 19;
      case 19: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_max_column_name_length:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &max_column_name_length_)));
          set_has_max_column_name_length();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(160)) goto parse_max_columns_in_group_by;
        break;
      }

      // optional uint32 max_columns_in_group_by = 20;
      case 20: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_max_columns_in_group_by:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &max_columns_in_group_by_)));
          set_has_max_columns_in_group_by();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(168)) goto parse_max_columns_in_order_by;
        break;
      }

      // optional uint32 max_columns_in_order_by = 21;
      case 21: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_max_columns_in_order_by:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &max_columns_in_order_by_)));
          set_has_max_columns_in_order_by();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(176)) goto parse_max_columns_in_select;
        break;
      }

      // optional uint32 max_columns_in_select = 22;
      case 22: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_max_columns_in_select:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &max_columns_in_select_)));
          set_has_max_columns_in_select();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(184)) goto parse_max_cursor_name_length;
        break;
      }

      // optional uint32 max_cursor_name_length = 23;
      case 23: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_max_cursor_name_length:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &max_cursor_name_length_)));
          set_has_max_cursor_name_length();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(192)) goto parse_max_logical_lob_size;
        break;
      }

      // optional uint32 max_logical_lob_size = 24;
      case 24: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_max_logical_lob_size:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &max_logical_lob_size_)));
          set_has_max_logical_lob_size();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(200)) goto parse_max_row_size;
        break;
      }

      // optional uint32 max_row_size = 25;
      case 25: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_max_row_size:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &max_row_size_)));
          set_has_max_row_size();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(208)) goto parse_max_schema_name_length;
        break;
      }

      // optional uint32 max_schema_name_length = 26;
      case 26: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_max_schema_name_length:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &max_schema_name_length_)));
          set_has_max_schema_name_length();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(216)) goto parse_max_statement_length;
        break;
      }

      // optional uint32 max_statement_length = 27;
      case 27: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_max_statement_length:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &max_statement_length_)));
          set_has_max_statement_length();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(224)) goto parse_max_statements;
        break;
      }

      // optional uint32 max_statements = 28;
      case 28: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_max_statements:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &max_statements_)));
          set_has_max_statements();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(232)) goto parse_max_table_name_length;
        break;
      }

      // optional uint32 max_table_name_length = 29;
      case 29: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_max_table_name_length:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &max_table_name_length_)));
          set_has_max_table_name_length();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(240)) goto parse_max_tables_in_select;
        break;
      }

      // optional uint32 max_tables_in_select = 30;
      case 30: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_max_tables_in_select:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &max_tables_in_select_)));
          set_has_max_tables_in_select();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(248)) goto parse_max_user_name_length;
        break;
      }

      // optional uint32 max_user_name_length = 31;
      case 31: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_max_user_name_length:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &max_user_name_length_)));
          set_has_max_user_name_length();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(256)) goto parse_null_collation;
        break;
      }

      // optional .exec.user.NullCollation null_collation = 32;
      case 32: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_null_collation:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::exec::user::NullCollation_IsValid(value)) {
            set_null_collation(static_cast< ::exec::user::NullCollation >(value));
          } else {
            mutable_unknown_fields()->AddVarint(32, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(264)) goto parse_null_plus_non_null_equals_null;
        break;
      }

      // optional bool null_plus_non_null_equals_null = 33;
      case 33: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_null_plus_non_null_equals_null:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &null_plus_non_null_equals_null_)));
          set_has_null_plus_non_null_equals_null();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(274)) goto parse_numeric_functions;
        break;
      }

      // repeated string numeric_functions = 34;
      case 34: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_numeric_functions:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->add_numeric_functions()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->numeric_functions(this->numeric_functions_size() - 1).data(),
            this->numeric_functions(this->numeric_functions_size() - 1).length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(274)) goto parse_numeric_functions;
        if (input->ExpectTag(280)) goto parse_order_by_support;
        break;
      }

      // repeated .exec.user.OrderBySupport order_by_support = 35;
      case 35: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_order_by_support:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::exec::user::OrderBySupport_IsValid(value)) {
            add_order_by_support(static_cast< ::exec::user::OrderBySupport >(value));
          } else {
            mutable_unknown_fields()->AddVarint(35, value);
          }
        } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag)
                   == ::google::protobuf::internal::WireFormatLite::
                      WIRETYPE_LENGTH_DELIMITED) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedEnumNoInline(
                 input,
                 &::exec::user::OrderBySupport_IsValid,
                 this->mutable_order_by_support())));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(280)) goto parse_order_by_support;
        if (input->ExpectTag(288)) goto parse_outer_join_support;
        break;
      }

      // repeated .exec.user.OuterJoinSupport outer_join_support = 36;
      case 36: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_outer_join_support:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::exec::user::OuterJoinSupport_IsValid(value)) {
            add_outer_join_support(static_cast< ::exec::user::OuterJoinSupport >(value));
          } else {
            mutable_unknown_fields()->AddVarint(36, value);
          }
        } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag)
                   == ::google::protobuf::internal::WireFormatLite::
                      WIRETYPE_LENGTH_DELIMITED) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedEnumNoInline(
                 input,
                 &::exec::user::OuterJoinSupport_IsValid,
                 this->mutable_outer_join_support())));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(288)) goto parse_outer_join_support;
        if (input->ExpectTag(296)) goto parse_quoted_identifier_casing;
        break;
      }

      // optional .exec.user.IdentifierCasing quoted_identifier_casing = 37;
      case 37: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_quoted_identifier_casing:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::exec::user::IdentifierCasing_IsValid(value)) {
            set_quoted_identifier_casing(static_cast< ::exec::user::IdentifierCasing >(value));
          } else {
            mutable_unknown_fields()->AddVarint(37, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(304)) goto parse_read_only;
        break;
      }

      // optional bool read_only = 38;
      case 38: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_read_only:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &read_only_)));
          set_has_read_only();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(314)) goto parse_schema_term;
        break;
      }

      // optional string schema_term = 39;
      case 39: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_schema_term:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_schema_term()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->schema_term().data(), this->schema_term().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(322)) goto parse_search_escape_string;
        break;
      }

      // optional string search_escape_string = 40;
      case 40: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_search_escape_string:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_search_escape_string()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->search_escape_string().data(), this->search_escape_string().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(328)) goto parse_select_for_update_supported;
        break;
      }

      // optional bool select_for_update_supported = 41;
      case 41: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_select_for_update_supported:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &select_for_update_supported_)));
          set_has_select_for_update_supported();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(338)) goto parse_special_characters;
        break;
      }

      // optional string special_characters = 42;
      case 42: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_special_characters:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_special_characters()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->special_characters().data(), this->special_characters().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(346)) goto parse_sql_keywords;
        break;
      }

      // repeated string sql_keywords = 43;
      case 43: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_sql_keywords:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->add_sql_keywords()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->sql_keywords(this->sql_keywords_size() - 1).data(),
            this->sql_keywords(this->sql_keywords_size() - 1).length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(346)) goto parse_sql_keywords;
        if (input->ExpectTag(354)) goto parse_string_functions;
        break;
      }

      // repeated string string_functions = 44;
      case 44: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_string_functions:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->add_string_functions()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->string_functions(this->string_functions_size() - 1).data(),
            this->string_functions(this->string_functions_size() - 1).length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(354)) goto parse_string_functions;
        if (input->ExpectTag(360)) goto parse_subquery_support;
        break;
      }

      // repeated .exec.user.SubQuerySupport subquery_support = 45;
      case 45: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_subquery_support:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::exec::user::SubQuerySupport_IsValid(value)) {
            add_subquery_support(static_cast< ::exec::user::SubQuerySupport >(value));
          } else {
            mutable_unknown_fields()->AddVarint(45, value);
          }
        } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag)
                   == ::google::protobuf::internal::WireFormatLite::
                      WIRETYPE_LENGTH_DELIMITED) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedEnumNoInline(
                 input,
                 &::exec::user::SubQuerySupport_IsValid,
                 this->mutable_subquery_support())));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(360)) goto parse_subquery_support;
        if (input->ExpectTag(370)) goto parse_system_functions;
        break;
      }

      // repeated string system_functions = 46;
      case 46: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_system_functions:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->add_system_functions()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->system_functions(this->system_functions_size() - 1).data(),
            this->system_functions(this->system_functions_size() - 1).length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(370)) goto parse_system_functions;
        if (input->ExpectTag(378)) goto parse_table_term;
        break;
      }

      // optional string table_term = 47;
      case 47: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_table_term:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_table_term()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->table_term().data(), this->table_term().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(384)) goto parse_transaction_supported;
        break;
      }

      // optional bool transaction_supported = 48;
      case 48: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_transaction_supported:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &transaction_supported_)));
          set_has_transaction_supported();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(392)) goto parse_union_support;
        break;
      }

      // repeated .exec.user.UnionSupport union_support = 49;
      case 49: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_union_support:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::exec::user::UnionSupport_IsValid(value)) {
            add_union_support(static_cast< ::exec::user::UnionSupport >(value));
          } else {
            mutable_unknown_fields()->AddVarint(49, value);
          }
        } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag)
                   == ::google::protobuf::internal::WireFormatLite::
                      WIRETYPE_LENGTH_DELIMITED) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedEnumNoInline(
                 input,
                 &::exec::user::UnionSupport_IsValid,
                 this->mutable_union_support())));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(392)) goto parse_union_support;
        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 ServerMeta::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional bool all_tables_selectable = 1;
  if (has_all_tables_selectable()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->all_tables_selectable(), output);
  }

  // optional bool blob_included_in_max_row_size = 2;
  if (has_blob_included_in_max_row_size()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->blob_included_in_max_row_size(), output);
  }

  // optional bool catalog_at_start = 3;
  if (has_catalog_at_start()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->catalog_at_start(), output);
  }

  // optional string catalog_separator = 4;
  if (has_catalog_separator()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->catalog_separator().data(), this->catalog_separator().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      4, this->catalog_separator(), output);
  }

  // optional string catalog_term = 5;
  if (has_catalog_term()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->catalog_term().data(), this->catalog_term().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      5, this->catalog_term(), output);
  }

  // repeated .exec.user.CollateSupport collate_support = 6;
  for (int i = 0; i < this->collate_support_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      6, this->collate_support(i), output);
  }

  // optional bool column_aliasing_supported = 7;
  if (has_column_aliasing_supported()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->column_aliasing_supported(), output);
  }

  // repeated .exec.user.ConvertSupport convert_support = 8;
  for (int i = 0; i < this->convert_support_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      8, this->convert_support(i), output);
  }

  // optional .exec.user.CorrelationNamesSupport correlation_names_support = 9;
  if (has_correlation_names_support()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      9, this->correlation_names_support(), output);
  }

  // repeated string date_time_functions = 10;
  for (int i = 0; i < this->date_time_functions_size(); i++) {
  ::google::protobuf::internal::WireFormat::VerifyUTF8String(
    this->date_time_functions(i).data(), this->date_time_functions(i).length(),
    ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      10, this->date_time_functions(i), output);
  }

  // repeated .exec.user.DateTimeLiteralsSupport date_time_literals_support = 11;
  for (int i = 0; i < this->date_time_literals_support_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      11, this->date_time_literals_support(i), output);
  }

  // optional .exec.user.GroupBySupport group_by_support = 12;
  if (has_group_by_support()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      12, this->group_by_support(), output);
  }

  // optional .exec.user.IdentifierCasing identifier_casing = 13;
  if (has_identifier_casing()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      13, this->identifier_casing(), output);
  }

  // optional string identifier_quote_string = 14;
  if (has_identifier_quote_string()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->identifier_quote_string().data(), this->identifier_quote_string().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      14, this->identifier_quote_string(), output);
  }

  // optional bool like_escape_clause_supported = 15;
  if (has_like_escape_clause_supported()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(15, this->like_escape_clause_supported(), output);
  }

  // optional uint32 max_binary_literal_length = 16;
  if (has_max_binary_literal_length()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(16, this->max_binary_literal_length(), output);
  }

  // optional uint32 max_catalog_name_length = 17;
  if (has_max_catalog_name_length()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(17, this->max_catalog_name_length(), output);
  }

  // optional uint32 max_char_literal_length = 18;
  if (has_max_char_literal_length()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(18, this->max_char_literal_length(), output);
  }

  // optional uint32 max_column_name_length = 19;
  if (has_max_column_name_length()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(19, this->max_column_name_length(), output);
  }

  // optional uint32 max_columns_in_group_by = 20;
  if (has_max_columns_in_group_by()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(20, this->max_columns_in_group_by(), output);
  }

  // optional uint32 max_columns_in_order_by = 21;
  if (has_max_columns_in_order_by()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(21, this->max_columns_in_order_by(), output);
  }

  // optional uint32 max_columns_in_select = 22;
  if (has_max_columns_in_select()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(22, this->max_columns_in_select(), output);
  }

  // optional uint32 max_cursor_name_length = 23;
  if (has_max_cursor_name_length()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(23, this->max_cursor_name_length(), output);
  }

  // optional uint32 max_logical_lob_size = 24;
  if (has_max_logical_lob_size()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(24, this->max_logical_lob_size(), output);
  }

  // optional uint32 max_row_size = 25;
  if (has_max_row_size()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(25, this->max_row_size(), output);
  }

  // optional uint32 max_schema_name_length = 26;
  if (has_max_schema_name_length()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(26, this->max_schema_name_length(), output);
  }

  // optional uint32 max_statement_length = 27;
  if (has_max_statement_length()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(27, this->max_statement_length(), output);
  }

  // optional uint32 max_statements = 28;
  if (has_max_statements()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(28, this->max_statements(), output);
  }

  // optional uint32 max_table_name_length = 29;
  if (has_max_table_name_length()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(29, this->max_table_name_length(), output);
  }

  // optional uint32 max_tables_in_select = 30;
  if (has_max_tables_in_select()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(30, this->max_tables_in_select(), output);
  }

  // optional uint32 max_user_name_length = 31;
  if (has_max_user_name_length()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(31, this->max_user_name_length(), output);
  }

  // optional .exec.user.NullCollation null_collation = 32;
  if (has_null_collation()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      32, this->null_collation(), output);
  }

  // optional bool null_plus_non_null_equals_null = 33;
  if (has_null_plus_non_null_equals_null()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(33, this->null_plus_non_null_equals_null(), output);
  }

  // repeated string numeric_functions = 34;
  for (int i = 0; i < this->numeric_functions_size(); i++) {
  ::google::protobuf::internal::WireFormat::VerifyUTF8String(
    this->numeric_functions(i).data(), this->numeric_functions(i).length(),
    ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      34, this->numeric_functions(i), output);
  }

  // repeated .exec.user.OrderBySupport order_by_support = 35;
  for (int i = 0; i < this->order_by_support_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      35, this->order_by_support(i), output);
  }

  // repeated .exec.user.OuterJoinSupport outer_join_support = 36;
  for (int i = 0; i < this->outer_join_support_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      36, this->outer_join_support(i), output);
  }

  // optional .exec.user.IdentifierCasing quoted_identifier_casing = 37;
  if (has_quoted_identifier_casing()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      37, this->quoted_identifier_casing(), output);
  }

  // optional bool read_only = 38;
  if (has_read_only()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(38, this->read_only(), output);
  }

  // optional string schema_term = 39;
  if (has_schema_term()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->schema_term().data(), this->schema_term().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      39, this->schema_term(), output);
  }

  // optional string search_escape_string = 40;
  if (has_search_escape_string()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->search_escape_string().data(), this->search_escape_string().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      40, this->search_escape_string(), output);
  }

  // optional bool select_for_update_supported = 41;
  if (has_select_for_update_supported()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(41, this->select_for_update_supported(), output);
  }

  // optional string special_characters = 42;
  if (has_special_characters()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->special_characters().data(), this->special_characters().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      42, this->special_characters(), output);
  }

  // repeated string sql_keywords = 43;
  for (int i = 0; i < this->sql_keywords_size(); i++) {
  ::google::protobuf::internal::WireFormat::VerifyUTF8String(
    this->sql_keywords(i).data(), this->sql_keywords(i).length(),
    ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      43, this->sql_keywords(i), output);
  }

  // repeated string string_functions = 44;
  for (int i = 0; i < this->string_functions_size(); i++) {
  ::google::protobuf::internal::WireFormat::VerifyUTF8String(
    this->string_functions(i).data(), this->string_functions(i).length(),
    ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      44, this->string_functions(i), output);
  }

  // repeated .exec.user.SubQuerySupport subquery_support = 45;
  for (int i = 0; i < this->subquery_support_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      45, this->subquery_support(i), output);
  }

  // repeated string system_functions = 46;
  for (int i = 0; i < this->system_functions_size(); i++) {
  ::google::protobuf::internal::WireFormat::VerifyUTF8String(
    this->system_functions(i).data(), this->system_functions(i).length(),
    ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      46, this->system_functions(i), output);
  }

  // optional string table_term = 47;
  if (has_table_term()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->table_term().data(), this->table_term().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      47, this->table_term(), output);
  }

  // optional bool transaction_supported = 48;
  if (has_transaction_supported()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(48, this->transaction_supported(), output);
  }

  // repeated .exec.user.UnionSupport union_support = 49;
  for (int i = 0; i < this->union_support_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      49, this->union_support(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* ServerMeta::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional bool all_tables_selectable = 1;
  if (has_all_tables_selectable()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->all_tables_selectable(), target);
  }

  // optional bool blob_included_in_max_row_size = 2;
  if (has_blob_included_in_max_row_size()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->blob_included_in_max_row_size(), target);
  }

  // optional bool catalog_at_start = 3;
  if (has_catalog_at_start()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->catalog_at_start(), target);
  }

  // optional string catalog_separator = 4;
  if (has_catalog_separator()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->catalog_separator().data(), this->catalog_separator().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        4, this->catalog_separator(), target);
  }

  // optional string catalog_term = 5;
  if (has_catalog_term()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->catalog_term().data(), this->catalog_term().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        5, this->catalog_term(), target);
  }

  // repeated .exec.user.CollateSupport collate_support = 6;
  for (int i = 0; i < this->collate_support_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      6, this->collate_support(i), target);
  }

  // optional bool column_aliasing_supported = 7;
  if (has_column_aliasing_supported()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(7, this->column_aliasing_supported(), target);
  }

  // repeated .exec.user.ConvertSupport convert_support = 8;
  for (int i = 0; i < this->convert_support_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        8, this->convert_support(i), target);
  }

  // optional .exec.user.CorrelationNamesSupport correlation_names_support = 9;
  if (has_correlation_names_support()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      9, this->correlation_names_support(), target);
  }

  // repeated string date_time_functions = 10;
  for (int i = 0; i < this->date_time_functions_size(); i++) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->date_time_functions(i).data(), this->date_time_functions(i).length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target = ::google::protobuf::internal::WireFormatLite::
      WriteStringToArray(10, this->date_time_functions(i), target);
  }

  // repeated .exec.user.DateTimeLiteralsSupport date_time_literals_support = 11;
  for (int i = 0; i < this->date_time_literals_support_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      11, this->date_time_literals_support(i), target);
  }

  // optional .exec.user.GroupBySupport group_by_support = 12;
  if (has_group_by_support()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      12, this->group_by_support(), target);
  }

  // optional .exec.user.IdentifierCasing identifier_casing = 13;
  if (has_identifier_casing()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      13, this->identifier_casing(), target);
  }

  // optional string identifier_quote_string = 14;
  if (has_identifier_quote_string()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->identifier_quote_string().data(), this->identifier_quote_string().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        14, this->identifier_quote_string(), target);
  }

  // optional bool like_escape_clause_supported = 15;
  if (has_like_escape_clause_supported()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(15, this->like_escape_clause_supported(), target);
  }

  // optional uint32 max_binary_literal_length = 16;
  if (has_max_binary_literal_length()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(16, this->max_binary_literal_length(), target);
  }

  // optional uint32 max_catalog_name_length = 17;
  if (has_max_catalog_name_length()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(17, this->max_catalog_name_length(), target);
  }

  // optional uint32 max_char_literal_length = 18;
  if (has_max_char_literal_length()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(18, this->max_char_literal_length(), target);
  }

  // optional uint32 max_column_name_length = 19;
  if (has_max_column_name_length()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(19, this->max_column_name_length(), target);
  }

  // optional uint32 max_columns_in_group_by = 20;
  if (has_max_columns_in_group_by()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(20, this->max_columns_in_group_by(), target);
  }

  // optional uint32 max_columns_in_order_by = 21;
  if (has_max_columns_in_order_by()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(21, this->max_columns_in_order_by(), target);
  }

  // optional uint32 max_columns_in_select = 22;
  if (has_max_columns_in_select()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(22, this->max_columns_in_select(), target);
  }

  // optional uint32 max_cursor_name_length = 23;
  if (has_max_cursor_name_length()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(23, this->max_cursor_name_length(), target);
  }

  // optional uint32 max_logical_lob_size = 24;
  if (has_max_logical_lob_size()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(24, this->max_logical_lob_size(), target);
  }

  // optional uint32 max_row_size = 25;
  if (has_max_row_size()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(25, this->max_row_size(), target);
  }

  // optional uint32 max_schema_name_length = 26;
  if (has_max_schema_name_length()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(26, this->max_schema_name_length(), target);
  }

  // optional uint32 max_statement_length = 27;
  if (has_max_statement_length()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(27, this->max_statement_length(), target);
  }

  // optional uint32 max_statements = 28;
  if (has_max_statements()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(28, this->max_statements(), target);
  }

  // optional uint32 max_table_name_length = 29;
  if (has_max_table_name_length()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(29, this->max_table_name_length(), target);
  }

  // optional uint32 max_tables_in_select = 30;
  if (has_max_tables_in_select()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(30, this->max_tables_in_select(), target);
  }

  // optional uint32 max_user_name_length = 31;
  if (has_max_user_name_length()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(31, this->max_user_name_length(), target);
  }

  // optional .exec.user.NullCollation null_collation = 32;
  if (has_null_collation()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      32, this->null_collation(), target);
  }

  // optional bool null_plus_non_null_equals_null = 33;
  if (has_null_plus_non_null_equals_null()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(33, this->null_plus_non_null_equals_null(), target);
  }

  // repeated string numeric_functions = 34;
  for (int i = 0; i < this->numeric_functions_size(); i++) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->numeric_functions(i).data(), this->numeric_functions(i).length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target = ::google::protobuf::internal::WireFormatLite::
      WriteStringToArray(34, this->numeric_functions(i), target);
  }

  // repeated .exec.user.OrderBySupport order_by_support = 35;
  for (int i = 0; i < this->order_by_support_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      35, this->order_by_support(i), target);
  }

  // repeated .exec.user.OuterJoinSupport outer_join_support = 36;
  for (int i = 0; i < this->outer_join_support_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      36, this->outer_join_support(i), target);
  }

  // optional .exec.user.IdentifierCasing quoted_identifier_casing = 37;
  if (has_quoted_identifier_casing()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      37, this->quoted_identifier_casing(), target);
  }

  // optional bool read_only = 38;
  if (has_read_only()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(38, this->read_only(), target);
  }

  // optional string schema_term = 39;
  if (has_schema_term()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->schema_term().data(), this->schema_term().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        39, this->schema_term(), target);
  }

  // optional string search_escape_string = 40;
  if (has_search_escape_string()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->search_escape_string().data(), this->search_escape_string().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        40, this->search_escape_string(), target);
  }

  // optional bool select_for_update_supported = 41;
  if (has_select_for_update_supported()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(41, this->select_for_update_supported(), target);
  }

  // optional string special_characters = 42;
  if (has_special_characters()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->special_characters().data(), this->special_characters().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        42, this->special_characters(), target);
  }

  // repeated string sql_keywords = 43;
  for (int i = 0; i < this->sql_keywords_size(); i++) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->sql_keywords(i).data(), this->sql_keywords(i).length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target = ::google::protobuf::internal::WireFormatLite::
      WriteStringToArray(43, this->sql_keywords(i), target);
  }

  // repeated string string_functions = 44;
  for (int i = 0; i < this->string_functions_size(); i++) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->string_functions(i).data(), this->string_functions(i).length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target = ::google::protobuf::internal::WireFormatLite::
      WriteStringToArray(44, this->string_functions(i), target);
  }

  // repeated .exec.user.SubQuerySupport subquery_support = 45;
  for (int i = 0; i < this->subquery_support_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      45, this->subquery_support(i), target);
  }

  // repeated string system_functions = 46;
  for (int i = 0; i < this->system_functions_size(); i++) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->system_functions(i).data(), this->system_functions(i).length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target = ::google::protobuf::internal::WireFormatLite::
      WriteStringToArray(46, this->system_functions(i), target);
  }

  // optional string table_term = 47;
  if (has_table_term()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->table_term().data(), this->table_term().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        47, this->table_term(), target);
  }

  // optional bool transaction_supported = 48;
  if (has_transaction_supported()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(48, this->transaction_supported(), target);
  }

  // repeated .exec.user.UnionSupport union_support = 49;
  for (int i = 0; i < this->union_support_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      49, this->union_support(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int ServerMeta::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional bool all_tables_selectable = 1;
    if (has_all_tables_selectable()) {
      total_size += 1 + 1;
    }

    // optional bool blob_included_in_max_row_size = 2;
    if (has_blob_included_in_max_row_size()) {
      total_size += 1 + 1;
    }

    // optional bool catalog_at_start = 3;
    if (has_catalog_at_start()) {
      total_size += 1 + 1;
    }

    // optional string catalog_separator = 4;
    if (has_catalog_separator()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->catalog_separator());
    }

    // optional string catalog_term = 5;
    if (has_catalog_term()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->catalog_term());
    }

    // optional bool column_aliasing_supported = 7;
    if (has_column_aliasing_supported()) {
      total_size += 1 + 1;
    }

  }
  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    // optional .exec.user.CorrelationNamesSupport correlation_names_support = 9;
    if (has_correlation_names_support()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->correlation_names_support());
    }

    // optional .exec.user.GroupBySupport group_by_support = 12;
    if (has_group_by_support()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->group_by_support());
    }

    // optional .exec.user.IdentifierCasing identifier_casing = 13;
    if (has_identifier_casing()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->identifier_casing());
    }

    // optional string identifier_quote_string = 14;
    if (has_identifier_quote_string()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->identifier_quote_string());
    }

    // optional bool like_escape_clause_supported = 15;
    if (has_like_escape_clause_supported()) {
      total_size += 1 + 1;
    }

    // optional uint32 max_binary_literal_length = 16;
    if (has_max_binary_literal_length()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->max_binary_literal_length());
    }

  }
  if (_has_bits_[16 / 32] & (0xffu << (16 % 32))) {
    // optional uint32 max_catalog_name_length = 17;
    if (has_max_catalog_name_length()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->max_catalog_name_length());
    }

    // optional uint32 max_char_literal_length = 18;
    if (has_max_char_literal_length()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->max_char_literal_length());
    }

    // optional uint32 max_column_name_length = 19;
    if (has_max_column_name_length()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->max_column_name_length());
    }

    // optional uint32 max_columns_in_group_by = 20;
    if (has_max_columns_in_group_by()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->max_columns_in_group_by());
    }

    // optional uint32 max_columns_in_order_by = 21;
    if (has_max_columns_in_order_by()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->max_columns_in_order_by());
    }

    // optional uint32 max_columns_in_select = 22;
    if (has_max_columns_in_select()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->max_columns_in_select());
    }

    // optional uint32 max_cursor_name_length = 23;
    if (has_max_cursor_name_length()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->max_cursor_name_length());
    }

    // optional uint32 max_logical_lob_size = 24;
    if (has_max_logical_lob_size()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->max_logical_lob_size());
    }

  }
  if (_has_bits_[24 / 32] & (0xffu << (24 % 32))) {
    // optional uint32 max_row_size = 25;
    if (has_max_row_size()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->max_row_size());
    }

    // optional uint32 max_schema_name_length = 26;
    if (has_max_schema_name_length()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->max_schema_name_length());
    }

    // optional uint32 max_statement_length = 27;
    if (has_max_statement_length()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->max_statement_length());
    }

    // optional uint32 max_statements = 28;
    if (has_max_statements()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->max_statements());
    }

    // optional uint32 max_table_name_length = 29;
    if (has_max_table_name_length()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->max_table_name_length());
    }

    // optional uint32 max_tables_in_select = 30;
    if (has_max_tables_in_select()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->max_tables_in_select());
    }

    // optional uint32 max_user_name_length = 31;
    if (has_max_user_name_length()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->max_user_name_length());
    }

    // optional .exec.user.NullCollation null_collation = 32;
    if (has_null_collation()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->null_collation());
    }

  }
  if (_has_bits_[32 / 32] & (0xffu << (32 % 32))) {
    // optional bool null_plus_non_null_equals_null = 33;
    if (has_null_plus_non_null_equals_null()) {
      total_size += 2 + 1;
    }

    // optional .exec.user.IdentifierCasing quoted_identifier_casing = 37;
    if (has_quoted_identifier_casing()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->quoted_identifier_casing());
    }

    // optional bool read_only = 38;
    if (has_read_only()) {
      total_size += 2 + 1;
    }

    // optional string schema_term = 39;
    if (has_schema_term()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->schema_term());
    }

    // optional string search_escape_string = 40;
    if (has_search_escape_string()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->search_escape_string());
    }

  }
  if (_has_bits_[40 / 32] & (0xffu << (40 % 32))) {
    // optional bool select_for_update_supported = 41;
    if (has_select_for_update_supported()) {
      total_size += 2 + 1;
    }

    // optional string special_characters = 42;
    if (has_special_characters()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->special_characters());
    }

    // optional string table_term = 47;
    if (has_table_term()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->table_term());
    }

    // optional bool transaction_supported = 48;
    if (has_transaction_supported()) {
      total_size += 2 + 1;
    }

  }
  // repeated .exec.user.CollateSupport collate_support = 6;
  {
    int data_size = 0;
    for (int i = 0; i < this->collate_support_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::EnumSize(
        this->collate_support(i));
    }
    total_size += 1 * this->collate_support_size() + data_size;
  }

  // repeated .exec.user.ConvertSupport convert_support = 8;
  total_size += 1 * this->convert_support_size();
  for (int i = 0; i < this->convert_support_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->convert_support(i));
  }

  // repeated string date_time_functions = 10;
  total_size += 1 * this->date_time_functions_size();
  for (int i = 0; i < this->date_time_functions_size(); i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
      this->date_time_functions(i));
  }

  // repeated .exec.user.DateTimeLiteralsSupport date_time_literals_support = 11;
  {
    int data_size = 0;
    for (int i = 0; i < this->date_time_literals_support_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::EnumSize(
        this->date_time_literals_support(i));
    }
    total_size += 1 * this->date_time_literals_support_size() + data_size;
  }

  // repeated string numeric_functions = 34;
  total_size += 2 * this->numeric_functions_size();
  for (int i = 0; i < this->numeric_functions_size(); i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
      this->numeric_functions(i));
  }

  // repeated .exec.user.OrderBySupport order_by_support = 35;
  {
    int data_size = 0;
    for (int i = 0; i < this->order_by_support_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::EnumSize(
        this->order_by_support(i));
    }
    total_size += 2 * this->order_by_support_size() + data_size;
  }

  // repeated .exec.user.OuterJoinSupport outer_join_support = 36;
  {
    int data_size = 0;
    for (int i = 0; i < this->outer_join_support_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::EnumSize(
        this->outer_join_support(i));
    }
    total_size += 2 * this->outer_join_support_size() + data_size;
  }

  // repeated string sql_keywords = 43;
  total_size += 2 * this->sql_keywords_size();
  for (int i = 0; i < this->sql_keywords_size(); i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
      this->sql_keywords(i));
  }

  // repeated string string_functions = 44;
  total_size += 2 * this->string_functions_size();
  for (int i = 0; i < this->string_functions_size(); i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
      this->string_functions(i));
  }

  // repeated .exec.user.SubQuerySupport subquery_support = 45;
  {
    int data_size = 0;
    for (int i = 0; i < this->subquery_support_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::EnumSize(
        this->subquery_support(i));
    }
    total_size += 2 * this->subquery_support_size() + data_size;
  }

  // repeated string system_functions = 46;
  total_size += 2 * this->system_functions_size();
  for (int i = 0; i < this->system_functions_size(); i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
      this->system_functions(i));
  }

  // repeated .exec.user.UnionSupport union_support = 49;
  {
    int data_size = 0;
    for (int i = 0; i < this->union_support_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::EnumSize(
        this->union_support(i));
    }
    total_size += 2 * this->union_support_size() + data_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 ServerMeta::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const ServerMeta* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const ServerMeta*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void ServerMeta::MergeFrom(const ServerMeta& from) {
  GOOGLE_CHECK_NE(&from, this);
  collate_support_.MergeFrom(from.collate_support_);
  convert_support_.MergeFrom(from.convert_support_);
  date_time_functions_.MergeFrom(from.date_time_functions_);
  date_time_literals_support_.MergeFrom(from.date_time_literals_support_);
  numeric_functions_.MergeFrom(from.numeric_functions_);
  order_by_support_.MergeFrom(from.order_by_support_);
  outer_join_support_.MergeFrom(from.outer_join_support_);
  sql_keywords_.MergeFrom(from.sql_keywords_);
  string_functions_.MergeFrom(from.string_functions_);
  subquery_support_.MergeFrom(from.subquery_support_);
  system_functions_.MergeFrom(from.system_functions_);
  union_support_.MergeFrom(from.union_support_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_all_tables_selectable()) {
      set_all_tables_selectable(from.all_tables_selectable());
    }
    if (from.has_blob_included_in_max_row_size()) {
      set_blob_included_in_max_row_size(from.blob_included_in_max_row_size());
    }
    if (from.has_catalog_at_start()) {
      set_catalog_at_start(from.catalog_at_start());
    }
    if (from.has_catalog_separator()) {
      set_catalog_separator(from.catalog_separator());
    }
    if (from.has_catalog_term()) {
      set_catalog_term(from.catalog_term());
    }
    if (from.has_column_aliasing_supported()) {
      set_column_aliasing_supported(from.column_aliasing_supported());
    }
  }
  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    if (from.has_correlation_names_support()) {
      set_correlation_names_support(from.correlation_names_support());
    }
    if (from.has_group_by_support()) {
      set_group_by_support(from.group_by_support());
    }
    if (from.has_identifier_casing()) {
      set_identifier_casing(from.identifier_casing());
    }
    if (from.has_identifier_quote_string()) {
      set_identifier_quote_string(from.identifier_quote_string());
    }
    if (from.has_like_escape_clause_supported()) {
      set_like_escape_clause_supported(from.like_escape_clause_supported());
    }
    if (from.has_max_binary_literal_length()) {
      set_max_binary_literal_length(from.max_binary_literal_length());
    }
  }
  if (from._has_bits_[16 / 32] & (0xffu << (16 % 32))) {
    if (from.has_max_catalog_name_length()) {
      set_max_catalog_name_length(from.max_catalog_name_length());
    }
    if (from.has_max_char_literal_length()) {
      set_max_char_literal_length(from.max_char_literal_length());
    }
    if (from.has_max_column_name_length()) {
      set_max_column_name_length(from.max_column_name_length());
    }
    if (from.has_max_columns_in_group_by()) {
      set_max_columns_in_group_by(from.max_columns_in_group_by());
    }
    if (from.has_max_columns_in_order_by()) {
      set_max_columns_in_order_by(from.max_columns_in_order_by());
    }
    if (from.has_max_columns_in_select()) {
      set_max_columns_in_select(from.max_columns_in_select());
    }
    if (from.has_max_cursor_name_length()) {
      set_max_cursor_name_length(from.max_cursor_name_length());
    }
    if (from.has_max_logical_lob_size()) {
      set_max_logical_lob_size(from.max_logical_lob_size());
    }
  }
  if (from._has_bits_[24 / 32] & (0xffu << (24 % 32))) {
    if (from.has_max_row_size()) {
      set_max_row_size(from.max_row_size());
    }
    if (from.has_max_schema_name_length()) {
      set_max_schema_name_length(from.max_schema_name_length());
    }
    if (from.has_max_statement_length()) {
      set_max_statement_length(from.max_statement_length());
    }
    if (from.has_max_statements()) {
      set_max_statements(from.max_statements());
    }
    if (from.has_max_table_name_length()) {
      set_max_table_name_length(from.max_table_name_length());
    }
    if (from.has_max_tables_in_select()) {
      set_max_tables_in_select(from.max_tables_in_select());
    }
    if (from.has_max_user_name_length()) {
      set_max_user_name_length(from.max_user_name_length());
    }
    if (from.has_null_collation()) {
      set_null_collation(from.null_collation());
    }
  }
  if (from._has_bits_[32 / 32] & (0xffu << (32 % 32))) {
    if (from.has_null_plus_non_null_equals_null()) {
      set_null_plus_non_null_equals_null(from.null_plus_non_null_equals_null());
    }
    if (from.has_quoted_identifier_casing()) {
      set_quoted_identifier_casing(from.quoted_identifier_casing());
    }
    if (from.has_read_only()) {
      set_read_only(from.read_only());
    }
    if (from.has_schema_term()) {
      set_schema_term(from.schema_term());
    }
    if (from.has_search_escape_string()) {
      set_search_escape_string(from.search_escape_string());
    }
  }
  if (from._has_bits_[40 / 32] & (0xffu << (40 % 32))) {
    if (from.has_select_for_update_supported()) {
      set_select_for_update_supported(from.select_for_update_supported());
    }
    if (from.has_special_characters()) {
      set_special_characters(from.special_characters());
    }
    if (from.has_table_term()) {
      set_table_term(from.table_term());
    }
    if (from.has_transaction_supported()) {
      set_transaction_supported(from.transaction_supported());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void ServerMeta::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ServerMeta::CopyFrom(const ServerMeta& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ServerMeta::IsInitialized() const {

  for (int i = 0; i < convert_support_size(); i++) {
    if (!this->convert_support(i).IsInitialized()) return false;
  }
  return true;
}

void ServerMeta::Swap(ServerMeta* other) {
  if (other != this) {
    std::swap(all_tables_selectable_, other->all_tables_selectable_);
    std::swap(blob_included_in_max_row_size_, other->blob_included_in_max_row_size_);
    std::swap(catalog_at_start_, other->catalog_at_start_);
    std::swap(catalog_separator_, other->catalog_separator_);
    std::swap(catalog_term_, other->catalog_term_);
    collate_support_.Swap(&other->collate_support_);
    std::swap(column_aliasing_supported_, other->column_aliasing_supported_);
    convert_support_.Swap(&other->convert_support_);
    std::swap(correlation_names_support_, other->correlation_names_support_);
    date_time_functions_.Swap(&other->date_time_functions_);
    date_time_literals_support_.Swap(&other->date_time_literals_support_);
    std::swap(group_by_support_, other->group_by_support_);
    std::swap(identifier_casing_, other->identifier_casing_);
    std::swap(identifier_quote_string_, other->identifier_quote_string_);
    std::swap(like_escape_clause_supported_, other->like_escape_clause_supported_);
    std::swap(max_binary_literal_length_, other->max_binary_literal_length_);
    std::swap(max_catalog_name_length_, other->max_catalog_name_length_);
    std::swap(max_char_literal_length_, other->max_char_literal_length_);
    std::swap(max_column_name_length_, other->max_column_name_length_);
    std::swap(max_columns_in_group_by_, other->max_columns_in_group_by_);
    std::swap(max_columns_in_order_by_, other->max_columns_in_order_by_);
    std::swap(max_columns_in_select_, other->max_columns_in_select_);
    std::swap(max_cursor_name_length_, other->max_cursor_name_length_);
    std::swap(max_logical_lob_size_, other->max_logical_lob_size_);
    std::swap(max_row_size_, other->max_row_size_);
    std::swap(max_schema_name_length_, other->max_schema_name_length_);
    std::swap(max_statement_length_, other->max_statement_length_);
    std::swap(max_statements_, other->max_statements_);
    std::swap(max_table_name_length_, other->max_table_name_length_);
    std::swap(max_tables_in_select_, other->max_tables_in_select_);
    std::swap(max_user_name_length_, other->max_user_name_length_);
    std::swap(null_collation_, other->null_collation_);
    std::swap(null_plus_non_null_equals_null_, other->null_plus_non_null_equals_null_);
    numeric_functions_.Swap(&other->numeric_functions_);
    order_by_support_.Swap(&other->order_by_support_);
    outer_join_support_.Swap(&other->outer_join_support_);
    std::swap(quoted_identifier_casing_, other->quoted_identifier_casing_);
    std::swap(read_only_, other->read_only_);
    std::swap(schema_term_, other->schema_term_);
    std::swap(search_escape_string_, other->search_escape_string_);
    std::swap(select_for_update_supported_, other->select_for_update_supported_);
    std::swap(special_characters_, other->special_characters_);
    sql_keywords_.Swap(&other->sql_keywords_);
    string_functions_.Swap(&other->string_functions_);
    subquery_support_.Swap(&other->subquery_support_);
    system_functions_.Swap(&other->system_functions_);
    std::swap(table_term_, other->table_term_);
    std::swap(transaction_supported_, other->transaction_supported_);
    union_support_.Swap(&other->union_support_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    std::swap(_has_bits_[1], other->_has_bits_[1]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata ServerMeta::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = ServerMeta_descriptor_;
  metadata.reflection = ServerMeta_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
}  // namespace exec

// @@protoc_insertion_point(global_scope)
