text: // 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_[7] = {
      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_),
    };
    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\"\200"
      "\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\"-\n\nLikeFilter\022\017\n\007patte"
      "rn\030\001 \001(\t\022\016\n\006escape\030\002 \001(\t\"D\n\016GetCatalogsR"
      "eq\0222\n\023catalog_name_filter\030\001 \001(\0132\025.exec.u"
      "ser.LikeFilter\"M\n\017CatalogMetadata\022\024\n\014cat"
      "alog_name\030\001 \001(\t\022\023\n\013description\030\002 \001(\t\022\017\n\007"
      "connect\030\003 \001(\t\"\223\001\n\017GetCatalogsResp\022(\n\006sta"
      "tus\030\001 \001(\0162\030.exec.user.RequestStatus\022,\n\010c"
      "atalogs\030\002 \003(\0132\032.exec.user.CatalogMetadat"
      "a\022(\n\005error\030\003 \001(\0132\031.exec.shared.DrillPBEr"
      "ror\"v\n\rGetSchemasReq\0222\n\023catalog_name_fil"
      "ter\030\001 \001(\0132\025.exec.user.LikeFilter\0221\n\022sche"
      "ma_name_filter\030\002 \001(\0132\025.exec.user.LikeFil"
      "ter\"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\016GetSc"
      "hemasResp\022(\n\006status\030\001 \001(\0162\030.exec.user.Re"
      "questStatus\022*\n\007schemas\030\002 \003(\0132\031.exec.user"
      ".SchemaMetadata\022(\n\005error\030\003 \001(\0132\031.exec.sh"
      "ared.DrillPBError\"\302\001\n\014GetTablesReq\0222\n\023ca"
      "talog_name_filter\030\001 \001(\0132\025.exec.user.Like"
      "Filter\0221\n\022schema_name_filter\030\002 \001(\0132\025.exe"
      "c.user.LikeFilter\0220\n\021table_name_filter\030\003"
      " \001(\0132\025.exec.user.LikeFilter\022\031\n\021table_typ"
      "e_filter\030\004 \003(\t\"\\\n\rTableMetadata\022\024\n\014catal"
      "og_name\030\001 \001(\t\022\023\n\013schema_name\030\002 \001(\t\022\022\n\nta"
      "ble_name\030\003 \001(\t\022\014\n\004type\030\004 \001(\t\"\215\001\n\rGetTabl"
      "esResp\022(\n\006status\030\001 \001(\0162\030.exec.user.Reque"
      "stStatus\022(\n\006tables\030\002 \003(\0132\030.exec.user.Tab"
      "leMetadata\022(\n\005error\030\003 \001(\0132\031.exec.shared."
      "DrillPBError\"\333\001\n\rGetColumnsReq\0222\n\023catalo"
      "g_name_filter\030\001 \001(\0132\025.exec.user.LikeFilt"
      "er\0221\n\022schema_name_filter\030\002 \001(\0132\025.exec.us"
      "er.LikeFilter\0220\n\021table_name_filter\030\003 \001(\013"
      "2\025.exec.user.LikeFilter\0221\n\022column_name_f"
      "ilter\030\004 \001(\0132\025.exec.user.LikeFilter\"\251\003\n\016C"
      "olumnMetadata\022\024\n\014catalog_name\030\001 \001(\t\022\023\n\013s"
      "chema_name\030\002 \001(\t\022\022\n\ntable_name\030\003 \001(\t\022\023\n\013"
      "column_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_nullabl"
      "e\030\007 \001(\010\022\021\n\tdata_type\030\010 \001(\t\022\027\n\017char_max_l"
      "ength\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_pre"
      "cision_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\rinterv"
      "al_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\016GetColumnsRes"
      "p\022(\n\006status\030\001 \001(\0162\030.exec.user.RequestSta"
      "tus\022*\n\007columns\030\002 \003(\0132\031.exec.user.ColumnM"
      "etadata\022(\n\005error\030\003 \001(\0132\031.exec.shared.Dri"
      "llPBError\"/\n\032CreatePreparedStatementReq\022"
      "\021\n\tsql_query\030\001 \001(\t\"\326\003\n\024ResultColumnMetad"
      "ata\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_nam"
      "e\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\014disp"
      "lay_size\030\013 \001(\005\022\022\n\nis_aliased\030\014 \001(\010\0225\n\rse"
      "archability\030\r \001(\0162\036.exec.user.ColumnSear"
      "chability\0223\n\014updatability\030\016 \001(\0162\035.exec.u"
      "ser.ColumnUpdatability\022\026\n\016auto_increment"
      "\030\017 \001(\010\022\030\n\020case_sensitivity\030\020 \001(\010\022\020\n\010sort"
      "able\030\021 \001(\010\022\022\n\nclass_name\030\022 \001(\t\022\023\n\013is_cur"
      "rency\030\024 \001(\010\".\n\027PreparedStatementHandle\022\023"
      "\n\013server_info\030\001 \001(\014\"\200\001\n\021PreparedStatemen"
      "t\0220\n\007columns\030\001 \003(\0132\037.exec.user.ResultCol"
      "umnMetadata\0229\n\rserver_handle\030\002 \001(\0132\".exe"
      "c.user.PreparedStatementHandle\"\253\001\n\033Creat"
      "ePreparedStatementResp\022(\n\006status\030\001 \001(\0162\030"
      ".exec.user.RequestStatus\0228\n\022prepared_sta"
      "tement\030\002 \001(\0132\034.exec.user.PreparedStateme"
      "nt\022(\n\005error\030\003 \001(\0132\031.exec.shared.DrillPBE"
      "rror\"\022\n\020GetServerMetaReq\"P\n\016ConvertSuppo"
      "rt\022\037\n\004from\030\001 \002(\0162\021.common.MinorType\022\035\n\002t"
      "o\030\002 \002(\0162\021.common.MinorType\"\223\001\n\021GetServer"
      "MetaResp\022(\n\006status\030\001 \001(\0162\030.exec.user.Req"
      "uestStatus\022*\n\013server_meta\030\002 \001(\0132\025.exec.u"
      "ser.ServerMeta\022(\n\005error\030\003 \001(\0132\031.exec.sha"
      "red.DrillPBError\"\377\r\n\nServerMeta\022\035\n\025all_t"
      "ables_selectable\030\001 \001(\010\022%\n\035blob_included_"
      "in_max_row_size\030\002 \001(\010\022\030\n\020catalog_at_star"
      "t\030\003 \001(\010\022\031\n\021catalog_separator\030\004 \001(\t\022\024\n\014ca"
      "talog_term\030\005 \001(\t\0222\n\017collate_support\030\006 \003("
      "\0162\031.exec.user.CollateSupport\022!\n\031column_a"
      "liasing_supported\030\007 \001(\010\0222\n\017convert_suppo"
      "rt\030\010 \003(\0132\031.exec.user.ConvertSupport\022E\n\031c"
      "orrelation_names_support\030\t \001(\0162\".exec.us"
      "er.CorrelationNamesSupport\022\033\n\023date_time_"
      "functions\030\n \003(\t\022F\n\032date_time_literals_su"
      "pport\030\013 \003(\0162\".exec.user.DateTimeLiterals"
      "Support\0223\n\020group_by_support\030\014 \001(\0162\031.exec"
      ".user.GroupBySupport\0226\n\021identifier_casin"
      "g\030\r \001(\0162\033.exec.user.IdentifierCasing\022\037\n\027"
      "identifier_quote_string\030\016 \001(\t\022$\n\034like_es"
      "cape_clause_supported\030\017 \001(\010\022!\n\031max_binar"
      "y_literal_length\030\020 \001(\r\022\037\n\027max_catalog_na"
      "me_length\030\021 \001(\r\022\037\n\027max_char_literal_leng"
      "th\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\027max"
      "_columns_in_order_by\030\025 \001(\r\022\035\n\025max_column"
      "s_in_select\030\026 \001(\r\022\036\n\026max_cursor_name_len"
      "gth\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_name"
      "_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_table"
      "_name_length\030\035 \001(\r\022\034\n\024max_tables_in_sele"
      "ct\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.NullC"
      "ollation\022&\n\036null_plus_non_null_equals_nu"
      "ll\030! \001(\010\022\031\n\021numeric_functions\030\" \003(\t\0223\n\020o"
      "rder_by_support\030# \003(\0162\031.exec.user.OrderB"
      "ySupport\0227\n\022outer_join_support\030$ \003(\0162\033.e"
      "xec.user.OuterJoinSupport\022=\n\030quoted_iden"
      "tifier_casing\030% \001(\0162\033.exec.user.Identifi"
      "erCasing\022\021\n\tread_only\030& \001(\010\022\023\n\013schema_te"
      "rm\030\' \001(\t\022\034\n\024search_escape_string\030( \001(\t\022#"
      "\n\033select_for_update_supported\030) \001(\010\022\032\n\022s"
      "pecial_characters\030* \001(\t\022\024\n\014sql_keywords\030"
      "+ \003(\t\022\030\n\020string_functions\030, \003(\t\0224\n\020subqu"
      "ery_support\030- \003(\0162\032.exec.user.SubQuerySu"
      "pport\022\030\n\020system_functions\030. \003(\t\022\022\n\ntable"
      "_term\030/ \001(\t\022\035\n\025transaction_supported\0300 \001"
      "(\010\022.\n\runion_support\0301 \003(\0162\027.exec.user.Un"
      "ionSupport\"\353\001\n\010RunQuery\0221\n\014results_mode\030"
      "\001 \001(\0162\033.exec.user.QueryResultsMode\022$\n\004ty"
      "pe\030\002 \001(\0162\026.exec.shared.QueryType\022\014\n\004plan"
      "\030\003 \001(\t\0221\n\tfragments\030\004 \003(\0132\036.exec.bit.con"
      "trol.PlanFragment\022E\n\031prepared_statement_"
      "handle\030\005 \001(\0132\".exec.user.PreparedStateme"
      "ntHandle*\320\003\n\007RpcType\022\r\n\tHANDSHAKE\020\000\022\007\n\003A"
      "CK\020\001\022\013\n\007GOODBYE\020\002\022\r\n\tRUN_QUERY\020\003\022\020\n\014CANC"
      "EL_QUERY\020\004\022\023\n\017REQUEST_RESULTS\020\005\022\027\n\023RESUM"
      "E_PAUSED_QUERY\020\013\022\034\n\030GET_QUERY_PLAN_FRAGM"
      "ENTS\020\014\022\020\n\014GET_CATALOGS\020\016\022\017\n\013GET_SCHEMAS\020"
      "\017\022\016\n\nGET_TABLES\020\020\022\017\n\013GET_COLUMNS\020\021\022\035\n\031CR"
      "EATE_PREPARED_STATEMENT\020\026\022\023\n\017GET_SERVER_"
      "META\020\010\022\016\n\nQUERY_DATA\020\006\022\020\n\014QUERY_HANDLE\020\007"
      "\022\030\n\024QUERY_PLAN_FRAGMENTS\020\r\022\014\n\010CATALOGS\020\022"
      "\022\013\n\007SCHEMAS\020\023\022\n\n\006TABLES\020\024\022\013\n\007COLUMNS\020\025\022\026"
      "\n\022PREPARED_STATEMENT\020\027\022\017\n\013SERVER_META\020\t\022"
      "\020\n\014QUERY_RESULT\020\n\022\020\n\014SASL_MESSAGE\020\030*6\n\013S"
      "aslSupport\022\030\n\024UNKNOWN_SASL_SUPPORT\020\000\022\r\n\t"
      "SASL_AUTH\020\001*#\n\020QueryResultsMode\022\017\n\013STREA"
      "M_FULL\020\001*q\n\017HandshakeStatus\022\013\n\007SUCCESS\020\001"
      "\022\030\n\024RPC_VERSION_MISMATCH\020\002\022\017\n\013AUTH_FAILE"
      "D\020\003\022\023\n\017UNKNOWN_FAILURE\020\004\022\021\n\rAUTH_REQUIRE"
      "D\020\005*D\n\rRequestStatus\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\023Col"
      "umnSearchability\022\031\n\025UNKNOWN_SEARCHABILIT"
      "Y\020\000\022\010\n\004NONE\020\001\022\010\n\004CHAR\020\002\022\n\n\006NUMBER\020\003\022\007\n\003A"
      "LL\020\004*K\n\022ColumnUpdatability\022\030\n\024UNKNOWN_UP"
      "DATABILITY\020\000\022\r\n\tREAD_ONLY\020\001\022\014\n\010WRITABLE\020"
      "\002*1\n\016CollateSupport\022\016\n\nCS_UNKNOWN\020\000\022\017\n\013C"
      "S_GROUP_BY\020\001*J\n\027CorrelationNamesSupport\022"
      "\013\n\007CN_NONE\020\001\022\026\n\022CN_DIFFERENT_NAMES\020\002\022\n\n\006"
      "CN_ANY\020\003*\271\003\n\027DateTimeLiteralsSupport\022\016\n\n"
      "DL_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_HOUR\020\007\022\026\n\022DL_INTERVAL_"
      "MINUTE\020\010\022\026\n\022DL_INTERVAL_SECOND\020\t\022\035\n\031DL_I"
      "NTERVAL_YEAR_TO_MONTH\020\n\022\033\n\027DL_INTERVAL_D"
      "AY_TO_HOUR\020\013\022\035\n\031DL_INTERVAL_DAY_TO_MINUT"
      "E\020\014\022\035\n\031DL_INTERVAL_DAY_TO_SECOND\020\r\022\036\n\032DL"
      "_INTERVAL_HOUR_TO_MINUTE\020\016\022\036\n\032DL_INTERVA"
      "L_HOUR_TO_SECOND\020\017\022 \n\034DL_INTERVAL_MINUTE"
      "_TO_SECOND\020\020*Y\n\016GroupBySupport\022\013\n\007GB_NON"
      "E\020\001\022\022\n\016GB_SELECT_ONLY\020\002\022\024\n\020GB_BEYOND_SEL"
      "ECT\020\003\022\020\n\014GB_UNRELATED\020\004*x\n\020IdentifierCas"
      "ing\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_MIXED\020\004*X\n\rNullCollati"
      "on\022\016\n\nNC_UNKNOWN\020\000\022\017\n\013NC_AT_START\020\001\022\r\n\tN"
      "C_AT_END\020\002\022\013\n\007NC_HIGH\020\003\022\n\n\006NC_LOW\020\004*E\n\016O"
      "rderBySupport\022\016\n\nOB_UNKNOWN\020\000\022\020\n\014OB_UNRE"
      "LATED\020\001\022\021\n\rOB_EXPRESSION\020\002*\226\001\n\020OuterJoin"
      "Support\022\016\n\nOJ_UNKNOWN\020\000\022\013\n\007OJ_LEFT\020\001\022\014\n\010"
      "OJ_RIGHT\020\002\022\013\n\007OJ_FULL\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_A"
      "LL_COMPARISON_OPS\020\007*\204\001\n\017SubQuerySupport\022"
      "\016\n\nSQ_UNKNOWN\020\000\022\021\n\rSQ_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\014Un"
      "ionSupport\022\r\n\tU_UNKNOWN\020\000\022\013\n\007U_UNION\020\001\022\017"
      "\n\013U_UNION_ALL\020\002B+\n\033org.apache.drill.exec"
      ".protoB\nUserProtosH\001", 8820);
    ::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:
        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;
  #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;
    ::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();
      }
    }
    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->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);
    }
  
    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);
    }
  
    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());
      }
  
    }
    // 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());
      }
    }
    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(_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)
  