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

#ifndef PROTOBUF_User_2eproto__INCLUDED
#define PROTOBUF_User_2eproto__INCLUDED

#include <string>

#include <google/protobuf/stubs/common.h>

#if GOOGLE_PROTOBUF_VERSION < 2005000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please update
#error your headers.
#endif
#if 2005000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include "SchemaDef.pb.h"
#include "Types.pb.h"
#include "UserBitShared.pb.h"
#include "BitData.pb.h"
#include "BitControl.pb.h"
#include "ExecutionProtos.pb.h"
// @@protoc_insertion_point(includes)

namespace exec {
namespace user {

// Internal implementation detail -- do not call these.
void  protobuf_AddDesc_User_2eproto();
void protobuf_AssignDesc_User_2eproto();
void protobuf_ShutdownFile_User_2eproto();

class Property;
class UserProperties;
class RpcEndpointInfos;
class UserToBitHandshake;
class RequestResults;
class GetQueryPlanFragments;
class QueryPlanFragments;
class BitToUserHandshake;
class LikeFilter;
class GetCatalogsReq;
class CatalogMetadata;
class GetCatalogsResp;
class GetSchemasReq;
class SchemaMetadata;
class GetSchemasResp;
class GetTablesReq;
class TableMetadata;
class GetTablesResp;
class GetColumnsReq;
class ColumnMetadata;
class GetColumnsResp;
class CreatePreparedStatementReq;
class ResultColumnMetadata;
class PreparedStatementHandle;
class PreparedStatement;
class CreatePreparedStatementResp;
class GetServerMetaReq;
class ConvertSupport;
class GetServerMetaResp;
class ServerMeta;
class RunQuery;

enum RpcType {
  HANDSHAKE = 0,
  ACK = 1,
  GOODBYE = 2,
  RUN_QUERY = 3,
  CANCEL_QUERY = 4,
  REQUEST_RESULTS = 5,
  RESUME_PAUSED_QUERY = 11,
  GET_QUERY_PLAN_FRAGMENTS = 12,
  GET_CATALOGS = 14,
  GET_SCHEMAS = 15,
  GET_TABLES = 16,
  GET_COLUMNS = 17,
  CREATE_PREPARED_STATEMENT = 22,
  GET_SERVER_META = 8,
  QUERY_DATA = 6,
  QUERY_HANDLE = 7,
  QUERY_PLAN_FRAGMENTS = 13,
  CATALOGS = 18,
  SCHEMAS = 19,
  TABLES = 20,
  COLUMNS = 21,
  PREPARED_STATEMENT = 23,
  SERVER_META = 9,
  QUERY_RESULT = 10,
  SASL_MESSAGE = 24
};
bool RpcType_IsValid(int value);
const RpcType RpcType_MIN = HANDSHAKE;
const RpcType RpcType_MAX = SASL_MESSAGE;
const int RpcType_ARRAYSIZE = RpcType_MAX + 1;

const ::google::protobuf::EnumDescriptor* RpcType_descriptor();
inline const ::std::string& RpcType_Name(RpcType value) {
  return ::google::protobuf::internal::NameOfEnum(
    RpcType_descriptor(), value);
}
inline bool RpcType_Parse(
    const ::std::string& name, RpcType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<RpcType>(
    RpcType_descriptor(), name, value);
}
enum SaslSupport {
  UNKNOWN_SASL_SUPPORT = 0,
  SASL_AUTH = 1,
  SASL_PRIVACY = 2
};
bool SaslSupport_IsValid(int value);
const SaslSupport SaslSupport_MIN = UNKNOWN_SASL_SUPPORT;
const SaslSupport SaslSupport_MAX = SASL_PRIVACY;
const int SaslSupport_ARRAYSIZE = SaslSupport_MAX + 1;

const ::google::protobuf::EnumDescriptor* SaslSupport_descriptor();
inline const ::std::string& SaslSupport_Name(SaslSupport value) {
  return ::google::protobuf::internal::NameOfEnum(
    SaslSupport_descriptor(), value);
}
inline bool SaslSupport_Parse(
    const ::std::string& name, SaslSupport* value) {
  return ::google::protobuf::internal::ParseNamedEnum<SaslSupport>(
    SaslSupport_descriptor(), name, value);
}
enum QueryResultsMode {
  STREAM_FULL = 1
};
bool QueryResultsMode_IsValid(int value);
const QueryResultsMode QueryResultsMode_MIN = STREAM_FULL;
const QueryResultsMode QueryResultsMode_MAX = STREAM_FULL;
const int QueryResultsMode_ARRAYSIZE = QueryResultsMode_MAX + 1;

const ::google::protobuf::EnumDescriptor* QueryResultsMode_descriptor();
inline const ::std::string& QueryResultsMode_Name(QueryResultsMode value) {
  return ::google::protobuf::internal::NameOfEnum(
    QueryResultsMode_descriptor(), value);
}
inline bool QueryResultsMode_Parse(
    const ::std::string& name, QueryResultsMode* value) {
  return ::google::protobuf::internal::ParseNamedEnum<QueryResultsMode>(
    QueryResultsMode_descriptor(), name, value);
}
enum HandshakeStatus {
  SUCCESS = 1,
  RPC_VERSION_MISMATCH = 2,
  AUTH_FAILED = 3,
  UNKNOWN_FAILURE = 4,
  AUTH_REQUIRED = 5
};
bool HandshakeStatus_IsValid(int value);
const HandshakeStatus HandshakeStatus_MIN = SUCCESS;
const HandshakeStatus HandshakeStatus_MAX = AUTH_REQUIRED;
const int HandshakeStatus_ARRAYSIZE = HandshakeStatus_MAX + 1;

const ::google::protobuf::EnumDescriptor* HandshakeStatus_descriptor();
inline const ::std::string& HandshakeStatus_Name(HandshakeStatus value) {
  return ::google::protobuf::internal::NameOfEnum(
    HandshakeStatus_descriptor(), value);
}
inline bool HandshakeStatus_Parse(
    const ::std::string& name, HandshakeStatus* value) {
  return ::google::protobuf::internal::ParseNamedEnum<HandshakeStatus>(
    HandshakeStatus_descriptor(), name, value);
}
enum RequestStatus {
  UNKNOWN_STATUS = 0,
  OK = 1,
  FAILED = 2,
  TIMEOUT = 3
};
bool RequestStatus_IsValid(int value);
const RequestStatus RequestStatus_MIN = UNKNOWN_STATUS;
const RequestStatus RequestStatus_MAX = TIMEOUT;
const int RequestStatus_ARRAYSIZE = RequestStatus_MAX + 1;

const ::google::protobuf::EnumDescriptor* RequestStatus_descriptor();
inline const ::std::string& RequestStatus_Name(RequestStatus value) {
  return ::google::protobuf::internal::NameOfEnum(
    RequestStatus_descriptor(), value);
}
inline bool RequestStatus_Parse(
    const ::std::string& name, RequestStatus* value) {
  return ::google::protobuf::internal::ParseNamedEnum<RequestStatus>(
    RequestStatus_descriptor(), name, value);
}
enum ColumnSearchability {
  UNKNOWN_SEARCHABILITY = 0,
  NONE = 1,
  CHAR = 2,
  NUMBER = 3,
  ALL = 4
};
bool ColumnSearchability_IsValid(int value);
const ColumnSearchability ColumnSearchability_MIN = UNKNOWN_SEARCHABILITY;
const ColumnSearchability ColumnSearchability_MAX = ALL;
const int ColumnSearchability_ARRAYSIZE = ColumnSearchability_MAX + 1;

const ::google::protobuf::EnumDescriptor* ColumnSearchability_descriptor();
inline const ::std::string& ColumnSearchability_Name(ColumnSearchability value) {
  return ::google::protobuf::internal::NameOfEnum(
    ColumnSearchability_descriptor(), value);
}
inline bool ColumnSearchability_Parse(
    const ::std::string& name, ColumnSearchability* value) {
  return ::google::protobuf::internal::ParseNamedEnum<ColumnSearchability>(
    ColumnSearchability_descriptor(), name, value);
}
enum ColumnUpdatability {
  UNKNOWN_UPDATABILITY = 0,
  READ_ONLY = 1,
  WRITABLE = 2
};
bool ColumnUpdatability_IsValid(int value);
const ColumnUpdatability ColumnUpdatability_MIN = UNKNOWN_UPDATABILITY;
const ColumnUpdatability ColumnUpdatability_MAX = WRITABLE;
const int ColumnUpdatability_ARRAYSIZE = ColumnUpdatability_MAX + 1;

const ::google::protobuf::EnumDescriptor* ColumnUpdatability_descriptor();
inline const ::std::string& ColumnUpdatability_Name(ColumnUpdatability value) {
  return ::google::protobuf::internal::NameOfEnum(
    ColumnUpdatability_descriptor(), value);
}
inline bool ColumnUpdatability_Parse(
    const ::std::string& name, ColumnUpdatability* value) {
  return ::google::protobuf::internal::ParseNamedEnum<ColumnUpdatability>(
    ColumnUpdatability_descriptor(), name, value);
}
enum CollateSupport {
  CS_UNKNOWN = 0,
  CS_GROUP_BY = 1
};
bool CollateSupport_IsValid(int value);
const CollateSupport CollateSupport_MIN = CS_UNKNOWN;
const CollateSupport CollateSupport_MAX = CS_GROUP_BY;
const int CollateSupport_ARRAYSIZE = CollateSupport_MAX + 1;

const ::google::protobuf::EnumDescriptor* CollateSupport_descriptor();
inline const ::std::string& CollateSupport_Name(CollateSupport value) {
  return ::google::protobuf::internal::NameOfEnum(
    CollateSupport_descriptor(), value);
}
inline bool CollateSupport_Parse(
    const ::std::string& name, CollateSupport* value) {
  return ::google::protobuf::internal::ParseNamedEnum<CollateSupport>(
    CollateSupport_descriptor(), name, value);
}
enum CorrelationNamesSupport {
  CN_NONE = 1,
  CN_DIFFERENT_NAMES = 2,
  CN_ANY = 3
};
bool CorrelationNamesSupport_IsValid(int value);
const CorrelationNamesSupport CorrelationNamesSupport_MIN = CN_NONE;
const CorrelationNamesSupport CorrelationNamesSupport_MAX = CN_ANY;
const int CorrelationNamesSupport_ARRAYSIZE = CorrelationNamesSupport_MAX + 1;

const ::google::protobuf::EnumDescriptor* CorrelationNamesSupport_descriptor();
inline const ::std::string& CorrelationNamesSupport_Name(CorrelationNamesSupport value) {
  return ::google::protobuf::internal::NameOfEnum(
    CorrelationNamesSupport_descriptor(), value);
}
inline bool CorrelationNamesSupport_Parse(
    const ::std::string& name, CorrelationNamesSupport* value) {
  return ::google::protobuf::internal::ParseNamedEnum<CorrelationNamesSupport>(
    CorrelationNamesSupport_descriptor(), name, value);
}
enum DateTimeLiteralsSupport {
  DL_UNKNOWN = 0,
  DL_DATE = 1,
  DL_TIME = 2,
  DL_TIMESTAMP = 3,
  DL_INTERVAL_YEAR = 4,
  DL_INTERVAL_MONTH = 5,
  DL_INTERVAL_DAY = 6,
  DL_INTERVAL_HOUR = 7,
  DL_INTERVAL_MINUTE = 8,
  DL_INTERVAL_SECOND = 9,
  DL_INTERVAL_YEAR_TO_MONTH = 10,
  DL_INTERVAL_DAY_TO_HOUR = 11,
  DL_INTERVAL_DAY_TO_MINUTE = 12,
  DL_INTERVAL_DAY_TO_SECOND = 13,
  DL_INTERVAL_HOUR_TO_MINUTE = 14,
  DL_INTERVAL_HOUR_TO_SECOND = 15,
  DL_INTERVAL_MINUTE_TO_SECOND = 16
};
bool DateTimeLiteralsSupport_IsValid(int value);
const DateTimeLiteralsSupport DateTimeLiteralsSupport_MIN = DL_UNKNOWN;
const DateTimeLiteralsSupport DateTimeLiteralsSupport_MAX = DL_INTERVAL_MINUTE_TO_SECOND;
const int DateTimeLiteralsSupport_ARRAYSIZE = DateTimeLiteralsSupport_MAX + 1;

const ::google::protobuf::EnumDescriptor* DateTimeLiteralsSupport_descriptor();
inline const ::std::string& DateTimeLiteralsSupport_Name(DateTimeLiteralsSupport value) {
  return ::google::protobuf::internal::NameOfEnum(
    DateTimeLiteralsSupport_descriptor(), value);
}
inline bool DateTimeLiteralsSupport_Parse(
    const ::std::string& name, DateTimeLiteralsSupport* value) {
  return ::google::protobuf::internal::ParseNamedEnum<DateTimeLiteralsSupport>(
    DateTimeLiteralsSupport_descriptor(), name, value);
}
enum GroupBySupport {
  GB_NONE = 1,
  GB_SELECT_ONLY = 2,
  GB_BEYOND_SELECT = 3,
  GB_UNRELATED = 4
};
bool GroupBySupport_IsValid(int value);
const GroupBySupport GroupBySupport_MIN = GB_NONE;
const GroupBySupport GroupBySupport_MAX = GB_UNRELATED;
const int GroupBySupport_ARRAYSIZE = GroupBySupport_MAX + 1;

const ::google::protobuf::EnumDescriptor* GroupBySupport_descriptor();
inline const ::std::string& GroupBySupport_Name(GroupBySupport value) {
  return ::google::protobuf::internal::NameOfEnum(
    GroupBySupport_descriptor(), value);
}
inline bool GroupBySupport_Parse(
    const ::std::string& name, GroupBySupport* value) {
  return ::google::protobuf::internal::ParseNamedEnum<GroupBySupport>(
    GroupBySupport_descriptor(), name, value);
}
enum IdentifierCasing {
  IC_UNKNOWN = 0,
  IC_STORES_LOWER = 1,
  IC_STORES_MIXED = 2,
  IC_STORES_UPPER = 3,
  IC_SUPPORTS_MIXED = 4
};
bool IdentifierCasing_IsValid(int value);
const IdentifierCasing IdentifierCasing_MIN = IC_UNKNOWN;
const IdentifierCasing IdentifierCasing_MAX = IC_SUPPORTS_MIXED;
const int IdentifierCasing_ARRAYSIZE = IdentifierCasing_MAX + 1;

const ::google::protobuf::EnumDescriptor* IdentifierCasing_descriptor();
inline const ::std::string& IdentifierCasing_Name(IdentifierCasing value) {
  return ::google::protobuf::internal::NameOfEnum(
    IdentifierCasing_descriptor(), value);
}
inline bool IdentifierCasing_Parse(
    const ::std::string& name, IdentifierCasing* value) {
  return ::google::protobuf::internal::ParseNamedEnum<IdentifierCasing>(
    IdentifierCasing_descriptor(), name, value);
}
enum NullCollation {
  NC_UNKNOWN = 0,
  NC_AT_START = 1,
  NC_AT_END = 2,
  NC_HIGH = 3,
  NC_LOW = 4
};
bool NullCollation_IsValid(int value);
const NullCollation NullCollation_MIN = NC_UNKNOWN;
const NullCollation NullCollation_MAX = NC_LOW;
const int NullCollation_ARRAYSIZE = NullCollation_MAX + 1;

const ::google::protobuf::EnumDescriptor* NullCollation_descriptor();
inline const ::std::string& NullCollation_Name(NullCollation value) {
  return ::google::protobuf::internal::NameOfEnum(
    NullCollation_descriptor(), value);
}
inline bool NullCollation_Parse(
    const ::std::string& name, NullCollation* value) {
  return ::google::protobuf::internal::ParseNamedEnum<NullCollation>(
    NullCollation_descriptor(), name, value);
}
enum OrderBySupport {
  OB_UNKNOWN = 0,
  OB_UNRELATED = 1,
  OB_EXPRESSION = 2
};
bool OrderBySupport_IsValid(int value);
const OrderBySupport OrderBySupport_MIN = OB_UNKNOWN;
const OrderBySupport OrderBySupport_MAX = OB_EXPRESSION;
const int OrderBySupport_ARRAYSIZE = OrderBySupport_MAX + 1;

const ::google::protobuf::EnumDescriptor* OrderBySupport_descriptor();
inline const ::std::string& OrderBySupport_Name(OrderBySupport value) {
  return ::google::protobuf::internal::NameOfEnum(
    OrderBySupport_descriptor(), value);
}
inline bool OrderBySupport_Parse(
    const ::std::string& name, OrderBySupport* value) {
  return ::google::protobuf::internal::ParseNamedEnum<OrderBySupport>(
    OrderBySupport_descriptor(), name, value);
}
enum OuterJoinSupport {
  OJ_UNKNOWN = 0,
  OJ_LEFT = 1,
  OJ_RIGHT = 2,
  OJ_FULL = 3,
  OJ_NESTED = 4,
  OJ_NOT_ORDERED = 5,
  OJ_INNER = 6,
  OJ_ALL_COMPARISON_OPS = 7
};
bool OuterJoinSupport_IsValid(int value);
const OuterJoinSupport OuterJoinSupport_MIN = OJ_UNKNOWN;
const OuterJoinSupport OuterJoinSupport_MAX = OJ_ALL_COMPARISON_OPS;
const int OuterJoinSupport_ARRAYSIZE = OuterJoinSupport_MAX + 1;

const ::google::protobuf::EnumDescriptor* OuterJoinSupport_descriptor();
inline const ::std::string& OuterJoinSupport_Name(OuterJoinSupport value) {
  return ::google::protobuf::internal::NameOfEnum(
    OuterJoinSupport_descriptor(), value);
}
inline bool OuterJoinSupport_Parse(
    const ::std::string& name, OuterJoinSupport* value) {
  return ::google::protobuf::internal::ParseNamedEnum<OuterJoinSupport>(
    OuterJoinSupport_descriptor(), name, value);
}
enum SubQuerySupport {
  SQ_UNKNOWN = 0,
  SQ_CORRELATED = 1,
  SQ_IN_COMPARISON = 2,
  SQ_IN_EXISTS = 3,
  SQ_IN_INSERT = 4,
  SQ_IN_QUANTIFIED = 5
};
bool SubQuerySupport_IsValid(int value);
const SubQuerySupport SubQuerySupport_MIN = SQ_UNKNOWN;
const SubQuerySupport SubQuerySupport_MAX = SQ_IN_QUANTIFIED;
const int SubQuerySupport_ARRAYSIZE = SubQuerySupport_MAX + 1;

const ::google::protobuf::EnumDescriptor* SubQuerySupport_descriptor();
inline const ::std::string& SubQuerySupport_Name(SubQuerySupport value) {
  return ::google::protobuf::internal::NameOfEnum(
    SubQuerySupport_descriptor(), value);
}
inline bool SubQuerySupport_Parse(
    const ::std::string& name, SubQuerySupport* value) {
  return ::google::protobuf::internal::ParseNamedEnum<SubQuerySupport>(
    SubQuerySupport_descriptor(), name, value);
}
enum UnionSupport {
  U_UNKNOWN = 0,
  U_UNION = 1,
  U_UNION_ALL = 2
};
bool UnionSupport_IsValid(int value);
const UnionSupport UnionSupport_MIN = U_UNKNOWN;
const UnionSupport UnionSupport_MAX = U_UNION_ALL;
const int UnionSupport_ARRAYSIZE = UnionSupport_MAX + 1;

const ::google::protobuf::EnumDescriptor* UnionSupport_descriptor();
inline const ::std::string& UnionSupport_Name(UnionSupport value) {
  return ::google::protobuf::internal::NameOfEnum(
    UnionSupport_descriptor(), value);
}
inline bool UnionSupport_Parse(
    const ::std::string& name, UnionSupport* value) {
  return ::google::protobuf::internal::ParseNamedEnum<UnionSupport>(
    UnionSupport_descriptor(), name, value);
}
// ===================================================================

class Property : public ::google::protobuf::Message {
 public:
  Property();
  virtual ~Property();

  Property(const Property& from);

  inline Property& operator=(const Property& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const Property& default_instance();

  void Swap(Property* other);

  // implements Message ----------------------------------------------

  Property* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Property& from);
  void MergeFrom(const Property& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required string key = 1;
  inline bool has_key() const;
  inline void clear_key();
  static const int kKeyFieldNumber = 1;
  inline const ::std::string& key() const;
  inline void set_key(const ::std::string& value);
  inline void set_key(const char* value);
  inline void set_key(const char* value, size_t size);
  inline ::std::string* mutable_key();
  inline ::std::string* release_key();
  inline void set_allocated_key(::std::string* key);

  // required string value = 2;
  inline bool has_value() const;
  inline void clear_value();
  static const int kValueFieldNumber = 2;
  inline const ::std::string& value() const;
  inline void set_value(const ::std::string& value);
  inline void set_value(const char* value);
  inline void set_value(const char* value, size_t size);
  inline ::std::string* mutable_value();
  inline ::std::string* release_value();
  inline void set_allocated_value(::std::string* value);

  // @@protoc_insertion_point(class_scope:exec.user.Property)
 private:
  inline void set_has_key();
  inline void clear_has_key();
  inline void set_has_value();
  inline void clear_has_value();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* key_;
  ::std::string* value_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static Property* default_instance_;
};
// -------------------------------------------------------------------

class UserProperties : public ::google::protobuf::Message {
 public:
  UserProperties();
  virtual ~UserProperties();

  UserProperties(const UserProperties& from);

  inline UserProperties& operator=(const UserProperties& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const UserProperties& default_instance();

  void Swap(UserProperties* other);

  // implements Message ----------------------------------------------

  UserProperties* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const UserProperties& from);
  void MergeFrom(const UserProperties& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated .exec.user.Property properties = 1;
  inline int properties_size() const;
  inline void clear_properties();
  static const int kPropertiesFieldNumber = 1;
  inline const ::exec::user::Property& properties(int index) const;
  inline ::exec::user::Property* mutable_properties(int index);
  inline ::exec::user::Property* add_properties();
  inline const ::google::protobuf::RepeatedPtrField< ::exec::user::Property >&
      properties() const;
  inline ::google::protobuf::RepeatedPtrField< ::exec::user::Property >*
      mutable_properties();

  // @@protoc_insertion_point(class_scope:exec.user.UserProperties)
 private:

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::RepeatedPtrField< ::exec::user::Property > properties_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static UserProperties* default_instance_;
};
// -------------------------------------------------------------------

class RpcEndpointInfos : public ::google::protobuf::Message {
 public:
  RpcEndpointInfos();
  virtual ~RpcEndpointInfos();

  RpcEndpointInfos(const RpcEndpointInfos& from);

  inline RpcEndpointInfos& operator=(const RpcEndpointInfos& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const RpcEndpointInfos& default_instance();

  void Swap(RpcEndpointInfos* other);

  // implements Message ----------------------------------------------

  RpcEndpointInfos* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const RpcEndpointInfos& from);
  void MergeFrom(const RpcEndpointInfos& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional string name = 1;
  inline bool has_name() const;
  inline void clear_name();
  static const int kNameFieldNumber = 1;
  inline const ::std::string& name() const;
  inline void set_name(const ::std::string& value);
  inline void set_name(const char* value);
  inline void set_name(const char* value, size_t size);
  inline ::std::string* mutable_name();
  inline ::std::string* release_name();
  inline void set_allocated_name(::std::string* name);

  // optional string version = 2;
  inline bool has_version() const;
  inline void clear_version();
  static const int kVersionFieldNumber = 2;
  inline const ::std::string& version() const;
  inline void set_version(const ::std::string& value);
  inline void set_version(const char* value);
  inline void set_version(const char* value, size_t size);
  inline ::std::string* mutable_version();
  inline ::std::string* release_version();
  inline void set_allocated_version(::std::string* version);

  // optional uint32 majorVersion = 3;
  inline bool has_majorversion() const;
  inline void clear_majorversion();
  static const int kMajorVersionFieldNumber = 3;
  inline ::google::protobuf::uint32 majorversion() const;
  inline void set_majorversion(::google::protobuf::uint32 value);

  // optional uint32 minorVersion = 4;
  inline bool has_minorversion() const;
  inline void clear_minorversion();
  static const int kMinorVersionFieldNumber = 4;
  inline ::google::protobuf::uint32 minorversion() const;
  inline void set_minorversion(::google::protobuf::uint32 value);

  // optional uint32 patchVersion = 5;
  inline bool has_patchversion() const;
  inline void clear_patchversion();
  static const int kPatchVersionFieldNumber = 5;
  inline ::google::protobuf::uint32 patchversion() const;
  inline void set_patchversion(::google::protobuf::uint32 value);

  // optional string application = 6;
  inline bool has_application() const;
  inline void clear_application();
  static const int kApplicationFieldNumber = 6;
  inline const ::std::string& application() const;
  inline void set_application(const ::std::string& value);
  inline void set_application(const char* value);
  inline void set_application(const char* value, size_t size);
  inline ::std::string* mutable_application();
  inline ::std::string* release_application();
  inline void set_allocated_application(::std::string* application);

  // optional uint32 buildNumber = 7;
  inline bool has_buildnumber() const;
  inline void clear_buildnumber();
  static const int kBuildNumberFieldNumber = 7;
  inline ::google::protobuf::uint32 buildnumber() const;
  inline void set_buildnumber(::google::protobuf::uint32 value);

  // optional string versionQualifier = 8;
  inline bool has_versionqualifier() const;
  inline void clear_versionqualifier();
  static const int kVersionQualifierFieldNumber = 8;
  inline const ::std::string& versionqualifier() const;
  inline void set_versionqualifier(const ::std::string& value);
  inline void set_versionqualifier(const char* value);
  inline void set_versionqualifier(const char* value, size_t size);
  inline ::std::string* mutable_versionqualifier();
  inline ::std::string* release_versionqualifier();
  inline void set_allocated_versionqualifier(::std::string* versionqualifier);

  // @@protoc_insertion_point(class_scope:exec.user.RpcEndpointInfos)
 private:
  inline void set_has_name();
  inline void clear_has_name();
  inline void set_has_version();
  inline void clear_has_version();
  inline void set_has_majorversion();
  inline void clear_has_majorversion();
  inline void set_has_minorversion();
  inline void clear_has_minorversion();
  inline void set_has_patchversion();
  inline void clear_has_patchversion();
  inline void set_has_application();
  inline void clear_has_application();
  inline void set_has_buildnumber();
  inline void clear_has_buildnumber();
  inline void set_has_versionqualifier();
  inline void clear_has_versionqualifier();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* name_;
  ::std::string* version_;
  ::google::protobuf::uint32 majorversion_;
  ::google::protobuf::uint32 minorversion_;
  ::std::string* application_;
  ::google::protobuf::uint32 patchversion_;
  ::google::protobuf::uint32 buildnumber_;
  ::std::string* versionqualifier_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(8 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static RpcEndpointInfos* default_instance_;
};
// -------------------------------------------------------------------

class UserToBitHandshake : public ::google::protobuf::Message {
 public:
  UserToBitHandshake();
  virtual ~UserToBitHandshake();

  UserToBitHandshake(const UserToBitHandshake& from);

  inline UserToBitHandshake& operator=(const UserToBitHandshake& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const UserToBitHandshake& default_instance();

  void Swap(UserToBitHandshake* other);

  // implements Message ----------------------------------------------

  UserToBitHandshake* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const UserToBitHandshake& from);
  void MergeFrom(const UserToBitHandshake& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .exec.shared.RpcChannel channel = 1 [default = USER];
  inline bool has_channel() const;
  inline void clear_channel();
  static const int kChannelFieldNumber = 1;
  inline ::exec::shared::RpcChannel channel() const;
  inline void set_channel(::exec::shared::RpcChannel value);

  // optional bool support_listening = 2;
  inline bool has_support_listening() const;
  inline void clear_support_listening();
  static const int kSupportListeningFieldNumber = 2;
  inline bool support_listening() const;
  inline void set_support_listening(bool value);

  // optional int32 rpc_version = 3;
  inline bool has_rpc_version() const;
  inline void clear_rpc_version();
  static const int kRpcVersionFieldNumber = 3;
  inline ::google::protobuf::int32 rpc_version() const;
  inline void set_rpc_version(::google::protobuf::int32 value);

  // optional .exec.shared.UserCredentials credentials = 4;
  inline bool has_credentials() const;
  inline void clear_credentials();
  static const int kCredentialsFieldNumber = 4;
  inline const ::exec::shared::UserCredentials& credentials() const;
  inline ::exec::shared::UserCredentials* mutable_credentials();
  inline ::exec::shared::UserCredentials* release_credentials();
  inline void set_allocated_credentials(::exec::shared::UserCredentials* credentials);

  // optional .exec.user.UserProperties properties = 5;
  inline bool has_properties() const;
  inline void clear_properties();
  static const int kPropertiesFieldNumber = 5;
  inline const ::exec::user::UserProperties& properties() const;
  inline ::exec::user::UserProperties* mutable_properties();
  inline ::exec::user::UserProperties* release_properties();
  inline void set_allocated_properties(::exec::user::UserProperties* properties);

  // optional bool support_complex_types = 6 [default = false];
  inline bool has_support_complex_types() const;
  inline void clear_support_complex_types();
  static const int kSupportComplexTypesFieldNumber = 6;
  inline bool support_complex_types() const;
  inline void set_support_complex_types(bool value);

  // optional bool support_timeout = 7 [default = false];
  inline bool has_support_timeout() const;
  inline void clear_support_timeout();
  static const int kSupportTimeoutFieldNumber = 7;
  inline bool support_timeout() const;
  inline void set_support_timeout(bool value);

  // optional .exec.user.RpcEndpointInfos client_infos = 8;
  inline bool has_client_infos() const;
  inline void clear_client_infos();
  static const int kClientInfosFieldNumber = 8;
  inline const ::exec::user::RpcEndpointInfos& client_infos() const;
  inline ::exec::user::RpcEndpointInfos* mutable_client_infos();
  inline ::exec::user::RpcEndpointInfos* release_client_infos();
  inline void set_allocated_client_infos(::exec::user::RpcEndpointInfos* client_infos);

  // optional .exec.user.SaslSupport sasl_support = 9;
  inline bool has_sasl_support() const;
  inline void clear_sasl_support();
  static const int kSaslSupportFieldNumber = 9;
  inline ::exec::user::SaslSupport sasl_support() const;
  inline void set_sasl_support(::exec::user::SaslSupport value);

  // @@protoc_insertion_point(class_scope:exec.user.UserToBitHandshake)
 private:
  inline void set_has_channel();
  inline void clear_has_channel();
  inline void set_has_support_listening();
  inline void clear_has_support_listening();
  inline void set_has_rpc_version();
  inline void clear_has_rpc_version();
  inline void set_has_credentials();
  inline void clear_has_credentials();
  inline void set_has_properties();
  inline void clear_has_properties();
  inline void set_has_support_complex_types();
  inline void clear_has_support_complex_types();
  inline void set_has_support_timeout();
  inline void clear_has_support_timeout();
  inline void set_has_client_infos();
  inline void clear_has_client_infos();
  inline void set_has_sasl_support();
  inline void clear_has_sasl_support();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  int channel_;
  ::google::protobuf::int32 rpc_version_;
  ::exec::shared::UserCredentials* credentials_;
  ::exec::user::UserProperties* properties_;
  bool support_listening_;
  bool support_complex_types_;
  bool support_timeout_;
  int sasl_support_;
  ::exec::user::RpcEndpointInfos* client_infos_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(9 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static UserToBitHandshake* default_instance_;
};
// -------------------------------------------------------------------

class RequestResults : public ::google::protobuf::Message {
 public:
  RequestResults();
  virtual ~RequestResults();

  RequestResults(const RequestResults& from);

  inline RequestResults& operator=(const RequestResults& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const RequestResults& default_instance();

  void Swap(RequestResults* other);

  // implements Message ----------------------------------------------

  RequestResults* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const RequestResults& from);
  void MergeFrom(const RequestResults& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .exec.shared.QueryId query_id = 1;
  inline bool has_query_id() const;
  inline void clear_query_id();
  static const int kQueryIdFieldNumber = 1;
  inline const ::exec::shared::QueryId& query_id() const;
  inline ::exec::shared::QueryId* mutable_query_id();
  inline ::exec::shared::QueryId* release_query_id();
  inline void set_allocated_query_id(::exec::shared::QueryId* query_id);

  // optional int32 maximum_responses = 2;
  inline bool has_maximum_responses() const;
  inline void clear_maximum_responses();
  static const int kMaximumResponsesFieldNumber = 2;
  inline ::google::protobuf::int32 maximum_responses() const;
  inline void set_maximum_responses(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:exec.user.RequestResults)
 private:
  inline void set_has_query_id();
  inline void clear_has_query_id();
  inline void set_has_maximum_responses();
  inline void clear_has_maximum_responses();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::exec::shared::QueryId* query_id_;
  ::google::protobuf::int32 maximum_responses_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static RequestResults* default_instance_;
};
// -------------------------------------------------------------------

class GetQueryPlanFragments : public ::google::protobuf::Message {
 public:
  GetQueryPlanFragments();
  virtual ~GetQueryPlanFragments();

  GetQueryPlanFragments(const GetQueryPlanFragments& from);

  inline GetQueryPlanFragments& operator=(const GetQueryPlanFragments& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const GetQueryPlanFragments& default_instance();

  void Swap(GetQueryPlanFragments* other);

  // implements Message ----------------------------------------------

  GetQueryPlanFragments* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const GetQueryPlanFragments& from);
  void MergeFrom(const GetQueryPlanFragments& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required string query = 1;
  inline bool has_query() const;
  inline void clear_query();
  static const int kQueryFieldNumber = 1;
  inline const ::std::string& query() const;
  inline void set_query(const ::std::string& value);
  inline void set_query(const char* value);
  inline void set_query(const char* value, size_t size);
  inline ::std::string* mutable_query();
  inline ::std::string* release_query();
  inline void set_allocated_query(::std::string* query);

  // optional .exec.shared.QueryType type = 2;
  inline bool has_type() const;
  inline void clear_type();
  static const int kTypeFieldNumber = 2;
  inline ::exec::shared::QueryType type() const;
  inline void set_type(::exec::shared::QueryType value);

  // optional bool split_plan = 3 [default = false];
  inline bool has_split_plan() const;
  inline void clear_split_plan();
  static const int kSplitPlanFieldNumber = 3;
  inline bool split_plan() const;
  inline void set_split_plan(bool value);

  // @@protoc_insertion_point(class_scope:exec.user.GetQueryPlanFragments)
 private:
  inline void set_has_query();
  inline void clear_has_query();
  inline void set_has_type();
  inline void clear_has_type();
  inline void set_has_split_plan();
  inline void clear_has_split_plan();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* query_;
  int type_;
  bool split_plan_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static GetQueryPlanFragments* default_instance_;
};
// -------------------------------------------------------------------

class QueryPlanFragments : public ::google::protobuf::Message {
 public:
  QueryPlanFragments();
  virtual ~QueryPlanFragments();

  QueryPlanFragments(const QueryPlanFragments& from);

  inline QueryPlanFragments& operator=(const QueryPlanFragments& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const QueryPlanFragments& default_instance();

  void Swap(QueryPlanFragments* other);

  // implements Message ----------------------------------------------

  QueryPlanFragments* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const QueryPlanFragments& from);
  void MergeFrom(const QueryPlanFragments& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required .exec.shared.QueryResult.QueryState status = 1;
  inline bool has_status() const;
  inline void clear_status();
  static const int kStatusFieldNumber = 1;
  inline ::exec::shared::QueryResult_QueryState status() const;
  inline void set_status(::exec::shared::QueryResult_QueryState value);

  // optional .exec.shared.QueryId query_id = 2;
  inline bool has_query_id() const;
  inline void clear_query_id();
  static const int kQueryIdFieldNumber = 2;
  inline const ::exec::shared::QueryId& query_id() const;
  inline ::exec::shared::QueryId* mutable_query_id();
  inline ::exec::shared::QueryId* release_query_id();
  inline void set_allocated_query_id(::exec::shared::QueryId* query_id);

  // repeated .exec.bit.control.PlanFragment fragments = 3;
  inline int fragments_size() const;
  inline void clear_fragments();
  static const int kFragmentsFieldNumber = 3;
  inline const ::exec::bit::control::PlanFragment& fragments(int index) const;
  inline ::exec::bit::control::PlanFragment* mutable_fragments(int index);
  inline ::exec::bit::control::PlanFragment* add_fragments();
  inline const ::google::protobuf::RepeatedPtrField< ::exec::bit::control::PlanFragment >&
      fragments() const;
  inline ::google::protobuf::RepeatedPtrField< ::exec::bit::control::PlanFragment >*
      mutable_fragments();

  // optional .exec.shared.DrillPBError error = 4;
  inline bool has_error() const;
  inline void clear_error();
  static const int kErrorFieldNumber = 4;
  inline const ::exec::shared::DrillPBError& error() const;
  inline ::exec::shared::DrillPBError* mutable_error();
  inline ::exec::shared::DrillPBError* release_error();
  inline void set_allocated_error(::exec::shared::DrillPBError* error);

  // @@protoc_insertion_point(class_scope:exec.user.QueryPlanFragments)
 private:
  inline void set_has_status();
  inline void clear_has_status();
  inline void set_has_query_id();
  inline void clear_has_query_id();
  inline void set_has_error();
  inline void clear_has_error();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::exec::shared::QueryId* query_id_;
  ::google::protobuf::RepeatedPtrField< ::exec::bit::control::PlanFragment > fragments_;
  ::exec::shared::DrillPBError* error_;
  int status_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static QueryPlanFragments* default_instance_;
};
// -------------------------------------------------------------------

class BitToUserHandshake : public ::google::protobuf::Message {
 public:
  BitToUserHandshake();
  virtual ~BitToUserHandshake();

  BitToUserHandshake(const BitToUserHandshake& from);

  inline BitToUserHandshake& operator=(const BitToUserHandshake& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const BitToUserHandshake& default_instance();

  void Swap(BitToUserHandshake* other);

  // implements Message ----------------------------------------------

  BitToUserHandshake* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const BitToUserHandshake& from);
  void MergeFrom(const BitToUserHandshake& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional int32 rpc_version = 2;
  inline bool has_rpc_version() const;
  inline void clear_rpc_version();
  static const int kRpcVersionFieldNumber = 2;
  inline ::google::protobuf::int32 rpc_version() const;
  inline void set_rpc_version(::google::protobuf::int32 value);

  // optional .exec.user.HandshakeStatus status = 3;
  inline bool has_status() const;
  inline void clear_status();
  static const int kStatusFieldNumber = 3;
  inline ::exec::user::HandshakeStatus status() const;
  inline void set_status(::exec::user::HandshakeStatus value);

  // optional string errorId = 4;
  inline bool has_errorid() const;
  inline void clear_errorid();
  static const int kErrorIdFieldNumber = 4;
  inline const ::std::string& errorid() const;
  inline void set_errorid(const ::std::string& value);
  inline void set_errorid(const char* value);
  inline void set_errorid(const char* value, size_t size);
  inline ::std::string* mutable_errorid();
  inline ::std::string* release_errorid();
  inline void set_allocated_errorid(::std::string* errorid);

  // optional string errorMessage = 5;
  inline bool has_errormessage() const;
  inline void clear_errormessage();
  static const int kErrorMessageFieldNumber = 5;
  inline const ::std::string& errormessage() const;
  inline void set_errormessage(const ::std::string& value);
  inline void set_errormessage(const char* value);
  inline void set_errormessage(const char* value, size_t size);
  inline ::std::string* mutable_errormessage();
  inline ::std::string* release_errormessage();
  inline void set_allocated_errormessage(::std::string* errormessage);

  // optional .exec.user.RpcEndpointInfos server_infos = 6;
  inline bool has_server_infos() const;
  inline void clear_server_infos();
  static const int kServerInfosFieldNumber = 6;
  inline const ::exec::user::RpcEndpointInfos& server_infos() const;
  inline ::exec::user::RpcEndpointInfos* mutable_server_infos();
  inline ::exec::user::RpcEndpointInfos* release_server_infos();
  inline void set_allocated_server_infos(::exec::user::RpcEndpointInfos* server_infos);

  // repeated string authenticationMechanisms = 7;
  inline int authenticationmechanisms_size() const;
  inline void clear_authenticationmechanisms();
  static const int kAuthenticationMechanismsFieldNumber = 7;
  inline const ::std::string& authenticationmechanisms(int index) const;
  inline ::std::string* mutable_authenticationmechanisms(int index);
  inline void set_authenticationmechanisms(int index, const ::std::string& value);
  inline void set_authenticationmechanisms(int index, const char* value);
  inline void set_authenticationmechanisms(int index, const char* value, size_t size);
  inline ::std::string* add_authenticationmechanisms();
  inline void add_authenticationmechanisms(const ::std::string& value);
  inline void add_authenticationmechanisms(const char* value);
  inline void add_authenticationmechanisms(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& authenticationmechanisms() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_authenticationmechanisms();

  // repeated .exec.user.RpcType supported_methods = 8;
  inline int supported_methods_size() const;
  inline void clear_supported_methods();
  static const int kSupportedMethodsFieldNumber = 8;
  inline ::exec::user::RpcType supported_methods(int index) const;
  inline void set_supported_methods(int index, ::exec::user::RpcType value);
  inline void add_supported_methods(::exec::user::RpcType value);
  inline const ::google::protobuf::RepeatedField<int>& supported_methods() const;
  inline ::google::protobuf::RepeatedField<int>* mutable_supported_methods();

  // optional bool encrypted = 9;
  inline bool has_encrypted() const;
  inline void clear_encrypted();
  static const int kEncryptedFieldNumber = 9;
  inline bool encrypted() const;
  inline void set_encrypted(bool value);

  // optional int32 maxWrappedSize = 10;
  inline bool has_maxwrappedsize() const;
  inline void clear_maxwrappedsize();
  static const int kMaxWrappedSizeFieldNumber = 10;
  inline ::google::protobuf::int32 maxwrappedsize() const;
  inline void set_maxwrappedsize(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:exec.user.BitToUserHandshake)
 private:
  inline void set_has_rpc_version();
  inline void clear_has_rpc_version();
  inline void set_has_status();
  inline void clear_has_status();
  inline void set_has_errorid();
  inline void clear_has_errorid();
  inline void set_has_errormessage();
  inline void clear_has_errormessage();
  inline void set_has_server_infos();
  inline void clear_has_server_infos();
  inline void set_has_encrypted();
  inline void clear_has_encrypted();
  inline void set_has_maxwrappedsize();
  inline void clear_has_maxwrappedsize();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::int32 rpc_version_;
  int status_;
  ::std::string* errorid_;
  ::std::string* errormessage_;
  ::exec::user::RpcEndpointInfos* server_infos_;
  ::google::protobuf::RepeatedPtrField< ::std::string> authenticationmechanisms_;
  ::google::protobuf::RepeatedField<int> supported_methods_;
  bool encrypted_;
  ::google::protobuf::int32 maxwrappedsize_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(9 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static BitToUserHandshake* default_instance_;
};
// -------------------------------------------------------------------

class LikeFilter : public ::google::protobuf::Message {
 public:
  LikeFilter();
  virtual ~LikeFilter();

  LikeFilter(const LikeFilter& from);

  inline LikeFilter& operator=(const LikeFilter& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const LikeFilter& default_instance();

  void Swap(LikeFilter* other);

  // implements Message ----------------------------------------------

  LikeFilter* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const LikeFilter& from);
  void MergeFrom(const LikeFilter& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional string pattern = 1;
  inline bool has_pattern() const;
  inline void clear_pattern();
  static const int kPatternFieldNumber = 1;
  inline const ::std::string& pattern() const;
  inline void set_pattern(const ::std::string& value);
  inline void set_pattern(const char* value);
  inline void set_pattern(const char* value, size_t size);
  inline ::std::string* mutable_pattern();
  inline ::std::string* release_pattern();
  inline void set_allocated_pattern(::std::string* pattern);

  // optional string escape = 2;
  inline bool has_escape() const;
  inline void clear_escape();
  static const int kEscapeFieldNumber = 2;
  inline const ::std::string& escape() const;
  inline void set_escape(const ::std::string& value);
  inline void set_escape(const char* value);
  inline void set_escape(const char* value, size_t size);
  inline ::std::string* mutable_escape();
  inline ::std::string* release_escape();
  inline void set_allocated_escape(::std::string* escape);

  // @@protoc_insertion_point(class_scope:exec.user.LikeFilter)
 private:
  inline void set_has_pattern();
  inline void clear_has_pattern();
  inline void set_has_escape();
  inline void clear_has_escape();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* pattern_;
  ::std::string* escape_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static LikeFilter* default_instance_;
};
// -------------------------------------------------------------------

class GetCatalogsReq : public ::google::protobuf::Message {
 public:
  GetCatalogsReq();
  virtual ~GetCatalogsReq();

  GetCatalogsReq(const GetCatalogsReq& from);

  inline GetCatalogsReq& operator=(const GetCatalogsReq& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const GetCatalogsReq& default_instance();

  void Swap(GetCatalogsReq* other);

  // implements Message ----------------------------------------------

  GetCatalogsReq* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const GetCatalogsReq& from);
  void MergeFrom(const GetCatalogsReq& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .exec.user.LikeFilter catalog_name_filter = 1;
  inline bool has_catalog_name_filter() const;
  inline void clear_catalog_name_filter();
  static const int kCatalogNameFilterFieldNumber = 1;
  inline const ::exec::user::LikeFilter& catalog_name_filter() const;
  inline ::exec::user::LikeFilter* mutable_catalog_name_filter();
  inline ::exec::user::LikeFilter* release_catalog_name_filter();
  inline void set_allocated_catalog_name_filter(::exec::user::LikeFilter* catalog_name_filter);

  // @@protoc_insertion_point(class_scope:exec.user.GetCatalogsReq)
 private:
  inline void set_has_catalog_name_filter();
  inline void clear_has_catalog_name_filter();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::exec::user::LikeFilter* catalog_name_filter_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static GetCatalogsReq* default_instance_;
};
// -------------------------------------------------------------------

class CatalogMetadata : public ::google::protobuf::Message {
 public:
  CatalogMetadata();
  virtual ~CatalogMetadata();

  CatalogMetadata(const CatalogMetadata& from);

  inline CatalogMetadata& operator=(const CatalogMetadata& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const CatalogMetadata& default_instance();

  void Swap(CatalogMetadata* other);

  // implements Message ----------------------------------------------

  CatalogMetadata* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CatalogMetadata& from);
  void MergeFrom(const CatalogMetadata& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional string catalog_name = 1;
  inline bool has_catalog_name() const;
  inline void clear_catalog_name();
  static const int kCatalogNameFieldNumber = 1;
  inline const ::std::string& catalog_name() const;
  inline void set_catalog_name(const ::std::string& value);
  inline void set_catalog_name(const char* value);
  inline void set_catalog_name(const char* value, size_t size);
  inline ::std::string* mutable_catalog_name();
  inline ::std::string* release_catalog_name();
  inline void set_allocated_catalog_name(::std::string* catalog_name);

  // optional string description = 2;
  inline bool has_description() const;
  inline void clear_description();
  static const int kDescriptionFieldNumber = 2;
  inline const ::std::string& description() const;
  inline void set_description(const ::std::string& value);
  inline void set_description(const char* value);
  inline void set_description(const char* value, size_t size);
  inline ::std::string* mutable_description();
  inline ::std::string* release_description();
  inline void set_allocated_description(::std::string* description);

  // optional string connect = 3;
  inline bool has_connect() const;
  inline void clear_connect();
  static const int kConnectFieldNumber = 3;
  inline const ::std::string& connect() const;
  inline void set_connect(const ::std::string& value);
  inline void set_connect(const char* value);
  inline void set_connect(const char* value, size_t size);
  inline ::std::string* mutable_connect();
  inline ::std::string* release_connect();
  inline void set_allocated_connect(::std::string* connect);

  // @@protoc_insertion_point(class_scope:exec.user.CatalogMetadata)
 private:
  inline void set_has_catalog_name();
  inline void clear_has_catalog_name();
  inline void set_has_description();
  inline void clear_has_description();
  inline void set_has_connect();
  inline void clear_has_connect();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* catalog_name_;
  ::std::string* description_;
  ::std::string* connect_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static CatalogMetadata* default_instance_;
};
// -------------------------------------------------------------------

class GetCatalogsResp : public ::google::protobuf::Message {
 public:
  GetCatalogsResp();
  virtual ~GetCatalogsResp();

  GetCatalogsResp(const GetCatalogsResp& from);

  inline GetCatalogsResp& operator=(const GetCatalogsResp& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const GetCatalogsResp& default_instance();

  void Swap(GetCatalogsResp* other);

  // implements Message ----------------------------------------------

  GetCatalogsResp* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const GetCatalogsResp& from);
  void MergeFrom(const GetCatalogsResp& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .exec.user.RequestStatus status = 1;
  inline bool has_status() const;
  inline void clear_status();
  static const int kStatusFieldNumber = 1;
  inline ::exec::user::RequestStatus status() const;
  inline void set_status(::exec::user::RequestStatus value);

  // repeated .exec.user.CatalogMetadata catalogs = 2;
  inline int catalogs_size() const;
  inline void clear_catalogs();
  static const int kCatalogsFieldNumber = 2;
  inline const ::exec::user::CatalogMetadata& catalogs(int index) const;
  inline ::exec::user::CatalogMetadata* mutable_catalogs(int index);
  inline ::exec::user::CatalogMetadata* add_catalogs();
  inline const ::google::protobuf::RepeatedPtrField< ::exec::user::CatalogMetadata >&
      catalogs() const;
  inline ::google::protobuf::RepeatedPtrField< ::exec::user::CatalogMetadata >*
      mutable_catalogs();

  // optional .exec.shared.DrillPBError error = 3;
  inline bool has_error() const;
  inline void clear_error();
  static const int kErrorFieldNumber = 3;
  inline const ::exec::shared::DrillPBError& error() const;
  inline ::exec::shared::DrillPBError* mutable_error();
  inline ::exec::shared::DrillPBError* release_error();
  inline void set_allocated_error(::exec::shared::DrillPBError* error);

  // @@protoc_insertion_point(class_scope:exec.user.GetCatalogsResp)
 private:
  inline void set_has_status();
  inline void clear_has_status();
  inline void set_has_error();
  inline void clear_has_error();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::RepeatedPtrField< ::exec::user::CatalogMetadata > catalogs_;
  ::exec::shared::DrillPBError* error_;
  int status_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static GetCatalogsResp* default_instance_;
};
// -------------------------------------------------------------------

class GetSchemasReq : public ::google::protobuf::Message {
 public:
  GetSchemasReq();
  virtual ~GetSchemasReq();

  GetSchemasReq(const GetSchemasReq& from);

  inline GetSchemasReq& operator=(const GetSchemasReq& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const GetSchemasReq& default_instance();

  void Swap(GetSchemasReq* other);

  // implements Message ----------------------------------------------

  GetSchemasReq* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const GetSchemasReq& from);
  void MergeFrom(const GetSchemasReq& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .exec.user.LikeFilter catalog_name_filter = 1;
  inline bool has_catalog_name_filter() const;
  inline void clear_catalog_name_filter();
  static const int kCatalogNameFilterFieldNumber = 1;
  inline const ::exec::user::LikeFilter& catalog_name_filter() const;
  inline ::exec::user::LikeFilter* mutable_catalog_name_filter();
  inline ::exec::user::LikeFilter* release_catalog_name_filter();
  inline void set_allocated_catalog_name_filter(::exec::user::LikeFilter* catalog_name_filter);

  // optional .exec.user.LikeFilter schema_name_filter = 2;
  inline bool has_schema_name_filter() const;
  inline void clear_schema_name_filter();
  static const int kSchemaNameFilterFieldNumber = 2;
  inline const ::exec::user::LikeFilter& schema_name_filter() const;
  inline ::exec::user::LikeFilter* mutable_schema_name_filter();
  inline ::exec::user::LikeFilter* release_schema_name_filter();
  inline void set_allocated_schema_name_filter(::exec::user::LikeFilter* schema_name_filter);

  // @@protoc_insertion_point(class_scope:exec.user.GetSchemasReq)
 private:
  inline void set_has_catalog_name_filter();
  inline void clear_has_catalog_name_filter();
  inline void set_has_schema_name_filter();
  inline void clear_has_schema_name_filter();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::exec::user::LikeFilter* catalog_name_filter_;
  ::exec::user::LikeFilter* schema_name_filter_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static GetSchemasReq* default_instance_;
};
// -------------------------------------------------------------------

class SchemaMetadata : public ::google::protobuf::Message {
 public:
  SchemaMetadata();
  virtual ~SchemaMetadata();

  SchemaMetadata(const SchemaMetadata& from);

  inline SchemaMetadata& operator=(const SchemaMetadata& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const SchemaMetadata& default_instance();

  void Swap(SchemaMetadata* other);

  // implements Message ----------------------------------------------

  SchemaMetadata* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SchemaMetadata& from);
  void MergeFrom(const SchemaMetadata& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional string catalog_name = 1;
  inline bool has_catalog_name() const;
  inline void clear_catalog_name();
  static const int kCatalogNameFieldNumber = 1;
  inline const ::std::string& catalog_name() const;
  inline void set_catalog_name(const ::std::string& value);
  inline void set_catalog_name(const char* value);
  inline void set_catalog_name(const char* value, size_t size);
  inline ::std::string* mutable_catalog_name();
  inline ::std::string* release_catalog_name();
  inline void set_allocated_catalog_name(::std::string* catalog_name);

  // optional string schema_name = 2;
  inline bool has_schema_name() const;
  inline void clear_schema_name();
  static const int kSchemaNameFieldNumber = 2;
  inline const ::std::string& schema_name() const;
  inline void set_schema_name(const ::std::string& value);
  inline void set_schema_name(const char* value);
  inline void set_schema_name(const char* value, size_t size);
  inline ::std::string* mutable_schema_name();
  inline ::std::string* release_schema_name();
  inline void set_allocated_schema_name(::std::string* schema_name);

  // optional string owner = 3;
  inline bool has_owner() const;
  inline void clear_owner();
  static const int kOwnerFieldNumber = 3;
  inline const ::std::string& owner() const;
  inline void set_owner(const ::std::string& value);
  inline void set_owner(const char* value);
  inline void set_owner(const char* value, size_t size);
  inline ::std::string* mutable_owner();
  inline ::std::string* release_owner();
  inline void set_allocated_owner(::std::string* owner);

  // optional string type = 4;
  inline bool has_type() const;
  inline void clear_type();
  static const int kTypeFieldNumber = 4;
  inline const ::std::string& type() const;
  inline void set_type(const ::std::string& value);
  inline void set_type(const char* value);
  inline void set_type(const char* value, size_t size);
  inline ::std::string* mutable_type();
  inline ::std::string* release_type();
  inline void set_allocated_type(::std::string* type);

  // optional string mutable = 5;
  inline bool has_mutable_() const;
  inline void clear_mutable_();
  static const int kMutableFieldNumber = 5;
  inline const ::std::string& mutable_() const;
  inline void set_mutable_(const ::std::string& value);
  inline void set_mutable_(const char* value);
  inline void set_mutable_(const char* value, size_t size);
  inline ::std::string* mutable_mutable_();
  inline ::std::string* release_mutable_();
  inline void set_allocated_mutable_(::std::string* mutable_);

  // @@protoc_insertion_point(class_scope:exec.user.SchemaMetadata)
 private:
  inline void set_has_catalog_name();
  inline void clear_has_catalog_name();
  inline void set_has_schema_name();
  inline void clear_has_schema_name();
  inline void set_has_owner();
  inline void clear_has_owner();
  inline void set_has_type();
  inline void clear_has_type();
  inline void set_has_mutable_();
  inline void clear_has_mutable_();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* catalog_name_;
  ::std::string* schema_name_;
  ::std::string* owner_;
  ::std::string* type_;
  ::std::string* mutable__;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static SchemaMetadata* default_instance_;
};
// -------------------------------------------------------------------

class GetSchemasResp : public ::google::protobuf::Message {
 public:
  GetSchemasResp();
  virtual ~GetSchemasResp();

  GetSchemasResp(const GetSchemasResp& from);

  inline GetSchemasResp& operator=(const GetSchemasResp& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const GetSchemasResp& default_instance();

  void Swap(GetSchemasResp* other);

  // implements Message ----------------------------------------------

  GetSchemasResp* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const GetSchemasResp& from);
  void MergeFrom(const GetSchemasResp& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .exec.user.RequestStatus status = 1;
  inline bool has_status() const;
  inline void clear_status();
  static const int kStatusFieldNumber = 1;
  inline ::exec::user::RequestStatus status() const;
  inline void set_status(::exec::user::RequestStatus value);

  // repeated .exec.user.SchemaMetadata schemas = 2;
  inline int schemas_size() const;
  inline void clear_schemas();
  static const int kSchemasFieldNumber = 2;
  inline const ::exec::user::SchemaMetadata& schemas(int index) const;
  inline ::exec::user::SchemaMetadata* mutable_schemas(int index);
  inline ::exec::user::SchemaMetadata* add_schemas();
  inline const ::google::protobuf::RepeatedPtrField< ::exec::user::SchemaMetadata >&
      schemas() const;
  inline ::google::protobuf::RepeatedPtrField< ::exec::user::SchemaMetadata >*
      mutable_schemas();

  // optional .exec.shared.DrillPBError error = 3;
  inline bool has_error() const;
  inline void clear_error();
  static const int kErrorFieldNumber = 3;
  inline const ::exec::shared::DrillPBError& error() const;
  inline ::exec::shared::DrillPBError* mutable_error();
  inline ::exec::shared::DrillPBError* release_error();
  inline void set_allocated_error(::exec::shared::DrillPBError* error);

  // @@protoc_insertion_point(class_scope:exec.user.GetSchemasResp)
 private:
  inline void set_has_status();
  inline void clear_has_status();
  inline void set_has_error();
  inline void clear_has_error();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::RepeatedPtrField< ::exec::user::SchemaMetadata > schemas_;
  ::exec::shared::DrillPBError* error_;
  int status_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static GetSchemasResp* default_instance_;
};
// -------------------------------------------------------------------

class GetTablesReq : public ::google::protobuf::Message {
 public:
  GetTablesReq();
  virtual ~GetTablesReq();

  GetTablesReq(const GetTablesReq& from);

  inline GetTablesReq& operator=(const GetTablesReq& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const GetTablesReq& default_instance();

  void Swap(GetTablesReq* other);

  // implements Message ----------------------------------------------

  GetTablesReq* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const GetTablesReq& from);
  void MergeFrom(const GetTablesReq& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .exec.user.LikeFilter catalog_name_filter = 1;
  inline bool has_catalog_name_filter() const;
  inline void clear_catalog_name_filter();
  static const int kCatalogNameFilterFieldNumber = 1;
  inline const ::exec::user::LikeFilter& catalog_name_filter() const;
  inline ::exec::user::LikeFilter* mutable_catalog_name_filter();
  inline ::exec::user::LikeFilter* release_catalog_name_filter();
  inline void set_allocated_catalog_name_filter(::exec::user::LikeFilter* catalog_name_filter);

  // optional .exec.user.LikeFilter schema_name_filter = 2;
  inline bool has_schema_name_filter() const;
  inline void clear_schema_name_filter();
  static const int kSchemaNameFilterFieldNumber = 2;
  inline const ::exec::user::LikeFilter& schema_name_filter() const;
  inline ::exec::user::LikeFilter* mutable_schema_name_filter();
  inline ::exec::user::LikeFilter* release_schema_name_filter();
  inline void set_allocated_schema_name_filter(::exec::user::LikeFilter* schema_name_filter);

  // optional .exec.user.LikeFilter table_name_filter = 3;
  inline bool has_table_name_filter() const;
  inline void clear_table_name_filter();
  static const int kTableNameFilterFieldNumber = 3;
  inline const ::exec::user::LikeFilter& table_name_filter() const;
  inline ::exec::user::LikeFilter* mutable_table_name_filter();
  inline ::exec::user::LikeFilter* release_table_name_filter();
  inline void set_allocated_table_name_filter(::exec::user::LikeFilter* table_name_filter);

  // repeated string table_type_filter = 4;
  inline int table_type_filter_size() const;
  inline void clear_table_type_filter();
  static const int kTableTypeFilterFieldNumber = 4;
  inline const ::std::string& table_type_filter(int index) const;
  inline ::std::string* mutable_table_type_filter(int index);
  inline void set_table_type_filter(int index, const ::std::string& value);
  inline void set_table_type_filter(int index, const char* value);
  inline void set_table_type_filter(int index, const char* value, size_t size);
  inline ::std::string* add_table_type_filter();
  inline void add_table_type_filter(const ::std::string& value);
  inline void add_table_type_filter(const char* value);
  inline void add_table_type_filter(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& table_type_filter() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_table_type_filter();

  // @@protoc_insertion_point(class_scope:exec.user.GetTablesReq)
 private:
  inline void set_has_catalog_name_filter();
  inline void clear_has_catalog_name_filter();
  inline void set_has_schema_name_filter();
  inline void clear_has_schema_name_filter();
  inline void set_has_table_name_filter();
  inline void clear_has_table_name_filter();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::exec::user::LikeFilter* catalog_name_filter_;
  ::exec::user::LikeFilter* schema_name_filter_;
  ::exec::user::LikeFilter* table_name_filter_;
  ::google::protobuf::RepeatedPtrField< ::std::string> table_type_filter_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static GetTablesReq* default_instance_;
};
// -------------------------------------------------------------------

class TableMetadata : public ::google::protobuf::Message {
 public:
  TableMetadata();
  virtual ~TableMetadata();

  TableMetadata(const TableMetadata& from);

  inline TableMetadata& operator=(const TableMetadata& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const TableMetadata& default_instance();

  void Swap(TableMetadata* other);

  // implements Message ----------------------------------------------

  TableMetadata* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const TableMetadata& from);
  void MergeFrom(const TableMetadata& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional string catalog_name = 1;
  inline bool has_catalog_name() const;
  inline void clear_catalog_name();
  static const int kCatalogNameFieldNumber = 1;
  inline const ::std::string& catalog_name() const;
  inline void set_catalog_name(const ::std::string& value);
  inline void set_catalog_name(const char* value);
  inline void set_catalog_name(const char* value, size_t size);
  inline ::std::string* mutable_catalog_name();
  inline ::std::string* release_catalog_name();
  inline void set_allocated_catalog_name(::std::string* catalog_name);

  // optional string schema_name = 2;
  inline bool has_schema_name() const;
  inline void clear_schema_name();
  static const int kSchemaNameFieldNumber = 2;
  inline const ::std::string& schema_name() const;
  inline void set_schema_name(const ::std::string& value);
  inline void set_schema_name(const char* value);
  inline void set_schema_name(const char* value, size_t size);
  inline ::std::string* mutable_schema_name();
  inline ::std::string* release_schema_name();
  inline void set_allocated_schema_name(::std::string* schema_name);

  // optional string table_name = 3;
  inline bool has_table_name() const;
  inline void clear_table_name();
  static const int kTableNameFieldNumber = 3;
  inline const ::std::string& table_name() const;
  inline void set_table_name(const ::std::string& value);
  inline void set_table_name(const char* value);
  inline void set_table_name(const char* value, size_t size);
  inline ::std::string* mutable_table_name();
  inline ::std::string* release_table_name();
  inline void set_allocated_table_name(::std::string* table_name);

  // optional string type = 4;
  inline bool has_type() const;
  inline void clear_type();
  static const int kTypeFieldNumber = 4;
  inline const ::std::string& type() const;
  inline void set_type(const ::std::string& value);
  inline void set_type(const char* value);
  inline void set_type(const char* value, size_t size);
  inline ::std::string* mutable_type();
  inline ::std::string* release_type();
  inline void set_allocated_type(::std::string* type);

  // @@protoc_insertion_point(class_scope:exec.user.TableMetadata)
 private:
  inline void set_has_catalog_name();
  inline void clear_has_catalog_name();
  inline void set_has_schema_name();
  inline void clear_has_schema_name();
  inline void set_has_table_name();
  inline void clear_has_table_name();
  inline void set_has_type();
  inline void clear_has_type();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* catalog_name_;
  ::std::string* schema_name_;
  ::std::string* table_name_;
  ::std::string* type_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static TableMetadata* default_instance_;
};
// -------------------------------------------------------------------

class GetTablesResp : public ::google::protobuf::Message {
 public:
  GetTablesResp();
  virtual ~GetTablesResp();

  GetTablesResp(const GetTablesResp& from);

  inline GetTablesResp& operator=(const GetTablesResp& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const GetTablesResp& default_instance();

  void Swap(GetTablesResp* other);

  // implements Message ----------------------------------------------

  GetTablesResp* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const GetTablesResp& from);
  void MergeFrom(const GetTablesResp& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .exec.user.RequestStatus status = 1;
  inline bool has_status() const;
  inline void clear_status();
  static const int kStatusFieldNumber = 1;
  inline ::exec::user::RequestStatus status() const;
  inline void set_status(::exec::user::RequestStatus value);

  // repeated .exec.user.TableMetadata tables = 2;
  inline int tables_size() const;
  inline void clear_tables();
  static const int kTablesFieldNumber = 2;
  inline const ::exec::user::TableMetadata& tables(int index) const;
  inline ::exec::user::TableMetadata* mutable_tables(int index);
  inline ::exec::user::TableMetadata* add_tables();
  inline const ::google::protobuf::RepeatedPtrField< ::exec::user::TableMetadata >&
      tables() const;
  inline ::google::protobuf::RepeatedPtrField< ::exec::user::TableMetadata >*
      mutable_tables();

  // optional .exec.shared.DrillPBError error = 3;
  inline bool has_error() const;
  inline void clear_error();
  static const int kErrorFieldNumber = 3;
  inline const ::exec::shared::DrillPBError& error() const;
  inline ::exec::shared::DrillPBError* mutable_error();
  inline ::exec::shared::DrillPBError* release_error();
  inline void set_allocated_error(::exec::shared::DrillPBError* error);

  // @@protoc_insertion_point(class_scope:exec.user.GetTablesResp)
 private:
  inline void set_has_status();
  inline void clear_has_status();
  inline void set_has_error();
  inline void clear_has_error();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::RepeatedPtrField< ::exec::user::TableMetadata > tables_;
  ::exec::shared::DrillPBError* error_;
  int status_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static GetTablesResp* default_instance_;
};
// -------------------------------------------------------------------

class GetColumnsReq : public ::google::protobuf::Message {
 public:
  GetColumnsReq();
  virtual ~GetColumnsReq();

  GetColumnsReq(const GetColumnsReq& from);

  inline GetColumnsReq& operator=(const GetColumnsReq& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const GetColumnsReq& default_instance();

  void Swap(GetColumnsReq* other);

  // implements Message ----------------------------------------------

  GetColumnsReq* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const GetColumnsReq& from);
  void MergeFrom(const GetColumnsReq& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .exec.user.LikeFilter catalog_name_filter = 1;
  inline bool has_catalog_name_filter() const;
  inline void clear_catalog_name_filter();
  static const int kCatalogNameFilterFieldNumber = 1;
  inline const ::exec::user::LikeFilter& catalog_name_filter() const;
  inline ::exec::user::LikeFilter* mutable_catalog_name_filter();
  inline ::exec::user::LikeFilter* release_catalog_name_filter();
  inline void set_allocated_catalog_name_filter(::exec::user::LikeFilter* catalog_name_filter);

  // optional .exec.user.LikeFilter schema_name_filter = 2;
  inline bool has_schema_name_filter() const;
  inline void clear_schema_name_filter();
  static const int kSchemaNameFilterFieldNumber = 2;
  inline const ::exec::user::LikeFilter& schema_name_filter() const;
  inline ::exec::user::LikeFilter* mutable_schema_name_filter();
  inline ::exec::user::LikeFilter* release_schema_name_filter();
  inline void set_allocated_schema_name_filter(::exec::user::LikeFilter* schema_name_filter);

  // optional .exec.user.LikeFilter table_name_filter = 3;
  inline bool has_table_name_filter() const;
  inline void clear_table_name_filter();
  static const int kTableNameFilterFieldNumber = 3;
  inline const ::exec::user::LikeFilter& table_name_filter() const;
  inline ::exec::user::LikeFilter* mutable_table_name_filter();
  inline ::exec::user::LikeFilter* release_table_name_filter();
  inline void set_allocated_table_name_filter(::exec::user::LikeFilter* table_name_filter);

  // optional .exec.user.LikeFilter column_name_filter = 4;
  inline bool has_column_name_filter() const;
  inline void clear_column_name_filter();
  static const int kColumnNameFilterFieldNumber = 4;
  inline const ::exec::user::LikeFilter& column_name_filter() const;
  inline ::exec::user::LikeFilter* mutable_column_name_filter();
  inline ::exec::user::LikeFilter* release_column_name_filter();
  inline void set_allocated_column_name_filter(::exec::user::LikeFilter* column_name_filter);

  // @@protoc_insertion_point(class_scope:exec.user.GetColumnsReq)
 private:
  inline void set_has_catalog_name_filter();
  inline void clear_has_catalog_name_filter();
  inline void set_has_schema_name_filter();
  inline void clear_has_schema_name_filter();
  inline void set_has_table_name_filter();
  inline void clear_has_table_name_filter();
  inline void set_has_column_name_filter();
  inline void clear_has_column_name_filter();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::exec::user::LikeFilter* catalog_name_filter_;
  ::exec::user::LikeFilter* schema_name_filter_;
  ::exec::user::LikeFilter* table_name_filter_;
  ::exec::user::LikeFilter* column_name_filter_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static GetColumnsReq* default_instance_;
};
// -------------------------------------------------------------------

class ColumnMetadata : public ::google::protobuf::Message {
 public:
  ColumnMetadata();
  virtual ~ColumnMetadata();

  ColumnMetadata(const ColumnMetadata& from);

  inline ColumnMetadata& operator=(const ColumnMetadata& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const ColumnMetadata& default_instance();

  void Swap(ColumnMetadata* other);

  // implements Message ----------------------------------------------

  ColumnMetadata* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ColumnMetadata& from);
  void MergeFrom(const ColumnMetadata& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional string catalog_name = 1;
  inline bool has_catalog_name() const;
  inline void clear_catalog_name();
  static const int kCatalogNameFieldNumber = 1;
  inline const ::std::string& catalog_name() const;
  inline void set_catalog_name(const ::std::string& value);
  inline void set_catalog_name(const char* value);
  inline void set_catalog_name(const char* value, size_t size);
  inline ::std::string* mutable_catalog_name();
  inline ::std::string* release_catalog_name();
  inline void set_allocated_catalog_name(::std::string* catalog_name);

  // optional string schema_name = 2;
  inline bool has_schema_name() const;
  inline void clear_schema_name();
  static const int kSchemaNameFieldNumber = 2;
  inline const ::std::string& schema_name() const;
  inline void set_schema_name(const ::std::string& value);
  inline void set_schema_name(const char* value);
  inline void set_schema_name(const char* value, size_t size);
  inline ::std::string* mutable_schema_name();
  inline ::std::string* release_schema_name();
  inline void set_allocated_schema_name(::std::string* schema_name);

  // optional string table_name = 3;
  inline bool has_table_name() const;
  inline void clear_table_name();
  static const int kTableNameFieldNumber = 3;
  inline const ::std::string& table_name() const;
  inline void set_table_name(const ::std::string& value);
  inline void set_table_name(const char* value);
  inline void set_table_name(const char* value, size_t size);
  inline ::std::string* mutable_table_name();
  inline ::std::string* release_table_name();
  inline void set_allocated_table_name(::std::string* table_name);

  // optional string column_name = 4;
  inline bool has_column_name() const;
  inline void clear_column_name();
  static const int kColumnNameFieldNumber = 4;
  inline const ::std::string& column_name() const;
  inline void set_column_name(const ::std::string& value);
  inline void set_column_name(const char* value);
  inline void set_column_name(const char* value, size_t size);
  inline ::std::string* mutable_column_name();
  inline ::std::string* release_column_name();
  inline void set_allocated_column_name(::std::string* column_name);

  // optional int32 ordinal_position = 5;
  inline bool has_ordinal_position() const;
  inline void clear_ordinal_position();
  static const int kOrdinalPositionFieldNumber = 5;
  inline ::google::protobuf::int32 ordinal_position() const;
  inline void set_ordinal_position(::google::protobuf::int32 value);

  // optional string default_value = 6;
  inline bool has_default_value() const;
  inline void clear_default_value();
  static const int kDefaultValueFieldNumber = 6;
  inline const ::std::string& default_value() const;
  inline void set_default_value(const ::std::string& value);
  inline void set_default_value(const char* value);
  inline void set_default_value(const char* value, size_t size);
  inline ::std::string* mutable_default_value();
  inline ::std::string* release_default_value();
  inline void set_allocated_default_value(::std::string* default_value);

  // optional bool is_nullable = 7;
  inline bool has_is_nullable() const;
  inline void clear_is_nullable();
  static const int kIsNullableFieldNumber = 7;
  inline bool is_nullable() const;
  inline void set_is_nullable(bool value);

  // optional string data_type = 8;
  inline bool has_data_type() const;
  inline void clear_data_type();
  static const int kDataTypeFieldNumber = 8;
  inline const ::std::string& data_type() const;
  inline void set_data_type(const ::std::string& value);
  inline void set_data_type(const char* value);
  inline void set_data_type(const char* value, size_t size);
  inline ::std::string* mutable_data_type();
  inline ::std::string* release_data_type();
  inline void set_allocated_data_type(::std::string* data_type);

  // optional int32 char_max_length = 9;
  inline bool has_char_max_length() const;
  inline void clear_char_max_length();
  static const int kCharMaxLengthFieldNumber = 9;
  inline ::google::protobuf::int32 char_max_length() const;
  inline void set_char_max_length(::google::protobuf::int32 value);

  // optional int32 char_octet_length = 10;
  inline bool has_char_octet_length() const;
  inline void clear_char_octet_length();
  static const int kCharOctetLengthFieldNumber = 10;
  inline ::google::protobuf::int32 char_octet_length() const;
  inline void set_char_octet_length(::google::protobuf::int32 value);

  // optional int32 numeric_precision = 11;
  inline bool has_numeric_precision() const;
  inline void clear_numeric_precision();
  static const int kNumericPrecisionFieldNumber = 11;
  inline ::google::protobuf::int32 numeric_precision() const;
  inline void set_numeric_precision(::google::protobuf::int32 value);

  // optional int32 numeric_precision_radix = 12;
  inline bool has_numeric_precision_radix() const;
  inline void clear_numeric_precision_radix();
  static const int kNumericPrecisionRadixFieldNumber = 12;
  inline ::google::protobuf::int32 numeric_precision_radix() const;
  inline void set_numeric_precision_radix(::google::protobuf::int32 value);

  // optional int32 numeric_scale = 13;
  inline bool has_numeric_scale() const;
  inline void clear_numeric_scale();
  static const int kNumericScaleFieldNumber = 13;
  inline ::google::protobuf::int32 numeric_scale() const;
  inline void set_numeric_scale(::google::protobuf::int32 value);

  // optional int32 date_time_precision = 14;
  inline bool has_date_time_precision() const;
  inline void clear_date_time_precision();
  static const int kDateTimePrecisionFieldNumber = 14;
  inline ::google::protobuf::int32 date_time_precision() const;
  inline void set_date_time_precision(::google::protobuf::int32 value);

  // optional string interval_type = 15;
  inline bool has_interval_type() const;
  inline void clear_interval_type();
  static const int kIntervalTypeFieldNumber = 15;
  inline const ::std::string& interval_type() const;
  inline void set_interval_type(const ::std::string& value);
  inline void set_interval_type(const char* value);
  inline void set_interval_type(const char* value, size_t size);
  inline ::std::string* mutable_interval_type();
  inline ::std::string* release_interval_type();
  inline void set_allocated_interval_type(::std::string* interval_type);

  // optional int32 interval_precision = 16;
  inline bool has_interval_precision() const;
  inline void clear_interval_precision();
  static const int kIntervalPrecisionFieldNumber = 16;
  inline ::google::protobuf::int32 interval_precision() const;
  inline void set_interval_precision(::google::protobuf::int32 value);

  // optional int32 column_size = 17;
  inline bool has_column_size() const;
  inline void clear_column_size();
  static const int kColumnSizeFieldNumber = 17;
  inline ::google::protobuf::int32 column_size() const;
  inline void set_column_size(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:exec.user.ColumnMetadata)
 private:
  inline void set_has_catalog_name();
  inline void clear_has_catalog_name();
  inline void set_has_schema_name();
  inline void clear_has_schema_name();
  inline void set_has_table_name();
  inline void clear_has_table_name();
  inline void set_has_column_name();
  inline void clear_has_column_name();
  inline void set_has_ordinal_position();
  inline void clear_has_ordinal_position();
  inline void set_has_default_value();
  inline void clear_has_default_value();
  inline void set_has_is_nullable();
  inline void clear_has_is_nullable();
  inline void set_has_data_type();
  inline void clear_has_data_type();
  inline void set_has_char_max_length();
  inline void clear_has_char_max_length();
  inline void set_has_char_octet_length();
  inline void clear_has_char_octet_length();
  inline void set_has_numeric_precision();
  inline void clear_has_numeric_precision();
  inline void set_has_numeric_precision_radix();
  inline void clear_has_numeric_precision_radix();
  inline void set_has_numeric_scale();
  inline void clear_has_numeric_scale();
  inline void set_has_date_time_precision();
  inline void clear_has_date_time_precision();
  inline void set_has_interval_type();
  inline void clear_has_interval_type();
  inline void set_has_interval_precision();
  inline void clear_has_interval_precision();
  inline void set_has_column_size();
  inline void clear_has_column_size();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* catalog_name_;
  ::std::string* schema_name_;
  ::std::string* table_name_;
  ::std::string* column_name_;
  ::std::string* default_value_;
  ::google::protobuf::int32 ordinal_position_;
  bool is_nullable_;
  ::std::string* data_type_;
  ::google::protobuf::int32 char_max_length_;
  ::google::protobuf::int32 char_octet_length_;
  ::google::protobuf::int32 numeric_precision_;
  ::google::protobuf::int32 numeric_precision_radix_;
  ::google::protobuf::int32 numeric_scale_;
  ::google::protobuf::int32 date_time_precision_;
  ::std::string* interval_type_;
  ::google::protobuf::int32 interval_precision_;
  ::google::protobuf::int32 column_size_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(17 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static ColumnMetadata* default_instance_;
};
// -------------------------------------------------------------------

class GetColumnsResp : public ::google::protobuf::Message {
 public:
  GetColumnsResp();
  virtual ~GetColumnsResp();

  GetColumnsResp(const GetColumnsResp& from);

  inline GetColumnsResp& operator=(const GetColumnsResp& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const GetColumnsResp& default_instance();

  void Swap(GetColumnsResp* other);

  // implements Message ----------------------------------------------

  GetColumnsResp* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const GetColumnsResp& from);
  void MergeFrom(const GetColumnsResp& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .exec.user.RequestStatus status = 1;
  inline bool has_status() const;
  inline void clear_status();
  static const int kStatusFieldNumber = 1;
  inline ::exec::user::RequestStatus status() const;
  inline void set_status(::exec::user::RequestStatus value);

  // repeated .exec.user.ColumnMetadata columns = 2;
  inline int columns_size() const;
  inline void clear_columns();
  static const int kColumnsFieldNumber = 2;
  inline const ::exec::user::ColumnMetadata& columns(int index) const;
  inline ::exec::user::ColumnMetadata* mutable_columns(int index);
  inline ::exec::user::ColumnMetadata* add_columns();
  inline const ::google::protobuf::RepeatedPtrField< ::exec::user::ColumnMetadata >&
      columns() const;
  inline ::google::protobuf::RepeatedPtrField< ::exec::user::ColumnMetadata >*
      mutable_columns();

  // optional .exec.shared.DrillPBError error = 3;
  inline bool has_error() const;
  inline void clear_error();
  static const int kErrorFieldNumber = 3;
  inline const ::exec::shared::DrillPBError& error() const;
  inline ::exec::shared::DrillPBError* mutable_error();
  inline ::exec::shared::DrillPBError* release_error();
  inline void set_allocated_error(::exec::shared::DrillPBError* error);

  // @@protoc_insertion_point(class_scope:exec.user.GetColumnsResp)
 private:
  inline void set_has_status();
  inline void clear_has_status();
  inline void set_has_error();
  inline void clear_has_error();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::RepeatedPtrField< ::exec::user::ColumnMetadata > columns_;
  ::exec::shared::DrillPBError* error_;
  int status_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static GetColumnsResp* default_instance_;
};
// -------------------------------------------------------------------

class CreatePreparedStatementReq : public ::google::protobuf::Message {
 public:
  CreatePreparedStatementReq();
  virtual ~CreatePreparedStatementReq();

  CreatePreparedStatementReq(const CreatePreparedStatementReq& from);

  inline CreatePreparedStatementReq& operator=(const CreatePreparedStatementReq& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const CreatePreparedStatementReq& default_instance();

  void Swap(CreatePreparedStatementReq* other);

  // implements Message ----------------------------------------------

  CreatePreparedStatementReq* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CreatePreparedStatementReq& from);
  void MergeFrom(const CreatePreparedStatementReq& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional string sql_query = 1;
  inline bool has_sql_query() const;
  inline void clear_sql_query();
  static const int kSqlQueryFieldNumber = 1;
  inline const ::std::string& sql_query() const;
  inline void set_sql_query(const ::std::string& value);
  inline void set_sql_query(const char* value);
  inline void set_sql_query(const char* value, size_t size);
  inline ::std::string* mutable_sql_query();
  inline ::std::string* release_sql_query();
  inline void set_allocated_sql_query(::std::string* sql_query);

  // @@protoc_insertion_point(class_scope:exec.user.CreatePreparedStatementReq)
 private:
  inline void set_has_sql_query();
  inline void clear_has_sql_query();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* sql_query_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static CreatePreparedStatementReq* default_instance_;
};
// -------------------------------------------------------------------

class ResultColumnMetadata : public ::google::protobuf::Message {
 public:
  ResultColumnMetadata();
  virtual ~ResultColumnMetadata();

  ResultColumnMetadata(const ResultColumnMetadata& from);

  inline ResultColumnMetadata& operator=(const ResultColumnMetadata& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const ResultColumnMetadata& default_instance();

  void Swap(ResultColumnMetadata* other);

  // implements Message ----------------------------------------------

  ResultColumnMetadata* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ResultColumnMetadata& from);
  void MergeFrom(const ResultColumnMetadata& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional string catalog_name = 1;
  inline bool has_catalog_name() const;
  inline void clear_catalog_name();
  static const int kCatalogNameFieldNumber = 1;
  inline const ::std::string& catalog_name() const;
  inline void set_catalog_name(const ::std::string& value);
  inline void set_catalog_name(const char* value);
  inline void set_catalog_name(const char* value, size_t size);
  inline ::std::string* mutable_catalog_name();
  inline ::std::string* release_catalog_name();
  inline void set_allocated_catalog_name(::std::string* catalog_name);

  // optional string schema_name = 2;
  inline bool has_schema_name() const;
  inline void clear_schema_name();
  static const int kSchemaNameFieldNumber = 2;
  inline const ::std::string& schema_name() const;
  inline void set_schema_name(const ::std::string& value);
  inline void set_schema_name(const char* value);
  inline void set_schema_name(const char* value, size_t size);
  inline ::std::string* mutable_schema_name();
  inline ::std::string* release_schema_name();
  inline void set_allocated_schema_name(::std::string* schema_name);

  // optional string table_name = 3;
  inline bool has_table_name() const;
  inline void clear_table_name();
  static const int kTableNameFieldNumber = 3;
  inline const ::std::string& table_name() const;
  inline void set_table_name(const ::std::string& value);
  inline void set_table_name(const char* value);
  inline void set_table_name(const char* value, size_t size);
  inline ::std::string* mutable_table_name();
  inline ::std::string* release_table_name();
  inline void set_allocated_table_name(::std::string* table_name);

  // optional string column_name = 4;
  inline bool has_column_name() const;
  inline void clear_column_name();
  static const int kColumnNameFieldNumber = 4;
  inline const ::std::string& column_name() const;
  inline void set_column_name(const ::std::string& value);
  inline void set_column_name(const char* value);
  inline void set_column_name(const char* value, size_t size);
  inline ::std::string* mutable_column_name();
  inline ::std::string* release_column_name();
  inline void set_allocated_column_name(::std::string* column_name);

  // optional string label = 5;
  inline bool has_label() const;
  inline void clear_label();
  static const int kLabelFieldNumber = 5;
  inline const ::std::string& label() const;
  inline void set_label(const ::std::string& value);
  inline void set_label(const char* value);
  inline void set_label(const char* value, size_t size);
  inline ::std::string* mutable_label();
  inline ::std::string* release_label();
  inline void set_allocated_label(::std::string* label);

  // optional string data_type = 6;
  inline bool has_data_type() const;
  inline void clear_data_type();
  static const int kDataTypeFieldNumber = 6;
  inline const ::std::string& data_type() const;
  inline void set_data_type(const ::std::string& value);
  inline void set_data_type(const char* value);
  inline void set_data_type(const char* value, size_t size);
  inline ::std::string* mutable_data_type();
  inline ::std::string* release_data_type();
  inline void set_allocated_data_type(::std::string* data_type);

  // optional bool is_nullable = 7;
  inline bool has_is_nullable() const;
  inline void clear_is_nullable();
  static const int kIsNullableFieldNumber = 7;
  inline bool is_nullable() const;
  inline void set_is_nullable(bool value);

  // optional int32 precision = 8;
  inline bool has_precision() const;
  inline void clear_precision();
  static const int kPrecisionFieldNumber = 8;
  inline ::google::protobuf::int32 precision() const;
  inline void set_precision(::google::protobuf::int32 value);

  // optional int32 scale = 9;
  inline bool has_scale() const;
  inline void clear_scale();
  static const int kScaleFieldNumber = 9;
  inline ::google::protobuf::int32 scale() const;
  inline void set_scale(::google::protobuf::int32 value);

  // optional bool signed = 10;
  inline bool has_signed_() const;
  inline void clear_signed_();
  static const int kSignedFieldNumber = 10;
  inline bool signed_() const;
  inline void set_signed_(bool value);

  // optional int32 display_size = 11;
  inline bool has_display_size() const;
  inline void clear_display_size();
  static const int kDisplaySizeFieldNumber = 11;
  inline ::google::protobuf::int32 display_size() const;
  inline void set_display_size(::google::protobuf::int32 value);

  // optional bool is_aliased = 12;
  inline bool has_is_aliased() const;
  inline void clear_is_aliased();
  static const int kIsAliasedFieldNumber = 12;
  inline bool is_aliased() const;
  inline void set_is_aliased(bool value);

  // optional .exec.user.ColumnSearchability searchability = 13;
  inline bool has_searchability() const;
  inline void clear_searchability();
  static const int kSearchabilityFieldNumber = 13;
  inline ::exec::user::ColumnSearchability searchability() const;
  inline void set_searchability(::exec::user::ColumnSearchability value);

  // optional .exec.user.ColumnUpdatability updatability = 14;
  inline bool has_updatability() const;
  inline void clear_updatability();
  static const int kUpdatabilityFieldNumber = 14;
  inline ::exec::user::ColumnUpdatability updatability() const;
  inline void set_updatability(::exec::user::ColumnUpdatability value);

  // optional bool auto_increment = 15;
  inline bool has_auto_increment() const;
  inline void clear_auto_increment();
  static const int kAutoIncrementFieldNumber = 15;
  inline bool auto_increment() const;
  inline void set_auto_increment(bool value);

  // optional bool case_sensitivity = 16;
  inline bool has_case_sensitivity() const;
  inline void clear_case_sensitivity();
  static const int kCaseSensitivityFieldNumber = 16;
  inline bool case_sensitivity() const;
  inline void set_case_sensitivity(bool value);

  // optional bool sortable = 17;
  inline bool has_sortable() const;
  inline void clear_sortable();
  static const int kSortableFieldNumber = 17;
  inline bool sortable() const;
  inline void set_sortable(bool value);

  // optional string class_name = 18;
  inline bool has_class_name() const;
  inline void clear_class_name();
  static const int kClassNameFieldNumber = 18;
  inline const ::std::string& class_name() const;
  inline void set_class_name(const ::std::string& value);
  inline void set_class_name(const char* value);
  inline void set_class_name(const char* value, size_t size);
  inline ::std::string* mutable_class_name();
  inline ::std::string* release_class_name();
  inline void set_allocated_class_name(::std::string* class_name);

  // optional bool is_currency = 20;
  inline bool has_is_currency() const;
  inline void clear_is_currency();
  static const int kIsCurrencyFieldNumber = 20;
  inline bool is_currency() const;
  inline void set_is_currency(bool value);

  // @@protoc_insertion_point(class_scope:exec.user.ResultColumnMetadata)
 private:
  inline void set_has_catalog_name();
  inline void clear_has_catalog_name();
  inline void set_has_schema_name();
  inline void clear_has_schema_name();
  inline void set_has_table_name();
  inline void clear_has_table_name();
  inline void set_has_column_name();
  inline void clear_has_column_name();
  inline void set_has_label();
  inline void clear_has_label();
  inline void set_has_data_type();
  inline void clear_has_data_type();
  inline void set_has_is_nullable();
  inline void clear_has_is_nullable();
  inline void set_has_precision();
  inline void clear_has_precision();
  inline void set_has_scale();
  inline void clear_has_scale();
  inline void set_has_signed_();
  inline void clear_has_signed_();
  inline void set_has_display_size();
  inline void clear_has_display_size();
  inline void set_has_is_aliased();
  inline void clear_has_is_aliased();
  inline void set_has_searchability();
  inline void clear_has_searchability();
  inline void set_has_updatability();
  inline void clear_has_updatability();
  inline void set_has_auto_increment();
  inline void clear_has_auto_increment();
  inline void set_has_case_sensitivity();
  inline void clear_has_case_sensitivity();
  inline void set_has_sortable();
  inline void clear_has_sortable();
  inline void set_has_class_name();
  inline void clear_has_class_name();
  inline void set_has_is_currency();
  inline void clear_has_is_currency();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* catalog_name_;
  ::std::string* schema_name_;
  ::std::string* table_name_;
  ::std::string* column_name_;
  ::std::string* label_;
  ::std::string* data_type_;
  ::google::protobuf::int32 precision_;
  ::google::protobuf::int32 scale_;
  ::google::protobuf::int32 display_size_;
  bool is_nullable_;
  bool signed__;
  bool is_aliased_;
  bool auto_increment_;
  int searchability_;
  int updatability_;
  ::std::string* class_name_;
  bool case_sensitivity_;
  bool sortable_;
  bool is_currency_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(19 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static ResultColumnMetadata* default_instance_;
};
// -------------------------------------------------------------------

class PreparedStatementHandle : public ::google::protobuf::Message {
 public:
  PreparedStatementHandle();
  virtual ~PreparedStatementHandle();

  PreparedStatementHandle(const PreparedStatementHandle& from);

  inline PreparedStatementHandle& operator=(const PreparedStatementHandle& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const PreparedStatementHandle& default_instance();

  void Swap(PreparedStatementHandle* other);

  // implements Message ----------------------------------------------

  PreparedStatementHandle* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const PreparedStatementHandle& from);
  void MergeFrom(const PreparedStatementHandle& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bytes server_info = 1;
  inline bool has_server_info() const;
  inline void clear_server_info();
  static const int kServerInfoFieldNumber = 1;
  inline const ::std::string& server_info() const;
  inline void set_server_info(const ::std::string& value);
  inline void set_server_info(const char* value);
  inline void set_server_info(const void* value, size_t size);
  inline ::std::string* mutable_server_info();
  inline ::std::string* release_server_info();
  inline void set_allocated_server_info(::std::string* server_info);

  // @@protoc_insertion_point(class_scope:exec.user.PreparedStatementHandle)
 private:
  inline void set_has_server_info();
  inline void clear_has_server_info();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* server_info_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static PreparedStatementHandle* default_instance_;
};
// -------------------------------------------------------------------

class PreparedStatement : public ::google::protobuf::Message {
 public:
  PreparedStatement();
  virtual ~PreparedStatement();

  PreparedStatement(const PreparedStatement& from);

  inline PreparedStatement& operator=(const PreparedStatement& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const PreparedStatement& default_instance();

  void Swap(PreparedStatement* other);

  // implements Message ----------------------------------------------

  PreparedStatement* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const PreparedStatement& from);
  void MergeFrom(const PreparedStatement& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated .exec.user.ResultColumnMetadata columns = 1;
  inline int columns_size() const;
  inline void clear_columns();
  static const int kColumnsFieldNumber = 1;
  inline const ::exec::user::ResultColumnMetadata& columns(int index) const;
  inline ::exec::user::ResultColumnMetadata* mutable_columns(int index);
  inline ::exec::user::ResultColumnMetadata* add_columns();
  inline const ::google::protobuf::RepeatedPtrField< ::exec::user::ResultColumnMetadata >&
      columns() const;
  inline ::google::protobuf::RepeatedPtrField< ::exec::user::ResultColumnMetadata >*
      mutable_columns();

  // optional .exec.user.PreparedStatementHandle server_handle = 2;
  inline bool has_server_handle() const;
  inline void clear_server_handle();
  static const int kServerHandleFieldNumber = 2;
  inline const ::exec::user::PreparedStatementHandle& server_handle() const;
  inline ::exec::user::PreparedStatementHandle* mutable_server_handle();
  inline ::exec::user::PreparedStatementHandle* release_server_handle();
  inline void set_allocated_server_handle(::exec::user::PreparedStatementHandle* server_handle);

  // @@protoc_insertion_point(class_scope:exec.user.PreparedStatement)
 private:
  inline void set_has_server_handle();
  inline void clear_has_server_handle();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::RepeatedPtrField< ::exec::user::ResultColumnMetadata > columns_;
  ::exec::user::PreparedStatementHandle* server_handle_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static PreparedStatement* default_instance_;
};
// -------------------------------------------------------------------

class CreatePreparedStatementResp : public ::google::protobuf::Message {
 public:
  CreatePreparedStatementResp();
  virtual ~CreatePreparedStatementResp();

  CreatePreparedStatementResp(const CreatePreparedStatementResp& from);

  inline CreatePreparedStatementResp& operator=(const CreatePreparedStatementResp& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const CreatePreparedStatementResp& default_instance();

  void Swap(CreatePreparedStatementResp* other);

  // implements Message ----------------------------------------------

  CreatePreparedStatementResp* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CreatePreparedStatementResp& from);
  void MergeFrom(const CreatePreparedStatementResp& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .exec.user.RequestStatus status = 1;
  inline bool has_status() const;
  inline void clear_status();
  static const int kStatusFieldNumber = 1;
  inline ::exec::user::RequestStatus status() const;
  inline void set_status(::exec::user::RequestStatus value);

  // optional .exec.user.PreparedStatement prepared_statement = 2;
  inline bool has_prepared_statement() const;
  inline void clear_prepared_statement();
  static const int kPreparedStatementFieldNumber = 2;
  inline const ::exec::user::PreparedStatement& prepared_statement() const;
  inline ::exec::user::PreparedStatement* mutable_prepared_statement();
  inline ::exec::user::PreparedStatement* release_prepared_statement();
  inline void set_allocated_prepared_statement(::exec::user::PreparedStatement* prepared_statement);

  // optional .exec.shared.DrillPBError error = 3;
  inline bool has_error() const;
  inline void clear_error();
  static const int kErrorFieldNumber = 3;
  inline const ::exec::shared::DrillPBError& error() const;
  inline ::exec::shared::DrillPBError* mutable_error();
  inline ::exec::shared::DrillPBError* release_error();
  inline void set_allocated_error(::exec::shared::DrillPBError* error);

  // @@protoc_insertion_point(class_scope:exec.user.CreatePreparedStatementResp)
 private:
  inline void set_has_status();
  inline void clear_has_status();
  inline void set_has_prepared_statement();
  inline void clear_has_prepared_statement();
  inline void set_has_error();
  inline void clear_has_error();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::exec::user::PreparedStatement* prepared_statement_;
  ::exec::shared::DrillPBError* error_;
  int status_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static CreatePreparedStatementResp* default_instance_;
};
// -------------------------------------------------------------------

class GetServerMetaReq : public ::google::protobuf::Message {
 public:
  GetServerMetaReq();
  virtual ~GetServerMetaReq();

  GetServerMetaReq(const GetServerMetaReq& from);

  inline GetServerMetaReq& operator=(const GetServerMetaReq& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const GetServerMetaReq& default_instance();

  void Swap(GetServerMetaReq* other);

  // implements Message ----------------------------------------------

  GetServerMetaReq* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const GetServerMetaReq& from);
  void MergeFrom(const GetServerMetaReq& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // @@protoc_insertion_point(class_scope:exec.user.GetServerMetaReq)
 private:

  ::google::protobuf::UnknownFieldSet _unknown_fields_;


  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[1];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static GetServerMetaReq* default_instance_;
};
// -------------------------------------------------------------------

class ConvertSupport : public ::google::protobuf::Message {
 public:
  ConvertSupport();
  virtual ~ConvertSupport();

  ConvertSupport(const ConvertSupport& from);

  inline ConvertSupport& operator=(const ConvertSupport& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const ConvertSupport& default_instance();

  void Swap(ConvertSupport* other);

  // implements Message ----------------------------------------------

  ConvertSupport* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ConvertSupport& from);
  void MergeFrom(const ConvertSupport& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required .common.MinorType from = 1;
  inline bool has_from() const;
  inline void clear_from();
  static const int kFromFieldNumber = 1;
  inline ::common::MinorType from() const;
  inline void set_from(::common::MinorType value);

  // required .common.MinorType to = 2;
  inline bool has_to() const;
  inline void clear_to();
  static const int kToFieldNumber = 2;
  inline ::common::MinorType to() const;
  inline void set_to(::common::MinorType value);

  // @@protoc_insertion_point(class_scope:exec.user.ConvertSupport)
 private:
  inline void set_has_from();
  inline void clear_has_from();
  inline void set_has_to();
  inline void clear_has_to();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  int from_;
  int to_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static ConvertSupport* default_instance_;
};
// -------------------------------------------------------------------

class GetServerMetaResp : public ::google::protobuf::Message {
 public:
  GetServerMetaResp();
  virtual ~GetServerMetaResp();

  GetServerMetaResp(const GetServerMetaResp& from);

  inline GetServerMetaResp& operator=(const GetServerMetaResp& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const GetServerMetaResp& default_instance();

  void Swap(GetServerMetaResp* other);

  // implements Message ----------------------------------------------

  GetServerMetaResp* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const GetServerMetaResp& from);
  void MergeFrom(const GetServerMetaResp& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .exec.user.RequestStatus status = 1;
  inline bool has_status() const;
  inline void clear_status();
  static const int kStatusFieldNumber = 1;
  inline ::exec::user::RequestStatus status() const;
  inline void set_status(::exec::user::RequestStatus value);

  // optional .exec.user.ServerMeta server_meta = 2;
  inline bool has_server_meta() const;
  inline void clear_server_meta();
  static const int kServerMetaFieldNumber = 2;
  inline const ::exec::user::ServerMeta& server_meta() const;
  inline ::exec::user::ServerMeta* mutable_server_meta();
  inline ::exec::user::ServerMeta* release_server_meta();
  inline void set_allocated_server_meta(::exec::user::ServerMeta* server_meta);

  // optional .exec.shared.DrillPBError error = 3;
  inline bool has_error() const;
  inline void clear_error();
  static const int kErrorFieldNumber = 3;
  inline const ::exec::shared::DrillPBError& error() const;
  inline ::exec::shared::DrillPBError* mutable_error();
  inline ::exec::shared::DrillPBError* release_error();
  inline void set_allocated_error(::exec::shared::DrillPBError* error);

  // @@protoc_insertion_point(class_scope:exec.user.GetServerMetaResp)
 private:
  inline void set_has_status();
  inline void clear_has_status();
  inline void set_has_server_meta();
  inline void clear_has_server_meta();
  inline void set_has_error();
  inline void clear_has_error();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::exec::user::ServerMeta* server_meta_;
  ::exec::shared::DrillPBError* error_;
  int status_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static GetServerMetaResp* default_instance_;
};
// -------------------------------------------------------------------

class ServerMeta : public ::google::protobuf::Message {
 public:
  ServerMeta();
  virtual ~ServerMeta();

  ServerMeta(const ServerMeta& from);

  inline ServerMeta& operator=(const ServerMeta& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const ServerMeta& default_instance();

  void Swap(ServerMeta* other);

  // implements Message ----------------------------------------------

  ServerMeta* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ServerMeta& from);
  void MergeFrom(const ServerMeta& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bool all_tables_selectable = 1;
  inline bool has_all_tables_selectable() const;
  inline void clear_all_tables_selectable();
  static const int kAllTablesSelectableFieldNumber = 1;
  inline bool all_tables_selectable() const;
  inline void set_all_tables_selectable(bool value);

  // optional bool blob_included_in_max_row_size = 2;
  inline bool has_blob_included_in_max_row_size() const;
  inline void clear_blob_included_in_max_row_size();
  static const int kBlobIncludedInMaxRowSizeFieldNumber = 2;
  inline bool blob_included_in_max_row_size() const;
  inline void set_blob_included_in_max_row_size(bool value);

  // optional bool catalog_at_start = 3;
  inline bool has_catalog_at_start() const;
  inline void clear_catalog_at_start();
  static const int kCatalogAtStartFieldNumber = 3;
  inline bool catalog_at_start() const;
  inline void set_catalog_at_start(bool value);

  // optional string catalog_separator = 4;
  inline bool has_catalog_separator() const;
  inline void clear_catalog_separator();
  static const int kCatalogSeparatorFieldNumber = 4;
  inline const ::std::string& catalog_separator() const;
  inline void set_catalog_separator(const ::std::string& value);
  inline void set_catalog_separator(const char* value);
  inline void set_catalog_separator(const char* value, size_t size);
  inline ::std::string* mutable_catalog_separator();
  inline ::std::string* release_catalog_separator();
  inline void set_allocated_catalog_separator(::std::string* catalog_separator);

  // optional string catalog_term = 5;
  inline bool has_catalog_term() const;
  inline void clear_catalog_term();
  static const int kCatalogTermFieldNumber = 5;
  inline const ::std::string& catalog_term() const;
  inline void set_catalog_term(const ::std::string& value);
  inline void set_catalog_term(const char* value);
  inline void set_catalog_term(const char* value, size_t size);
  inline ::std::string* mutable_catalog_term();
  inline ::std::string* release_catalog_term();
  inline void set_allocated_catalog_term(::std::string* catalog_term);

  // repeated .exec.user.CollateSupport collate_support = 6;
  inline int collate_support_size() const;
  inline void clear_collate_support();
  static const int kCollateSupportFieldNumber = 6;
  inline ::exec::user::CollateSupport collate_support(int index) const;
  inline void set_collate_support(int index, ::exec::user::CollateSupport value);
  inline void add_collate_support(::exec::user::CollateSupport value);
  inline const ::google::protobuf::RepeatedField<int>& collate_support() const;
  inline ::google::protobuf::RepeatedField<int>* mutable_collate_support();

  // optional bool column_aliasing_supported = 7;
  inline bool has_column_aliasing_supported() const;
  inline void clear_column_aliasing_supported();
  static const int kColumnAliasingSupportedFieldNumber = 7;
  inline bool column_aliasing_supported() const;
  inline void set_column_aliasing_supported(bool value);

  // repeated .exec.user.ConvertSupport convert_support = 8;
  inline int convert_support_size() const;
  inline void clear_convert_support();
  static const int kConvertSupportFieldNumber = 8;
  inline const ::exec::user::ConvertSupport& convert_support(int index) const;
  inline ::exec::user::ConvertSupport* mutable_convert_support(int index);
  inline ::exec::user::ConvertSupport* add_convert_support();
  inline const ::google::protobuf::RepeatedPtrField< ::exec::user::ConvertSupport >&
      convert_support() const;
  inline ::google::protobuf::RepeatedPtrField< ::exec::user::ConvertSupport >*
      mutable_convert_support();

  // optional .exec.user.CorrelationNamesSupport correlation_names_support = 9;
  inline bool has_correlation_names_support() const;
  inline void clear_correlation_names_support();
  static const int kCorrelationNamesSupportFieldNumber = 9;
  inline ::exec::user::CorrelationNamesSupport correlation_names_support() const;
  inline void set_correlation_names_support(::exec::user::CorrelationNamesSupport value);

  // repeated string date_time_functions = 10;
  inline int date_time_functions_size() const;
  inline void clear_date_time_functions();
  static const int kDateTimeFunctionsFieldNumber = 10;
  inline const ::std::string& date_time_functions(int index) const;
  inline ::std::string* mutable_date_time_functions(int index);
  inline void set_date_time_functions(int index, const ::std::string& value);
  inline void set_date_time_functions(int index, const char* value);
  inline void set_date_time_functions(int index, const char* value, size_t size);
  inline ::std::string* add_date_time_functions();
  inline void add_date_time_functions(const ::std::string& value);
  inline void add_date_time_functions(const char* value);
  inline void add_date_time_functions(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& date_time_functions() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_date_time_functions();

  // repeated .exec.user.DateTimeLiteralsSupport date_time_literals_support = 11;
  inline int date_time_literals_support_size() const;
  inline void clear_date_time_literals_support();
  static const int kDateTimeLiteralsSupportFieldNumber = 11;
  inline ::exec::user::DateTimeLiteralsSupport date_time_literals_support(int index) const;
  inline void set_date_time_literals_support(int index, ::exec::user::DateTimeLiteralsSupport value);
  inline void add_date_time_literals_support(::exec::user::DateTimeLiteralsSupport value);
  inline const ::google::protobuf::RepeatedField<int>& date_time_literals_support() const;
  inline ::google::protobuf::RepeatedField<int>* mutable_date_time_literals_support();

  // optional .exec.user.GroupBySupport group_by_support = 12;
  inline bool has_group_by_support() const;
  inline void clear_group_by_support();
  static const int kGroupBySupportFieldNumber = 12;
  inline ::exec::user::GroupBySupport group_by_support() const;
  inline void set_group_by_support(::exec::user::GroupBySupport value);

  // optional .exec.user.IdentifierCasing identifier_casing = 13;
  inline bool has_identifier_casing() const;
  inline void clear_identifier_casing();
  static const int kIdentifierCasingFieldNumber = 13;
  inline ::exec::user::IdentifierCasing identifier_casing() const;
  inline void set_identifier_casing(::exec::user::IdentifierCasing value);

  // optional string identifier_quote_string = 14;
  inline bool has_identifier_quote_string() const;
  inline void clear_identifier_quote_string();
  static const int kIdentifierQuoteStringFieldNumber = 14;
  inline const ::std::string& identifier_quote_string() const;
  inline void set_identifier_quote_string(const ::std::string& value);
  inline void set_identifier_quote_string(const char* value);
  inline void set_identifier_quote_string(const char* value, size_t size);
  inline ::std::string* mutable_identifier_quote_string();
  inline ::std::string* release_identifier_quote_string();
  inline void set_allocated_identifier_quote_string(::std::string* identifier_quote_string);

  // optional bool like_escape_clause_supported = 15;
  inline bool has_like_escape_clause_supported() const;
  inline void clear_like_escape_clause_supported();
  static const int kLikeEscapeClauseSupportedFieldNumber = 15;
  inline bool like_escape_clause_supported() const;
  inline void set_like_escape_clause_supported(bool value);

  // optional uint32 max_binary_literal_length = 16;
  inline bool has_max_binary_literal_length() const;
  inline void clear_max_binary_literal_length();
  static const int kMaxBinaryLiteralLengthFieldNumber = 16;
  inline ::google::protobuf::uint32 max_binary_literal_length() const;
  inline void set_max_binary_literal_length(::google::protobuf::uint32 value);

  // optional uint32 max_catalog_name_length = 17;
  inline bool has_max_catalog_name_length() const;
  inline void clear_max_catalog_name_length();
  static const int kMaxCatalogNameLengthFieldNumber = 17;
  inline ::google::protobuf::uint32 max_catalog_name_length() const;
  inline void set_max_catalog_name_length(::google::protobuf::uint32 value);

  // optional uint32 max_char_literal_length = 18;
  inline bool has_max_char_literal_length() const;
  inline void clear_max_char_literal_length();
  static const int kMaxCharLiteralLengthFieldNumber = 18;
  inline ::google::protobuf::uint32 max_char_literal_length() const;
  inline void set_max_char_literal_length(::google::protobuf::uint32 value);

  // optional uint32 max_column_name_length = 19;
  inline bool has_max_column_name_length() const;
  inline void clear_max_column_name_length();
  static const int kMaxColumnNameLengthFieldNumber = 19;
  inline ::google::protobuf::uint32 max_column_name_length() const;
  inline void set_max_column_name_length(::google::protobuf::uint32 value);

  // optional uint32 max_columns_in_group_by = 20;
  inline bool has_max_columns_in_group_by() const;
  inline void clear_max_columns_in_group_by();
  static const int kMaxColumnsInGroupByFieldNumber = 20;
  inline ::google::protobuf::uint32 max_columns_in_group_by() const;
  inline void set_max_columns_in_group_by(::google::protobuf::uint32 value);

  // optional uint32 max_columns_in_order_by = 21;
  inline bool has_max_columns_in_order_by() const;
  inline void clear_max_columns_in_order_by();
  static const int kMaxColumnsInOrderByFieldNumber = 21;
  inline ::google::protobuf::uint32 max_columns_in_order_by() const;
  inline void set_max_columns_in_order_by(::google::protobuf::uint32 value);

  // optional uint32 max_columns_in_select = 22;
  inline bool has_max_columns_in_select() const;
  inline void clear_max_columns_in_select();
  static const int kMaxColumnsInSelectFieldNumber = 22;
  inline ::google::protobuf::uint32 max_columns_in_select() const;
  inline void set_max_columns_in_select(::google::protobuf::uint32 value);

  // optional uint32 max_cursor_name_length = 23;
  inline bool has_max_cursor_name_length() const;
  inline void clear_max_cursor_name_length();
  static const int kMaxCursorNameLengthFieldNumber = 23;
  inline ::google::protobuf::uint32 max_cursor_name_length() const;
  inline void set_max_cursor_name_length(::google::protobuf::uint32 value);

  // optional uint32 max_logical_lob_size = 24;
  inline bool has_max_logical_lob_size() const;
  inline void clear_max_logical_lob_size();
  static const int kMaxLogicalLobSizeFieldNumber = 24;
  inline ::google::protobuf::uint32 max_logical_lob_size() const;
  inline void set_max_logical_lob_size(::google::protobuf::uint32 value);

  // optional uint32 max_row_size = 25;
  inline bool has_max_row_size() const;
  inline void clear_max_row_size();
  static const int kMaxRowSizeFieldNumber = 25;
  inline ::google::protobuf::uint32 max_row_size() const;
  inline void set_max_row_size(::google::protobuf::uint32 value);

  // optional uint32 max_schema_name_length = 26;
  inline bool has_max_schema_name_length() const;
  inline void clear_max_schema_name_length();
  static const int kMaxSchemaNameLengthFieldNumber = 26;
  inline ::google::protobuf::uint32 max_schema_name_length() const;
  inline void set_max_schema_name_length(::google::protobuf::uint32 value);

  // optional uint32 max_statement_length = 27;
  inline bool has_max_statement_length() const;
  inline void clear_max_statement_length();
  static const int kMaxStatementLengthFieldNumber = 27;
  inline ::google::protobuf::uint32 max_statement_length() const;
  inline void set_max_statement_length(::google::protobuf::uint32 value);

  // optional uint32 max_statements = 28;
  inline bool has_max_statements() const;
  inline void clear_max_statements();
  static const int kMaxStatementsFieldNumber = 28;
  inline ::google::protobuf::uint32 max_statements() const;
  inline void set_max_statements(::google::protobuf::uint32 value);

  // optional uint32 max_table_name_length = 29;
  inline bool has_max_table_name_length() const;
  inline void clear_max_table_name_length();
  static const int kMaxTableNameLengthFieldNumber = 29;
  inline ::google::protobuf::uint32 max_table_name_length() const;
  inline void set_max_table_name_length(::google::protobuf::uint32 value);

  // optional uint32 max_tables_in_select = 30;
  inline bool has_max_tables_in_select() const;
  inline void clear_max_tables_in_select();
  static const int kMaxTablesInSelectFieldNumber = 30;
  inline ::google::protobuf::uint32 max_tables_in_select() const;
  inline void set_max_tables_in_select(::google::protobuf::uint32 value);

  // optional uint32 max_user_name_length = 31;
  inline bool has_max_user_name_length() const;
  inline void clear_max_user_name_length();
  static const int kMaxUserNameLengthFieldNumber = 31;
  inline ::google::protobuf::uint32 max_user_name_length() const;
  inline void set_max_user_name_length(::google::protobuf::uint32 value);

  // optional .exec.user.NullCollation null_collation = 32;
  inline bool has_null_collation() const;
  inline void clear_null_collation();
  static const int kNullCollationFieldNumber = 32;
  inline ::exec::user::NullCollation null_collation() const;
  inline void set_null_collation(::exec::user::NullCollation value);

  // optional bool null_plus_non_null_equals_null = 33;
  inline bool has_null_plus_non_null_equals_null() const;
  inline void clear_null_plus_non_null_equals_null();
  static const int kNullPlusNonNullEqualsNullFieldNumber = 33;
  inline bool null_plus_non_null_equals_null() const;
  inline void set_null_plus_non_null_equals_null(bool value);

  // repeated string numeric_functions = 34;
  inline int numeric_functions_size() const;
  inline void clear_numeric_functions();
  static const int kNumericFunctionsFieldNumber = 34;
  inline const ::std::string& numeric_functions(int index) const;
  inline ::std::string* mutable_numeric_functions(int index);
  inline void set_numeric_functions(int index, const ::std::string& value);
  inline void set_numeric_functions(int index, const char* value);
  inline void set_numeric_functions(int index, const char* value, size_t size);
  inline ::std::string* add_numeric_functions();
  inline void add_numeric_functions(const ::std::string& value);
  inline void add_numeric_functions(const char* value);
  inline void add_numeric_functions(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& numeric_functions() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_numeric_functions();

  // repeated .exec.user.OrderBySupport order_by_support = 35;
  inline int order_by_support_size() const;
  inline void clear_order_by_support();
  static const int kOrderBySupportFieldNumber = 35;
  inline ::exec::user::OrderBySupport order_by_support(int index) const;
  inline void set_order_by_support(int index, ::exec::user::OrderBySupport value);
  inline void add_order_by_support(::exec::user::OrderBySupport value);
  inline const ::google::protobuf::RepeatedField<int>& order_by_support() const;
  inline ::google::protobuf::RepeatedField<int>* mutable_order_by_support();

  // repeated .exec.user.OuterJoinSupport outer_join_support = 36;
  inline int outer_join_support_size() const;
  inline void clear_outer_join_support();
  static const int kOuterJoinSupportFieldNumber = 36;
  inline ::exec::user::OuterJoinSupport outer_join_support(int index) const;
  inline void set_outer_join_support(int index, ::exec::user::OuterJoinSupport value);
  inline void add_outer_join_support(::exec::user::OuterJoinSupport value);
  inline const ::google::protobuf::RepeatedField<int>& outer_join_support() const;
  inline ::google::protobuf::RepeatedField<int>* mutable_outer_join_support();

  // optional .exec.user.IdentifierCasing quoted_identifier_casing = 37;
  inline bool has_quoted_identifier_casing() const;
  inline void clear_quoted_identifier_casing();
  static const int kQuotedIdentifierCasingFieldNumber = 37;
  inline ::exec::user::IdentifierCasing quoted_identifier_casing() const;
  inline void set_quoted_identifier_casing(::exec::user::IdentifierCasing value);

  // optional bool read_only = 38;
  inline bool has_read_only() const;
  inline void clear_read_only();
  static const int kReadOnlyFieldNumber = 38;
  inline bool read_only() const;
  inline void set_read_only(bool value);

  // optional string schema_term = 39;
  inline bool has_schema_term() const;
  inline void clear_schema_term();
  static const int kSchemaTermFieldNumber = 39;
  inline const ::std::string& schema_term() const;
  inline void set_schema_term(const ::std::string& value);
  inline void set_schema_term(const char* value);
  inline void set_schema_term(const char* value, size_t size);
  inline ::std::string* mutable_schema_term();
  inline ::std::string* release_schema_term();
  inline void set_allocated_schema_term(::std::string* schema_term);

  // optional string search_escape_string = 40;
  inline bool has_search_escape_string() const;
  inline void clear_search_escape_string();
  static const int kSearchEscapeStringFieldNumber = 40;
  inline const ::std::string& search_escape_string() const;
  inline void set_search_escape_string(const ::std::string& value);
  inline void set_search_escape_string(const char* value);
  inline void set_search_escape_string(const char* value, size_t size);
  inline ::std::string* mutable_search_escape_string();
  inline ::std::string* release_search_escape_string();
  inline void set_allocated_search_escape_string(::std::string* search_escape_string);

  // optional bool select_for_update_supported = 41;
  inline bool has_select_for_update_supported() const;
  inline void clear_select_for_update_supported();
  static const int kSelectForUpdateSupportedFieldNumber = 41;
  inline bool select_for_update_supported() const;
  inline void set_select_for_update_supported(bool value);

  // optional string special_characters = 42;
  inline bool has_special_characters() const;
  inline void clear_special_characters();
  static const int kSpecialCharactersFieldNumber = 42;
  inline const ::std::string& special_characters() const;
  inline void set_special_characters(const ::std::string& value);
  inline void set_special_characters(const char* value);
  inline void set_special_characters(const char* value, size_t size);
  inline ::std::string* mutable_special_characters();
  inline ::std::string* release_special_characters();
  inline void set_allocated_special_characters(::std::string* special_characters);

  // repeated string sql_keywords = 43;
  inline int sql_keywords_size() const;
  inline void clear_sql_keywords();
  static const int kSqlKeywordsFieldNumber = 43;
  inline const ::std::string& sql_keywords(int index) const;
  inline ::std::string* mutable_sql_keywords(int index);
  inline void set_sql_keywords(int index, const ::std::string& value);
  inline void set_sql_keywords(int index, const char* value);
  inline void set_sql_keywords(int index, const char* value, size_t size);
  inline ::std::string* add_sql_keywords();
  inline void add_sql_keywords(const ::std::string& value);
  inline void add_sql_keywords(const char* value);
  inline void add_sql_keywords(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& sql_keywords() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_sql_keywords();

  // repeated string string_functions = 44;
  inline int string_functions_size() const;
  inline void clear_string_functions();
  static const int kStringFunctionsFieldNumber = 44;
  inline const ::std::string& string_functions(int index) const;
  inline ::std::string* mutable_string_functions(int index);
  inline void set_string_functions(int index, const ::std::string& value);
  inline void set_string_functions(int index, const char* value);
  inline void set_string_functions(int index, const char* value, size_t size);
  inline ::std::string* add_string_functions();
  inline void add_string_functions(const ::std::string& value);
  inline void add_string_functions(const char* value);
  inline void add_string_functions(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& string_functions() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_string_functions();

  // repeated .exec.user.SubQuerySupport subquery_support = 45;
  inline int subquery_support_size() const;
  inline void clear_subquery_support();
  static const int kSubquerySupportFieldNumber = 45;
  inline ::exec::user::SubQuerySupport subquery_support(int index) const;
  inline void set_subquery_support(int index, ::exec::user::SubQuerySupport value);
  inline void add_subquery_support(::exec::user::SubQuerySupport value);
  inline const ::google::protobuf::RepeatedField<int>& subquery_support() const;
  inline ::google::protobuf::RepeatedField<int>* mutable_subquery_support();

  // repeated string system_functions = 46;
  inline int system_functions_size() const;
  inline void clear_system_functions();
  static const int kSystemFunctionsFieldNumber = 46;
  inline const ::std::string& system_functions(int index) const;
  inline ::std::string* mutable_system_functions(int index);
  inline void set_system_functions(int index, const ::std::string& value);
  inline void set_system_functions(int index, const char* value);
  inline void set_system_functions(int index, const char* value, size_t size);
  inline ::std::string* add_system_functions();
  inline void add_system_functions(const ::std::string& value);
  inline void add_system_functions(const char* value);
  inline void add_system_functions(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& system_functions() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_system_functions();

  // optional string table_term = 47;
  inline bool has_table_term() const;
  inline void clear_table_term();
  static const int kTableTermFieldNumber = 47;
  inline const ::std::string& table_term() const;
  inline void set_table_term(const ::std::string& value);
  inline void set_table_term(const char* value);
  inline void set_table_term(const char* value, size_t size);
  inline ::std::string* mutable_table_term();
  inline ::std::string* release_table_term();
  inline void set_allocated_table_term(::std::string* table_term);

  // optional bool transaction_supported = 48;
  inline bool has_transaction_supported() const;
  inline void clear_transaction_supported();
  static const int kTransactionSupportedFieldNumber = 48;
  inline bool transaction_supported() const;
  inline void set_transaction_supported(bool value);

  // repeated .exec.user.UnionSupport union_support = 49;
  inline int union_support_size() const;
  inline void clear_union_support();
  static const int kUnionSupportFieldNumber = 49;
  inline ::exec::user::UnionSupport union_support(int index) const;
  inline void set_union_support(int index, ::exec::user::UnionSupport value);
  inline void add_union_support(::exec::user::UnionSupport value);
  inline const ::google::protobuf::RepeatedField<int>& union_support() const;
  inline ::google::protobuf::RepeatedField<int>* mutable_union_support();

  // @@protoc_insertion_point(class_scope:exec.user.ServerMeta)
 private:
  inline void set_has_all_tables_selectable();
  inline void clear_has_all_tables_selectable();
  inline void set_has_blob_included_in_max_row_size();
  inline void clear_has_blob_included_in_max_row_size();
  inline void set_has_catalog_at_start();
  inline void clear_has_catalog_at_start();
  inline void set_has_catalog_separator();
  inline void clear_has_catalog_separator();
  inline void set_has_catalog_term();
  inline void clear_has_catalog_term();
  inline void set_has_column_aliasing_supported();
  inline void clear_has_column_aliasing_supported();
  inline void set_has_correlation_names_support();
  inline void clear_has_correlation_names_support();
  inline void set_has_group_by_support();
  inline void clear_has_group_by_support();
  inline void set_has_identifier_casing();
  inline void clear_has_identifier_casing();
  inline void set_has_identifier_quote_string();
  inline void clear_has_identifier_quote_string();
  inline void set_has_like_escape_clause_supported();
  inline void clear_has_like_escape_clause_supported();
  inline void set_has_max_binary_literal_length();
  inline void clear_has_max_binary_literal_length();
  inline void set_has_max_catalog_name_length();
  inline void clear_has_max_catalog_name_length();
  inline void set_has_max_char_literal_length();
  inline void clear_has_max_char_literal_length();
  inline void set_has_max_column_name_length();
  inline void clear_has_max_column_name_length();
  inline void set_has_max_columns_in_group_by();
  inline void clear_has_max_columns_in_group_by();
  inline void set_has_max_columns_in_order_by();
  inline void clear_has_max_columns_in_order_by();
  inline void set_has_max_columns_in_select();
  inline void clear_has_max_columns_in_select();
  inline void set_has_max_cursor_name_length();
  inline void clear_has_max_cursor_name_length();
  inline void set_has_max_logical_lob_size();
  inline void clear_has_max_logical_lob_size();
  inline void set_has_max_row_size();
  inline void clear_has_max_row_size();
  inline void set_has_max_schema_name_length();
  inline void clear_has_max_schema_name_length();
  inline void set_has_max_statement_length();
  inline void clear_has_max_statement_length();
  inline void set_has_max_statements();
  inline void clear_has_max_statements();
  inline void set_has_max_table_name_length();
  inline void clear_has_max_table_name_length();
  inline void set_has_max_tables_in_select();
  inline void clear_has_max_tables_in_select();
  inline void set_has_max_user_name_length();
  inline void clear_has_max_user_name_length();
  inline void set_has_null_collation();
  inline void clear_has_null_collation();
  inline void set_has_null_plus_non_null_equals_null();
  inline void clear_has_null_plus_non_null_equals_null();
  inline void set_has_quoted_identifier_casing();
  inline void clear_has_quoted_identifier_casing();
  inline void set_has_read_only();
  inline void clear_has_read_only();
  inline void set_has_schema_term();
  inline void clear_has_schema_term();
  inline void set_has_search_escape_string();
  inline void clear_has_search_escape_string();
  inline void set_has_select_for_update_supported();
  inline void clear_has_select_for_update_supported();
  inline void set_has_special_characters();
  inline void clear_has_special_characters();
  inline void set_has_table_term();
  inline void clear_has_table_term();
  inline void set_has_transaction_supported();
  inline void clear_has_transaction_supported();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* catalog_separator_;
  bool all_tables_selectable_;
  bool blob_included_in_max_row_size_;
  bool catalog_at_start_;
  bool column_aliasing_supported_;
  int correlation_names_support_;
  ::std::string* catalog_term_;
  ::google::protobuf::RepeatedField<int> collate_support_;
  ::google::protobuf::RepeatedPtrField< ::exec::user::ConvertSupport > convert_support_;
  ::google::protobuf::RepeatedPtrField< ::std::string> date_time_functions_;
  ::google::protobuf::RepeatedField<int> date_time_literals_support_;
  int group_by_support_;
  int identifier_casing_;
  ::std::string* identifier_quote_string_;
  ::google::protobuf::uint32 max_binary_literal_length_;
  ::google::protobuf::uint32 max_catalog_name_length_;
  ::google::protobuf::uint32 max_char_literal_length_;
  ::google::protobuf::uint32 max_column_name_length_;
  ::google::protobuf::uint32 max_columns_in_group_by_;
  ::google::protobuf::uint32 max_columns_in_order_by_;
  ::google::protobuf::uint32 max_columns_in_select_;
  ::google::protobuf::uint32 max_cursor_name_length_;
  ::google::protobuf::uint32 max_logical_lob_size_;
  ::google::protobuf::uint32 max_row_size_;
  ::google::protobuf::uint32 max_schema_name_length_;
  ::google::protobuf::uint32 max_statement_length_;
  ::google::protobuf::uint32 max_statements_;
  ::google::protobuf::uint32 max_table_name_length_;
  ::google::protobuf::uint32 max_tables_in_select_;
  ::google::protobuf::uint32 max_user_name_length_;
  bool like_escape_clause_supported_;
  bool null_plus_non_null_equals_null_;
  bool read_only_;
  bool select_for_update_supported_;
  int null_collation_;
  ::google::protobuf::RepeatedPtrField< ::std::string> numeric_functions_;
  ::google::protobuf::RepeatedField<int> order_by_support_;
  ::google::protobuf::RepeatedField<int> outer_join_support_;
  ::std::string* schema_term_;
  ::std::string* search_escape_string_;
  ::std::string* special_characters_;
  int quoted_identifier_casing_;
  bool transaction_supported_;
  ::google::protobuf::RepeatedPtrField< ::std::string> sql_keywords_;
  ::google::protobuf::RepeatedPtrField< ::std::string> string_functions_;
  ::google::protobuf::RepeatedField<int> subquery_support_;
  ::google::protobuf::RepeatedPtrField< ::std::string> system_functions_;
  ::std::string* table_term_;
  ::google::protobuf::RepeatedField<int> union_support_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(49 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static ServerMeta* default_instance_;
};
// -------------------------------------------------------------------

class RunQuery : public ::google::protobuf::Message {
 public:
  RunQuery();
  virtual ~RunQuery();

  RunQuery(const RunQuery& from);

  inline RunQuery& operator=(const RunQuery& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const RunQuery& default_instance();

  void Swap(RunQuery* other);

  // implements Message ----------------------------------------------

  RunQuery* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const RunQuery& from);
  void MergeFrom(const RunQuery& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .exec.user.QueryResultsMode results_mode = 1;
  inline bool has_results_mode() const;
  inline void clear_results_mode();
  static const int kResultsModeFieldNumber = 1;
  inline ::exec::user::QueryResultsMode results_mode() const;
  inline void set_results_mode(::exec::user::QueryResultsMode value);

  // optional .exec.shared.QueryType type = 2;
  inline bool has_type() const;
  inline void clear_type();
  static const int kTypeFieldNumber = 2;
  inline ::exec::shared::QueryType type() const;
  inline void set_type(::exec::shared::QueryType value);

  // optional string plan = 3;
  inline bool has_plan() const;
  inline void clear_plan();
  static const int kPlanFieldNumber = 3;
  inline const ::std::string& plan() const;
  inline void set_plan(const ::std::string& value);
  inline void set_plan(const char* value);
  inline void set_plan(const char* value, size_t size);
  inline ::std::string* mutable_plan();
  inline ::std::string* release_plan();
  inline void set_allocated_plan(::std::string* plan);

  // repeated .exec.bit.control.PlanFragment fragments = 4;
  inline int fragments_size() const;
  inline void clear_fragments();
  static const int kFragmentsFieldNumber = 4;
  inline const ::exec::bit::control::PlanFragment& fragments(int index) const;
  inline ::exec::bit::control::PlanFragment* mutable_fragments(int index);
  inline ::exec::bit::control::PlanFragment* add_fragments();
  inline const ::google::protobuf::RepeatedPtrField< ::exec::bit::control::PlanFragment >&
      fragments() const;
  inline ::google::protobuf::RepeatedPtrField< ::exec::bit::control::PlanFragment >*
      mutable_fragments();

  // optional .exec.user.PreparedStatementHandle prepared_statement_handle = 5;
  inline bool has_prepared_statement_handle() const;
  inline void clear_prepared_statement_handle();
  static const int kPreparedStatementHandleFieldNumber = 5;
  inline const ::exec::user::PreparedStatementHandle& prepared_statement_handle() const;
  inline ::exec::user::PreparedStatementHandle* mutable_prepared_statement_handle();
  inline ::exec::user::PreparedStatementHandle* release_prepared_statement_handle();
  inline void set_allocated_prepared_statement_handle(::exec::user::PreparedStatementHandle* prepared_statement_handle);

  // @@protoc_insertion_point(class_scope:exec.user.RunQuery)
 private:
  inline void set_has_results_mode();
  inline void clear_has_results_mode();
  inline void set_has_type();
  inline void clear_has_type();
  inline void set_has_plan();
  inline void clear_has_plan();
  inline void set_has_prepared_statement_handle();
  inline void clear_has_prepared_statement_handle();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  int results_mode_;
  int type_;
  ::std::string* plan_;
  ::google::protobuf::RepeatedPtrField< ::exec::bit::control::PlanFragment > fragments_;
  ::exec::user::PreparedStatementHandle* prepared_statement_handle_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static RunQuery* default_instance_;
};
// ===================================================================


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

// Property

// required string key = 1;
inline bool Property::has_key() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Property::set_has_key() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Property::clear_has_key() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Property::clear_key() {
  if (key_ != &::google::protobuf::internal::kEmptyString) {
    key_->clear();
  }
  clear_has_key();
}
inline const ::std::string& Property::key() const {
  return *key_;
}
inline void Property::set_key(const ::std::string& value) {
  set_has_key();
  if (key_ == &::google::protobuf::internal::kEmptyString) {
    key_ = new ::std::string;
  }
  key_->assign(value);
}
inline void Property::set_key(const char* value) {
  set_has_key();
  if (key_ == &::google::protobuf::internal::kEmptyString) {
    key_ = new ::std::string;
  }
  key_->assign(value);
}
inline void Property::set_key(const char* value, size_t size) {
  set_has_key();
  if (key_ == &::google::protobuf::internal::kEmptyString) {
    key_ = new ::std::string;
  }
  key_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Property::mutable_key() {
  set_has_key();
  if (key_ == &::google::protobuf::internal::kEmptyString) {
    key_ = new ::std::string;
  }
  return key_;
}
inline ::std::string* Property::release_key() {
  clear_has_key();
  if (key_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = key_;
    key_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void Property::set_allocated_key(::std::string* key) {
  if (key_ != &::google::protobuf::internal::kEmptyString) {
    delete key_;
  }
  if (key) {
    set_has_key();
    key_ = key;
  } else {
    clear_has_key();
    key_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// required string value = 2;
inline bool Property::has_value() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Property::set_has_value() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Property::clear_has_value() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Property::clear_value() {
  if (value_ != &::google::protobuf::internal::kEmptyString) {
    value_->clear();
  }
  clear_has_value();
}
inline const ::std::string& Property::value() const {
  return *value_;
}
inline void Property::set_value(const ::std::string& value) {
  set_has_value();
  if (value_ == &::google::protobuf::internal::kEmptyString) {
    value_ = new ::std::string;
  }
  value_->assign(value);
}
inline void Property::set_value(const char* value) {
  set_has_value();
  if (value_ == &::google::protobuf::internal::kEmptyString) {
    value_ = new ::std::string;
  }
  value_->assign(value);
}
inline void Property::set_value(const char* value, size_t size) {
  set_has_value();
  if (value_ == &::google::protobuf::internal::kEmptyString) {
    value_ = new ::std::string;
  }
  value_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Property::mutable_value() {
  set_has_value();
  if (value_ == &::google::protobuf::internal::kEmptyString) {
    value_ = new ::std::string;
  }
  return value_;
}
inline ::std::string* Property::release_value() {
  clear_has_value();
  if (value_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = value_;
    value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void Property::set_allocated_value(::std::string* value) {
  if (value_ != &::google::protobuf::internal::kEmptyString) {
    delete value_;
  }
  if (value) {
    set_has_value();
    value_ = value;
  } else {
    clear_has_value();
    value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// -------------------------------------------------------------------

// UserProperties

// repeated .exec.user.Property properties = 1;
inline int UserProperties::properties_size() const {
  return properties_.size();
}
inline void UserProperties::clear_properties() {
  properties_.Clear();
}
inline const ::exec::user::Property& UserProperties::properties(int index) const {
  return properties_.Get(index);
}
inline ::exec::user::Property* UserProperties::mutable_properties(int index) {
  return properties_.Mutable(index);
}
inline ::exec::user::Property* UserProperties::add_properties() {
  return properties_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::exec::user::Property >&
UserProperties::properties() const {
  return properties_;
}
inline ::google::protobuf::RepeatedPtrField< ::exec::user::Property >*
UserProperties::mutable_properties() {
  return &properties_;
}

// -------------------------------------------------------------------

// RpcEndpointInfos

// optional string name = 1;
inline bool RpcEndpointInfos::has_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void RpcEndpointInfos::set_has_name() {
  _has_bits_[0] |= 0x00000001u;
}
inline void RpcEndpointInfos::clear_has_name() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void RpcEndpointInfos::clear_name() {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    name_->clear();
  }
  clear_has_name();
}
inline const ::std::string& RpcEndpointInfos::name() const {
  return *name_;
}
inline void RpcEndpointInfos::set_name(const ::std::string& value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void RpcEndpointInfos::set_name(const char* value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void RpcEndpointInfos::set_name(const char* value, size_t size) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* RpcEndpointInfos::mutable_name() {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  return name_;
}
inline ::std::string* RpcEndpointInfos::release_name() {
  clear_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = name_;
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void RpcEndpointInfos::set_allocated_name(::std::string* name) {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    delete name_;
  }
  if (name) {
    set_has_name();
    name_ = name;
  } else {
    clear_has_name();
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string version = 2;
inline bool RpcEndpointInfos::has_version() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void RpcEndpointInfos::set_has_version() {
  _has_bits_[0] |= 0x00000002u;
}
inline void RpcEndpointInfos::clear_has_version() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void RpcEndpointInfos::clear_version() {
  if (version_ != &::google::protobuf::internal::kEmptyString) {
    version_->clear();
  }
  clear_has_version();
}
inline const ::std::string& RpcEndpointInfos::version() const {
  return *version_;
}
inline void RpcEndpointInfos::set_version(const ::std::string& value) {
  set_has_version();
  if (version_ == &::google::protobuf::internal::kEmptyString) {
    version_ = new ::std::string;
  }
  version_->assign(value);
}
inline void RpcEndpointInfos::set_version(const char* value) {
  set_has_version();
  if (version_ == &::google::protobuf::internal::kEmptyString) {
    version_ = new ::std::string;
  }
  version_->assign(value);
}
inline void RpcEndpointInfos::set_version(const char* value, size_t size) {
  set_has_version();
  if (version_ == &::google::protobuf::internal::kEmptyString) {
    version_ = new ::std::string;
  }
  version_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* RpcEndpointInfos::mutable_version() {
  set_has_version();
  if (version_ == &::google::protobuf::internal::kEmptyString) {
    version_ = new ::std::string;
  }
  return version_;
}
inline ::std::string* RpcEndpointInfos::release_version() {
  clear_has_version();
  if (version_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = version_;
    version_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void RpcEndpointInfos::set_allocated_version(::std::string* version) {
  if (version_ != &::google::protobuf::internal::kEmptyString) {
    delete version_;
  }
  if (version) {
    set_has_version();
    version_ = version;
  } else {
    clear_has_version();
    version_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional uint32 majorVersion = 3;
inline bool RpcEndpointInfos::has_majorversion() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void RpcEndpointInfos::set_has_majorversion() {
  _has_bits_[0] |= 0x00000004u;
}
inline void RpcEndpointInfos::clear_has_majorversion() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void RpcEndpointInfos::clear_majorversion() {
  majorversion_ = 0u;
  clear_has_majorversion();
}
inline ::google::protobuf::uint32 RpcEndpointInfos::majorversion() const {
  return majorversion_;
}
inline void RpcEndpointInfos::set_majorversion(::google::protobuf::uint32 value) {
  set_has_majorversion();
  majorversion_ = value;
}

// optional uint32 minorVersion = 4;
inline bool RpcEndpointInfos::has_minorversion() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void RpcEndpointInfos::set_has_minorversion() {
  _has_bits_[0] |= 0x00000008u;
}
inline void RpcEndpointInfos::clear_has_minorversion() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void RpcEndpointInfos::clear_minorversion() {
  minorversion_ = 0u;
  clear_has_minorversion();
}
inline ::google::protobuf::uint32 RpcEndpointInfos::minorversion() const {
  return minorversion_;
}
inline void RpcEndpointInfos::set_minorversion(::google::protobuf::uint32 value) {
  set_has_minorversion();
  minorversion_ = value;
}

// optional uint32 patchVersion = 5;
inline bool RpcEndpointInfos::has_patchversion() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void RpcEndpointInfos::set_has_patchversion() {
  _has_bits_[0] |= 0x00000010u;
}
inline void RpcEndpointInfos::clear_has_patchversion() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void RpcEndpointInfos::clear_patchversion() {
  patchversion_ = 0u;
  clear_has_patchversion();
}
inline ::google::protobuf::uint32 RpcEndpointInfos::patchversion() const {
  return patchversion_;
}
inline void RpcEndpointInfos::set_patchversion(::google::protobuf::uint32 value) {
  set_has_patchversion();
  patchversion_ = value;
}

// optional string application = 6;
inline bool RpcEndpointInfos::has_application() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void RpcEndpointInfos::set_has_application() {
  _has_bits_[0] |= 0x00000020u;
}
inline void RpcEndpointInfos::clear_has_application() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void RpcEndpointInfos::clear_application() {
  if (application_ != &::google::protobuf::internal::kEmptyString) {
    application_->clear();
  }
  clear_has_application();
}
inline const ::std::string& RpcEndpointInfos::application() const {
  return *application_;
}
inline void RpcEndpointInfos::set_application(const ::std::string& value) {
  set_has_application();
  if (application_ == &::google::protobuf::internal::kEmptyString) {
    application_ = new ::std::string;
  }
  application_->assign(value);
}
inline void RpcEndpointInfos::set_application(const char* value) {
  set_has_application();
  if (application_ == &::google::protobuf::internal::kEmptyString) {
    application_ = new ::std::string;
  }
  application_->assign(value);
}
inline void RpcEndpointInfos::set_application(const char* value, size_t size) {
  set_has_application();
  if (application_ == &::google::protobuf::internal::kEmptyString) {
    application_ = new ::std::string;
  }
  application_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* RpcEndpointInfos::mutable_application() {
  set_has_application();
  if (application_ == &::google::protobuf::internal::kEmptyString) {
    application_ = new ::std::string;
  }
  return application_;
}
inline ::std::string* RpcEndpointInfos::release_application() {
  clear_has_application();
  if (application_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = application_;
    application_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void RpcEndpointInfos::set_allocated_application(::std::string* application) {
  if (application_ != &::google::protobuf::internal::kEmptyString) {
    delete application_;
  }
  if (application) {
    set_has_application();
    application_ = application;
  } else {
    clear_has_application();
    application_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional uint32 buildNumber = 7;
inline bool RpcEndpointInfos::has_buildnumber() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void RpcEndpointInfos::set_has_buildnumber() {
  _has_bits_[0] |= 0x00000040u;
}
inline void RpcEndpointInfos::clear_has_buildnumber() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void RpcEndpointInfos::clear_buildnumber() {
  buildnumber_ = 0u;
  clear_has_buildnumber();
}
inline ::google::protobuf::uint32 RpcEndpointInfos::buildnumber() const {
  return buildnumber_;
}
inline void RpcEndpointInfos::set_buildnumber(::google::protobuf::uint32 value) {
  set_has_buildnumber();
  buildnumber_ = value;
}

// optional string versionQualifier = 8;
inline bool RpcEndpointInfos::has_versionqualifier() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void RpcEndpointInfos::set_has_versionqualifier() {
  _has_bits_[0] |= 0x00000080u;
}
inline void RpcEndpointInfos::clear_has_versionqualifier() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void RpcEndpointInfos::clear_versionqualifier() {
  if (versionqualifier_ != &::google::protobuf::internal::kEmptyString) {
    versionqualifier_->clear();
  }
  clear_has_versionqualifier();
}
inline const ::std::string& RpcEndpointInfos::versionqualifier() const {
  return *versionqualifier_;
}
inline void RpcEndpointInfos::set_versionqualifier(const ::std::string& value) {
  set_has_versionqualifier();
  if (versionqualifier_ == &::google::protobuf::internal::kEmptyString) {
    versionqualifier_ = new ::std::string;
  }
  versionqualifier_->assign(value);
}
inline void RpcEndpointInfos::set_versionqualifier(const char* value) {
  set_has_versionqualifier();
  if (versionqualifier_ == &::google::protobuf::internal::kEmptyString) {
    versionqualifier_ = new ::std::string;
  }
  versionqualifier_->assign(value);
}
inline void RpcEndpointInfos::set_versionqualifier(const char* value, size_t size) {
  set_has_versionqualifier();
  if (versionqualifier_ == &::google::protobuf::internal::kEmptyString) {
    versionqualifier_ = new ::std::string;
  }
  versionqualifier_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* RpcEndpointInfos::mutable_versionqualifier() {
  set_has_versionqualifier();
  if (versionqualifier_ == &::google::protobuf::internal::kEmptyString) {
    versionqualifier_ = new ::std::string;
  }
  return versionqualifier_;
}
inline ::std::string* RpcEndpointInfos::release_versionqualifier() {
  clear_has_versionqualifier();
  if (versionqualifier_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = versionqualifier_;
    versionqualifier_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void RpcEndpointInfos::set_allocated_versionqualifier(::std::string* versionqualifier) {
  if (versionqualifier_ != &::google::protobuf::internal::kEmptyString) {
    delete versionqualifier_;
  }
  if (versionqualifier) {
    set_has_versionqualifier();
    versionqualifier_ = versionqualifier;
  } else {
    clear_has_versionqualifier();
    versionqualifier_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// -------------------------------------------------------------------

// UserToBitHandshake

// optional .exec.shared.RpcChannel channel = 1 [default = USER];
inline bool UserToBitHandshake::has_channel() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void UserToBitHandshake::set_has_channel() {
  _has_bits_[0] |= 0x00000001u;
}
inline void UserToBitHandshake::clear_has_channel() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void UserToBitHandshake::clear_channel() {
  channel_ = 2;
  clear_has_channel();
}
inline ::exec::shared::RpcChannel UserToBitHandshake::channel() const {
  return static_cast< ::exec::shared::RpcChannel >(channel_);
}
inline void UserToBitHandshake::set_channel(::exec::shared::RpcChannel value) {
  assert(::exec::shared::RpcChannel_IsValid(value));
  set_has_channel();
  channel_ = value;
}

// optional bool support_listening = 2;
inline bool UserToBitHandshake::has_support_listening() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void UserToBitHandshake::set_has_support_listening() {
  _has_bits_[0] |= 0x00000002u;
}
inline void UserToBitHandshake::clear_has_support_listening() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void UserToBitHandshake::clear_support_listening() {
  support_listening_ = false;
  clear_has_support_listening();
}
inline bool UserToBitHandshake::support_listening() const {
  return support_listening_;
}
inline void UserToBitHandshake::set_support_listening(bool value) {
  set_has_support_listening();
  support_listening_ = value;
}

// optional int32 rpc_version = 3;
inline bool UserToBitHandshake::has_rpc_version() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void UserToBitHandshake::set_has_rpc_version() {
  _has_bits_[0] |= 0x00000004u;
}
inline void UserToBitHandshake::clear_has_rpc_version() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void UserToBitHandshake::clear_rpc_version() {
  rpc_version_ = 0;
  clear_has_rpc_version();
}
inline ::google::protobuf::int32 UserToBitHandshake::rpc_version() const {
  return rpc_version_;
}
inline void UserToBitHandshake::set_rpc_version(::google::protobuf::int32 value) {
  set_has_rpc_version();
  rpc_version_ = value;
}

// optional .exec.shared.UserCredentials credentials = 4;
inline bool UserToBitHandshake::has_credentials() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void UserToBitHandshake::set_has_credentials() {
  _has_bits_[0] |= 0x00000008u;
}
inline void UserToBitHandshake::clear_has_credentials() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void UserToBitHandshake::clear_credentials() {
  if (credentials_ != NULL) credentials_->::exec::shared::UserCredentials::Clear();
  clear_has_credentials();
}
inline const ::exec::shared::UserCredentials& UserToBitHandshake::credentials() const {
  return credentials_ != NULL ? *credentials_ : *default_instance_->credentials_;
}
inline ::exec::shared::UserCredentials* UserToBitHandshake::mutable_credentials() {
  set_has_credentials();
  if (credentials_ == NULL) credentials_ = new ::exec::shared::UserCredentials;
  return credentials_;
}
inline ::exec::shared::UserCredentials* UserToBitHandshake::release_credentials() {
  clear_has_credentials();
  ::exec::shared::UserCredentials* temp = credentials_;
  credentials_ = NULL;
  return temp;
}
inline void UserToBitHandshake::set_allocated_credentials(::exec::shared::UserCredentials* credentials) {
  delete credentials_;
  credentials_ = credentials;
  if (credentials) {
    set_has_credentials();
  } else {
    clear_has_credentials();
  }
}

// optional .exec.user.UserProperties properties = 5;
inline bool UserToBitHandshake::has_properties() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void UserToBitHandshake::set_has_properties() {
  _has_bits_[0] |= 0x00000010u;
}
inline void UserToBitHandshake::clear_has_properties() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void UserToBitHandshake::clear_properties() {
  if (properties_ != NULL) properties_->::exec::user::UserProperties::Clear();
  clear_has_properties();
}
inline const ::exec::user::UserProperties& UserToBitHandshake::properties() const {
  return properties_ != NULL ? *properties_ : *default_instance_->properties_;
}
inline ::exec::user::UserProperties* UserToBitHandshake::mutable_properties() {
  set_has_properties();
  if (properties_ == NULL) properties_ = new ::exec::user::UserProperties;
  return properties_;
}
inline ::exec::user::UserProperties* UserToBitHandshake::release_properties() {
  clear_has_properties();
  ::exec::user::UserProperties* temp = properties_;
  properties_ = NULL;
  return temp;
}
inline void UserToBitHandshake::set_allocated_properties(::exec::user::UserProperties* properties) {
  delete properties_;
  properties_ = properties;
  if (properties) {
    set_has_properties();
  } else {
    clear_has_properties();
  }
}

// optional bool support_complex_types = 6 [default = false];
inline bool UserToBitHandshake::has_support_complex_types() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void UserToBitHandshake::set_has_support_complex_types() {
  _has_bits_[0] |= 0x00000020u;
}
inline void UserToBitHandshake::clear_has_support_complex_types() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void UserToBitHandshake::clear_support_complex_types() {
  support_complex_types_ = false;
  clear_has_support_complex_types();
}
inline bool UserToBitHandshake::support_complex_types() const {
  return support_complex_types_;
}
inline void UserToBitHandshake::set_support_complex_types(bool value) {
  set_has_support_complex_types();
  support_complex_types_ = value;
}

// optional bool support_timeout = 7 [default = false];
inline bool UserToBitHandshake::has_support_timeout() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void UserToBitHandshake::set_has_support_timeout() {
  _has_bits_[0] |= 0x00000040u;
}
inline void UserToBitHandshake::clear_has_support_timeout() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void UserToBitHandshake::clear_support_timeout() {
  support_timeout_ = false;
  clear_has_support_timeout();
}
inline bool UserToBitHandshake::support_timeout() const {
  return support_timeout_;
}
inline void UserToBitHandshake::set_support_timeout(bool value) {
  set_has_support_timeout();
  support_timeout_ = value;
}

// optional .exec.user.RpcEndpointInfos client_infos = 8;
inline bool UserToBitHandshake::has_client_infos() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void UserToBitHandshake::set_has_client_infos() {
  _has_bits_[0] |= 0x00000080u;
}
inline void UserToBitHandshake::clear_has_client_infos() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void UserToBitHandshake::clear_client_infos() {
  if (client_infos_ != NULL) client_infos_->::exec::user::RpcEndpointInfos::Clear();
  clear_has_client_infos();
}
inline const ::exec::user::RpcEndpointInfos& UserToBitHandshake::client_infos() const {
  return client_infos_ != NULL ? *client_infos_ : *default_instance_->client_infos_;
}
inline ::exec::user::RpcEndpointInfos* UserToBitHandshake::mutable_client_infos() {
  set_has_client_infos();
  if (client_infos_ == NULL) client_infos_ = new ::exec::user::RpcEndpointInfos;
  return client_infos_;
}
inline ::exec::user::RpcEndpointInfos* UserToBitHandshake::release_client_infos() {
  clear_has_client_infos();
  ::exec::user::RpcEndpointInfos* temp = client_infos_;
  client_infos_ = NULL;
  return temp;
}
inline void UserToBitHandshake::set_allocated_client_infos(::exec::user::RpcEndpointInfos* client_infos) {
  delete client_infos_;
  client_infos_ = client_infos;
  if (client_infos) {
    set_has_client_infos();
  } else {
    clear_has_client_infos();
  }
}

// optional .exec.user.SaslSupport sasl_support = 9;
inline bool UserToBitHandshake::has_sasl_support() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void UserToBitHandshake::set_has_sasl_support() {
  _has_bits_[0] |= 0x00000100u;
}
inline void UserToBitHandshake::clear_has_sasl_support() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void UserToBitHandshake::clear_sasl_support() {
  sasl_support_ = 0;
  clear_has_sasl_support();
}
inline ::exec::user::SaslSupport UserToBitHandshake::sasl_support() const {
  return static_cast< ::exec::user::SaslSupport >(sasl_support_);
}
inline void UserToBitHandshake::set_sasl_support(::exec::user::SaslSupport value) {
  assert(::exec::user::SaslSupport_IsValid(value));
  set_has_sasl_support();
  sasl_support_ = value;
}

// -------------------------------------------------------------------

// RequestResults

// optional .exec.shared.QueryId query_id = 1;
inline bool RequestResults::has_query_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void RequestResults::set_has_query_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void RequestResults::clear_has_query_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void RequestResults::clear_query_id() {
  if (query_id_ != NULL) query_id_->::exec::shared::QueryId::Clear();
  clear_has_query_id();
}
inline const ::exec::shared::QueryId& RequestResults::query_id() const {
  return query_id_ != NULL ? *query_id_ : *default_instance_->query_id_;
}
inline ::exec::shared::QueryId* RequestResults::mutable_query_id() {
  set_has_query_id();
  if (query_id_ == NULL) query_id_ = new ::exec::shared::QueryId;
  return query_id_;
}
inline ::exec::shared::QueryId* RequestResults::release_query_id() {
  clear_has_query_id();
  ::exec::shared::QueryId* temp = query_id_;
  query_id_ = NULL;
  return temp;
}
inline void RequestResults::set_allocated_query_id(::exec::shared::QueryId* query_id) {
  delete query_id_;
  query_id_ = query_id;
  if (query_id) {
    set_has_query_id();
  } else {
    clear_has_query_id();
  }
}

// optional int32 maximum_responses = 2;
inline bool RequestResults::has_maximum_responses() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void RequestResults::set_has_maximum_responses() {
  _has_bits_[0] |= 0x00000002u;
}
inline void RequestResults::clear_has_maximum_responses() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void RequestResults::clear_maximum_responses() {
  maximum_responses_ = 0;
  clear_has_maximum_responses();
}
inline ::google::protobuf::int32 RequestResults::maximum_responses() const {
  return maximum_responses_;
}
inline void RequestResults::set_maximum_responses(::google::protobuf::int32 value) {
  set_has_maximum_responses();
  maximum_responses_ = value;
}

// -------------------------------------------------------------------

// GetQueryPlanFragments

// required string query = 1;
inline bool GetQueryPlanFragments::has_query() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetQueryPlanFragments::set_has_query() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetQueryPlanFragments::clear_has_query() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetQueryPlanFragments::clear_query() {
  if (query_ != &::google::protobuf::internal::kEmptyString) {
    query_->clear();
  }
  clear_has_query();
}
inline const ::std::string& GetQueryPlanFragments::query() const {
  return *query_;
}
inline void GetQueryPlanFragments::set_query(const ::std::string& value) {
  set_has_query();
  if (query_ == &::google::protobuf::internal::kEmptyString) {
    query_ = new ::std::string;
  }
  query_->assign(value);
}
inline void GetQueryPlanFragments::set_query(const char* value) {
  set_has_query();
  if (query_ == &::google::protobuf::internal::kEmptyString) {
    query_ = new ::std::string;
  }
  query_->assign(value);
}
inline void GetQueryPlanFragments::set_query(const char* value, size_t size) {
  set_has_query();
  if (query_ == &::google::protobuf::internal::kEmptyString) {
    query_ = new ::std::string;
  }
  query_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* GetQueryPlanFragments::mutable_query() {
  set_has_query();
  if (query_ == &::google::protobuf::internal::kEmptyString) {
    query_ = new ::std::string;
  }
  return query_;
}
inline ::std::string* GetQueryPlanFragments::release_query() {
  clear_has_query();
  if (query_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = query_;
    query_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void GetQueryPlanFragments::set_allocated_query(::std::string* query) {
  if (query_ != &::google::protobuf::internal::kEmptyString) {
    delete query_;
  }
  if (query) {
    set_has_query();
    query_ = query;
  } else {
    clear_has_query();
    query_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional .exec.shared.QueryType type = 2;
inline bool GetQueryPlanFragments::has_type() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GetQueryPlanFragments::set_has_type() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GetQueryPlanFragments::clear_has_type() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GetQueryPlanFragments::clear_type() {
  type_ = 1;
  clear_has_type();
}
inline ::exec::shared::QueryType GetQueryPlanFragments::type() const {
  return static_cast< ::exec::shared::QueryType >(type_);
}
inline void GetQueryPlanFragments::set_type(::exec::shared::QueryType value) {
  assert(::exec::shared::QueryType_IsValid(value));
  set_has_type();
  type_ = value;
}

// optional bool split_plan = 3 [default = false];
inline bool GetQueryPlanFragments::has_split_plan() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void GetQueryPlanFragments::set_has_split_plan() {
  _has_bits_[0] |= 0x00000004u;
}
inline void GetQueryPlanFragments::clear_has_split_plan() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void GetQueryPlanFragments::clear_split_plan() {
  split_plan_ = false;
  clear_has_split_plan();
}
inline bool GetQueryPlanFragments::split_plan() const {
  return split_plan_;
}
inline void GetQueryPlanFragments::set_split_plan(bool value) {
  set_has_split_plan();
  split_plan_ = value;
}

// -------------------------------------------------------------------

// QueryPlanFragments

// required .exec.shared.QueryResult.QueryState status = 1;
inline bool QueryPlanFragments::has_status() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void QueryPlanFragments::set_has_status() {
  _has_bits_[0] |= 0x00000001u;
}
inline void QueryPlanFragments::clear_has_status() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void QueryPlanFragments::clear_status() {
  status_ = 0;
  clear_has_status();
}
inline ::exec::shared::QueryResult_QueryState QueryPlanFragments::status() const {
  return static_cast< ::exec::shared::QueryResult_QueryState >(status_);
}
inline void QueryPlanFragments::set_status(::exec::shared::QueryResult_QueryState value) {
  assert(::exec::shared::QueryResult_QueryState_IsValid(value));
  set_has_status();
  status_ = value;
}

// optional .exec.shared.QueryId query_id = 2;
inline bool QueryPlanFragments::has_query_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void QueryPlanFragments::set_has_query_id() {
  _has_bits_[0] |= 0x00000002u;
}
inline void QueryPlanFragments::clear_has_query_id() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void QueryPlanFragments::clear_query_id() {
  if (query_id_ != NULL) query_id_->::exec::shared::QueryId::Clear();
  clear_has_query_id();
}
inline const ::exec::shared::QueryId& QueryPlanFragments::query_id() const {
  return query_id_ != NULL ? *query_id_ : *default_instance_->query_id_;
}
inline ::exec::shared::QueryId* QueryPlanFragments::mutable_query_id() {
  set_has_query_id();
  if (query_id_ == NULL) query_id_ = new ::exec::shared::QueryId;
  return query_id_;
}
inline ::exec::shared::QueryId* QueryPlanFragments::release_query_id() {
  clear_has_query_id();
  ::exec::shared::QueryId* temp = query_id_;
  query_id_ = NULL;
  return temp;
}
inline void QueryPlanFragments::set_allocated_query_id(::exec::shared::QueryId* query_id) {
  delete query_id_;
  query_id_ = query_id;
  if (query_id) {
    set_has_query_id();
  } else {
    clear_has_query_id();
  }
}

// repeated .exec.bit.control.PlanFragment fragments = 3;
inline int QueryPlanFragments::fragments_size() const {
  return fragments_.size();
}
inline void QueryPlanFragments::clear_fragments() {
  fragments_.Clear();
}
inline const ::exec::bit::control::PlanFragment& QueryPlanFragments::fragments(int index) const {
  return fragments_.Get(index);
}
inline ::exec::bit::control::PlanFragment* QueryPlanFragments::mutable_fragments(int index) {
  return fragments_.Mutable(index);
}
inline ::exec::bit::control::PlanFragment* QueryPlanFragments::add_fragments() {
  return fragments_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::exec::bit::control::PlanFragment >&
QueryPlanFragments::fragments() const {
  return fragments_;
}
inline ::google::protobuf::RepeatedPtrField< ::exec::bit::control::PlanFragment >*
QueryPlanFragments::mutable_fragments() {
  return &fragments_;
}

// optional .exec.shared.DrillPBError error = 4;
inline bool QueryPlanFragments::has_error() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void QueryPlanFragments::set_has_error() {
  _has_bits_[0] |= 0x00000008u;
}
inline void QueryPlanFragments::clear_has_error() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void QueryPlanFragments::clear_error() {
  if (error_ != NULL) error_->::exec::shared::DrillPBError::Clear();
  clear_has_error();
}
inline const ::exec::shared::DrillPBError& QueryPlanFragments::error() const {
  return error_ != NULL ? *error_ : *default_instance_->error_;
}
inline ::exec::shared::DrillPBError* QueryPlanFragments::mutable_error() {
  set_has_error();
  if (error_ == NULL) error_ = new ::exec::shared::DrillPBError;
  return error_;
}
inline ::exec::shared::DrillPBError* QueryPlanFragments::release_error() {
  clear_has_error();
  ::exec::shared::DrillPBError* temp = error_;
  error_ = NULL;
  return temp;
}
inline void QueryPlanFragments::set_allocated_error(::exec::shared::DrillPBError* error) {
  delete error_;
  error_ = error;
  if (error) {
    set_has_error();
  } else {
    clear_has_error();
  }
}

// -------------------------------------------------------------------

// BitToUserHandshake

// optional int32 rpc_version = 2;
inline bool BitToUserHandshake::has_rpc_version() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void BitToUserHandshake::set_has_rpc_version() {
  _has_bits_[0] |= 0x00000001u;
}
inline void BitToUserHandshake::clear_has_rpc_version() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void BitToUserHandshake::clear_rpc_version() {
  rpc_version_ = 0;
  clear_has_rpc_version();
}
inline ::google::protobuf::int32 BitToUserHandshake::rpc_version() const {
  return rpc_version_;
}
inline void BitToUserHandshake::set_rpc_version(::google::protobuf::int32 value) {
  set_has_rpc_version();
  rpc_version_ = value;
}

// optional .exec.user.HandshakeStatus status = 3;
inline bool BitToUserHandshake::has_status() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void BitToUserHandshake::set_has_status() {
  _has_bits_[0] |= 0x00000002u;
}
inline void BitToUserHandshake::clear_has_status() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void BitToUserHandshake::clear_status() {
  status_ = 1;
  clear_has_status();
}
inline ::exec::user::HandshakeStatus BitToUserHandshake::status() const {
  return static_cast< ::exec::user::HandshakeStatus >(status_);
}
inline void BitToUserHandshake::set_status(::exec::user::HandshakeStatus value) {
  assert(::exec::user::HandshakeStatus_IsValid(value));
  set_has_status();
  status_ = value;
}

// optional string errorId = 4;
inline bool BitToUserHandshake::has_errorid() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void BitToUserHandshake::set_has_errorid() {
  _has_bits_[0] |= 0x00000004u;
}
inline void BitToUserHandshake::clear_has_errorid() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void BitToUserHandshake::clear_errorid() {
  if (errorid_ != &::google::protobuf::internal::kEmptyString) {
    errorid_->clear();
  }
  clear_has_errorid();
}
inline const ::std::string& BitToUserHandshake::errorid() const {
  return *errorid_;
}
inline void BitToUserHandshake::set_errorid(const ::std::string& value) {
  set_has_errorid();
  if (errorid_ == &::google::protobuf::internal::kEmptyString) {
    errorid_ = new ::std::string;
  }
  errorid_->assign(value);
}
inline void BitToUserHandshake::set_errorid(const char* value) {
  set_has_errorid();
  if (errorid_ == &::google::protobuf::internal::kEmptyString) {
    errorid_ = new ::std::string;
  }
  errorid_->assign(value);
}
inline void BitToUserHandshake::set_errorid(const char* value, size_t size) {
  set_has_errorid();
  if (errorid_ == &::google::protobuf::internal::kEmptyString) {
    errorid_ = new ::std::string;
  }
  errorid_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* BitToUserHandshake::mutable_errorid() {
  set_has_errorid();
  if (errorid_ == &::google::protobuf::internal::kEmptyString) {
    errorid_ = new ::std::string;
  }
  return errorid_;
}
inline ::std::string* BitToUserHandshake::release_errorid() {
  clear_has_errorid();
  if (errorid_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = errorid_;
    errorid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void BitToUserHandshake::set_allocated_errorid(::std::string* errorid) {
  if (errorid_ != &::google::protobuf::internal::kEmptyString) {
    delete errorid_;
  }
  if (errorid) {
    set_has_errorid();
    errorid_ = errorid;
  } else {
    clear_has_errorid();
    errorid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string errorMessage = 5;
inline bool BitToUserHandshake::has_errormessage() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void BitToUserHandshake::set_has_errormessage() {
  _has_bits_[0] |= 0x00000008u;
}
inline void BitToUserHandshake::clear_has_errormessage() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void BitToUserHandshake::clear_errormessage() {
  if (errormessage_ != &::google::protobuf::internal::kEmptyString) {
    errormessage_->clear();
  }
  clear_has_errormessage();
}
inline const ::std::string& BitToUserHandshake::errormessage() const {
  return *errormessage_;
}
inline void BitToUserHandshake::set_errormessage(const ::std::string& value) {
  set_has_errormessage();
  if (errormessage_ == &::google::protobuf::internal::kEmptyString) {
    errormessage_ = new ::std::string;
  }
  errormessage_->assign(value);
}
inline void BitToUserHandshake::set_errormessage(const char* value) {
  set_has_errormessage();
  if (errormessage_ == &::google::protobuf::internal::kEmptyString) {
    errormessage_ = new ::std::string;
  }
  errormessage_->assign(value);
}
inline void BitToUserHandshake::set_errormessage(const char* value, size_t size) {
  set_has_errormessage();
  if (errormessage_ == &::google::protobuf::internal::kEmptyString) {
    errormessage_ = new ::std::string;
  }
  errormessage_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* BitToUserHandshake::mutable_errormessage() {
  set_has_errormessage();
  if (errormessage_ == &::google::protobuf::internal::kEmptyString) {
    errormessage_ = new ::std::string;
  }
  return errormessage_;
}
inline ::std::string* BitToUserHandshake::release_errormessage() {
  clear_has_errormessage();
  if (errormessage_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = errormessage_;
    errormessage_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void BitToUserHandshake::set_allocated_errormessage(::std::string* errormessage) {
  if (errormessage_ != &::google::protobuf::internal::kEmptyString) {
    delete errormessage_;
  }
  if (errormessage) {
    set_has_errormessage();
    errormessage_ = errormessage;
  } else {
    clear_has_errormessage();
    errormessage_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional .exec.user.RpcEndpointInfos server_infos = 6;
inline bool BitToUserHandshake::has_server_infos() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void BitToUserHandshake::set_has_server_infos() {
  _has_bits_[0] |= 0x00000010u;
}
inline void BitToUserHandshake::clear_has_server_infos() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void BitToUserHandshake::clear_server_infos() {
  if (server_infos_ != NULL) server_infos_->::exec::user::RpcEndpointInfos::Clear();
  clear_has_server_infos();
}
inline const ::exec::user::RpcEndpointInfos& BitToUserHandshake::server_infos() const {
  return server_infos_ != NULL ? *server_infos_ : *default_instance_->server_infos_;
}
inline ::exec::user::RpcEndpointInfos* BitToUserHandshake::mutable_server_infos() {
  set_has_server_infos();
  if (server_infos_ == NULL) server_infos_ = new ::exec::user::RpcEndpointInfos;
  return server_infos_;
}
inline ::exec::user::RpcEndpointInfos* BitToUserHandshake::release_server_infos() {
  clear_has_server_infos();
  ::exec::user::RpcEndpointInfos* temp = server_infos_;
  server_infos_ = NULL;
  return temp;
}
inline void BitToUserHandshake::set_allocated_server_infos(::exec::user::RpcEndpointInfos* server_infos) {
  delete server_infos_;
  server_infos_ = server_infos;
  if (server_infos) {
    set_has_server_infos();
  } else {
    clear_has_server_infos();
  }
}

// repeated string authenticationMechanisms = 7;
inline int BitToUserHandshake::authenticationmechanisms_size() const {
  return authenticationmechanisms_.size();
}
inline void BitToUserHandshake::clear_authenticationmechanisms() {
  authenticationmechanisms_.Clear();
}
inline const ::std::string& BitToUserHandshake::authenticationmechanisms(int index) const {
  return authenticationmechanisms_.Get(index);
}
inline ::std::string* BitToUserHandshake::mutable_authenticationmechanisms(int index) {
  return authenticationmechanisms_.Mutable(index);
}
inline void BitToUserHandshake::set_authenticationmechanisms(int index, const ::std::string& value) {
  authenticationmechanisms_.Mutable(index)->assign(value);
}
inline void BitToUserHandshake::set_authenticationmechanisms(int index, const char* value) {
  authenticationmechanisms_.Mutable(index)->assign(value);
}
inline void BitToUserHandshake::set_authenticationmechanisms(int index, const char* value, size_t size) {
  authenticationmechanisms_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* BitToUserHandshake::add_authenticationmechanisms() {
  return authenticationmechanisms_.Add();
}
inline void BitToUserHandshake::add_authenticationmechanisms(const ::std::string& value) {
  authenticationmechanisms_.Add()->assign(value);
}
inline void BitToUserHandshake::add_authenticationmechanisms(const char* value) {
  authenticationmechanisms_.Add()->assign(value);
}
inline void BitToUserHandshake::add_authenticationmechanisms(const char* value, size_t size) {
  authenticationmechanisms_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
BitToUserHandshake::authenticationmechanisms() const {
  return authenticationmechanisms_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
BitToUserHandshake::mutable_authenticationmechanisms() {
  return &authenticationmechanisms_;
}

// repeated .exec.user.RpcType supported_methods = 8;
inline int BitToUserHandshake::supported_methods_size() const {
  return supported_methods_.size();
}
inline void BitToUserHandshake::clear_supported_methods() {
  supported_methods_.Clear();
}
inline ::exec::user::RpcType BitToUserHandshake::supported_methods(int index) const {
  return static_cast< ::exec::user::RpcType >(supported_methods_.Get(index));
}
inline void BitToUserHandshake::set_supported_methods(int index, ::exec::user::RpcType value) {
  assert(::exec::user::RpcType_IsValid(value));
  supported_methods_.Set(index, value);
}
inline void BitToUserHandshake::add_supported_methods(::exec::user::RpcType value) {
  assert(::exec::user::RpcType_IsValid(value));
  supported_methods_.Add(value);
}
inline const ::google::protobuf::RepeatedField<int>&
BitToUserHandshake::supported_methods() const {
  return supported_methods_;
}
inline ::google::protobuf::RepeatedField<int>*
BitToUserHandshake::mutable_supported_methods() {
  return &supported_methods_;
}

// optional bool encrypted = 9;
inline bool BitToUserHandshake::has_encrypted() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void BitToUserHandshake::set_has_encrypted() {
  _has_bits_[0] |= 0x00000080u;
}
inline void BitToUserHandshake::clear_has_encrypted() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void BitToUserHandshake::clear_encrypted() {
  encrypted_ = false;
  clear_has_encrypted();
}
inline bool BitToUserHandshake::encrypted() const {
  return encrypted_;
}
inline void BitToUserHandshake::set_encrypted(bool value) {
  set_has_encrypted();
  encrypted_ = value;
}

// optional int32 maxWrappedSize = 10;
inline bool BitToUserHandshake::has_maxwrappedsize() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void BitToUserHandshake::set_has_maxwrappedsize() {
  _has_bits_[0] |= 0x00000100u;
}
inline void BitToUserHandshake::clear_has_maxwrappedsize() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void BitToUserHandshake::clear_maxwrappedsize() {
  maxwrappedsize_ = 0;
  clear_has_maxwrappedsize();
}
inline ::google::protobuf::int32 BitToUserHandshake::maxwrappedsize() const {
  return maxwrappedsize_;
}
inline void BitToUserHandshake::set_maxwrappedsize(::google::protobuf::int32 value) {
  set_has_maxwrappedsize();
  maxwrappedsize_ = value;
}

// -------------------------------------------------------------------

// LikeFilter

// optional string pattern = 1;
inline bool LikeFilter::has_pattern() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void LikeFilter::set_has_pattern() {
  _has_bits_[0] |= 0x00000001u;
}
inline void LikeFilter::clear_has_pattern() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void LikeFilter::clear_pattern() {
  if (pattern_ != &::google::protobuf::internal::kEmptyString) {
    pattern_->clear();
  }
  clear_has_pattern();
}
inline const ::std::string& LikeFilter::pattern() const {
  return *pattern_;
}
inline void LikeFilter::set_pattern(const ::std::string& value) {
  set_has_pattern();
  if (pattern_ == &::google::protobuf::internal::kEmptyString) {
    pattern_ = new ::std::string;
  }
  pattern_->assign(value);
}
inline void LikeFilter::set_pattern(const char* value) {
  set_has_pattern();
  if (pattern_ == &::google::protobuf::internal::kEmptyString) {
    pattern_ = new ::std::string;
  }
  pattern_->assign(value);
}
inline void LikeFilter::set_pattern(const char* value, size_t size) {
  set_has_pattern();
  if (pattern_ == &::google::protobuf::internal::kEmptyString) {
    pattern_ = new ::std::string;
  }
  pattern_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* LikeFilter::mutable_pattern() {
  set_has_pattern();
  if (pattern_ == &::google::protobuf::internal::kEmptyString) {
    pattern_ = new ::std::string;
  }
  return pattern_;
}
inline ::std::string* LikeFilter::release_pattern() {
  clear_has_pattern();
  if (pattern_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = pattern_;
    pattern_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void LikeFilter::set_allocated_pattern(::std::string* pattern) {
  if (pattern_ != &::google::protobuf::internal::kEmptyString) {
    delete pattern_;
  }
  if (pattern) {
    set_has_pattern();
    pattern_ = pattern;
  } else {
    clear_has_pattern();
    pattern_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string escape = 2;
inline bool LikeFilter::has_escape() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void LikeFilter::set_has_escape() {
  _has_bits_[0] |= 0x00000002u;
}
inline void LikeFilter::clear_has_escape() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void LikeFilter::clear_escape() {
  if (escape_ != &::google::protobuf::internal::kEmptyString) {
    escape_->clear();
  }
  clear_has_escape();
}
inline const ::std::string& LikeFilter::escape() const {
  return *escape_;
}
inline void LikeFilter::set_escape(const ::std::string& value) {
  set_has_escape();
  if (escape_ == &::google::protobuf::internal::kEmptyString) {
    escape_ = new ::std::string;
  }
  escape_->assign(value);
}
inline void LikeFilter::set_escape(const char* value) {
  set_has_escape();
  if (escape_ == &::google::protobuf::internal::kEmptyString) {
    escape_ = new ::std::string;
  }
  escape_->assign(value);
}
inline void LikeFilter::set_escape(const char* value, size_t size) {
  set_has_escape();
  if (escape_ == &::google::protobuf::internal::kEmptyString) {
    escape_ = new ::std::string;
  }
  escape_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* LikeFilter::mutable_escape() {
  set_has_escape();
  if (escape_ == &::google::protobuf::internal::kEmptyString) {
    escape_ = new ::std::string;
  }
  return escape_;
}
inline ::std::string* LikeFilter::release_escape() {
  clear_has_escape();
  if (escape_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = escape_;
    escape_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void LikeFilter::set_allocated_escape(::std::string* escape) {
  if (escape_ != &::google::protobuf::internal::kEmptyString) {
    delete escape_;
  }
  if (escape) {
    set_has_escape();
    escape_ = escape;
  } else {
    clear_has_escape();
    escape_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// -------------------------------------------------------------------

// GetCatalogsReq

// optional .exec.user.LikeFilter catalog_name_filter = 1;
inline bool GetCatalogsReq::has_catalog_name_filter() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetCatalogsReq::set_has_catalog_name_filter() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetCatalogsReq::clear_has_catalog_name_filter() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetCatalogsReq::clear_catalog_name_filter() {
  if (catalog_name_filter_ != NULL) catalog_name_filter_->::exec::user::LikeFilter::Clear();
  clear_has_catalog_name_filter();
}
inline const ::exec::user::LikeFilter& GetCatalogsReq::catalog_name_filter() const {
  return catalog_name_filter_ != NULL ? *catalog_name_filter_ : *default_instance_->catalog_name_filter_;
}
inline ::exec::user::LikeFilter* GetCatalogsReq::mutable_catalog_name_filter() {
  set_has_catalog_name_filter();
  if (catalog_name_filter_ == NULL) catalog_name_filter_ = new ::exec::user::LikeFilter;
  return catalog_name_filter_;
}
inline ::exec::user::LikeFilter* GetCatalogsReq::release_catalog_name_filter() {
  clear_has_catalog_name_filter();
  ::exec::user::LikeFilter* temp = catalog_name_filter_;
  catalog_name_filter_ = NULL;
  return temp;
}
inline void GetCatalogsReq::set_allocated_catalog_name_filter(::exec::user::LikeFilter* catalog_name_filter) {
  delete catalog_name_filter_;
  catalog_name_filter_ = catalog_name_filter;
  if (catalog_name_filter) {
    set_has_catalog_name_filter();
  } else {
    clear_has_catalog_name_filter();
  }
}

// -------------------------------------------------------------------

// CatalogMetadata

// optional string catalog_name = 1;
inline bool CatalogMetadata::has_catalog_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CatalogMetadata::set_has_catalog_name() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CatalogMetadata::clear_has_catalog_name() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CatalogMetadata::clear_catalog_name() {
  if (catalog_name_ != &::google::protobuf::internal::kEmptyString) {
    catalog_name_->clear();
  }
  clear_has_catalog_name();
}
inline const ::std::string& CatalogMetadata::catalog_name() const {
  return *catalog_name_;
}
inline void CatalogMetadata::set_catalog_name(const ::std::string& value) {
  set_has_catalog_name();
  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
    catalog_name_ = new ::std::string;
  }
  catalog_name_->assign(value);
}
inline void CatalogMetadata::set_catalog_name(const char* value) {
  set_has_catalog_name();
  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
    catalog_name_ = new ::std::string;
  }
  catalog_name_->assign(value);
}
inline void CatalogMetadata::set_catalog_name(const char* value, size_t size) {
  set_has_catalog_name();
  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
    catalog_name_ = new ::std::string;
  }
  catalog_name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CatalogMetadata::mutable_catalog_name() {
  set_has_catalog_name();
  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
    catalog_name_ = new ::std::string;
  }
  return catalog_name_;
}
inline ::std::string* CatalogMetadata::release_catalog_name() {
  clear_has_catalog_name();
  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = catalog_name_;
    catalog_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void CatalogMetadata::set_allocated_catalog_name(::std::string* catalog_name) {
  if (catalog_name_ != &::google::protobuf::internal::kEmptyString) {
    delete catalog_name_;
  }
  if (catalog_name) {
    set_has_catalog_name();
    catalog_name_ = catalog_name;
  } else {
    clear_has_catalog_name();
    catalog_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string description = 2;
inline bool CatalogMetadata::has_description() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CatalogMetadata::set_has_description() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CatalogMetadata::clear_has_description() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CatalogMetadata::clear_description() {
  if (description_ != &::google::protobuf::internal::kEmptyString) {
    description_->clear();
  }
  clear_has_description();
}
inline const ::std::string& CatalogMetadata::description() const {
  return *description_;
}
inline void CatalogMetadata::set_description(const ::std::string& value) {
  set_has_description();
  if (description_ == &::google::protobuf::internal::kEmptyString) {
    description_ = new ::std::string;
  }
  description_->assign(value);
}
inline void CatalogMetadata::set_description(const char* value) {
  set_has_description();
  if (description_ == &::google::protobuf::internal::kEmptyString) {
    description_ = new ::std::string;
  }
  description_->assign(value);
}
inline void CatalogMetadata::set_description(const char* value, size_t size) {
  set_has_description();
  if (description_ == &::google::protobuf::internal::kEmptyString) {
    description_ = new ::std::string;
  }
  description_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CatalogMetadata::mutable_description() {
  set_has_description();
  if (description_ == &::google::protobuf::internal::kEmptyString) {
    description_ = new ::std::string;
  }
  return description_;
}
inline ::std::string* CatalogMetadata::release_description() {
  clear_has_description();
  if (description_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = description_;
    description_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void CatalogMetadata::set_allocated_description(::std::string* description) {
  if (description_ != &::google::protobuf::internal::kEmptyString) {
    delete description_;
  }
  if (description) {
    set_has_description();
    description_ = description;
  } else {
    clear_has_description();
    description_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string connect = 3;
inline bool CatalogMetadata::has_connect() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void CatalogMetadata::set_has_connect() {
  _has_bits_[0] |= 0x00000004u;
}
inline void CatalogMetadata::clear_has_connect() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void CatalogMetadata::clear_connect() {
  if (connect_ != &::google::protobuf::internal::kEmptyString) {
    connect_->clear();
  }
  clear_has_connect();
}
inline const ::std::string& CatalogMetadata::connect() const {
  return *connect_;
}
inline void CatalogMetadata::set_connect(const ::std::string& value) {
  set_has_connect();
  if (connect_ == &::google::protobuf::internal::kEmptyString) {
    connect_ = new ::std::string;
  }
  connect_->assign(value);
}
inline void CatalogMetadata::set_connect(const char* value) {
  set_has_connect();
  if (connect_ == &::google::protobuf::internal::kEmptyString) {
    connect_ = new ::std::string;
  }
  connect_->assign(value);
}
inline void CatalogMetadata::set_connect(const char* value, size_t size) {
  set_has_connect();
  if (connect_ == &::google::protobuf::internal::kEmptyString) {
    connect_ = new ::std::string;
  }
  connect_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CatalogMetadata::mutable_connect() {
  set_has_connect();
  if (connect_ == &::google::protobuf::internal::kEmptyString) {
    connect_ = new ::std::string;
  }
  return connect_;
}
inline ::std::string* CatalogMetadata::release_connect() {
  clear_has_connect();
  if (connect_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = connect_;
    connect_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void CatalogMetadata::set_allocated_connect(::std::string* connect) {
  if (connect_ != &::google::protobuf::internal::kEmptyString) {
    delete connect_;
  }
  if (connect) {
    set_has_connect();
    connect_ = connect;
  } else {
    clear_has_connect();
    connect_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// -------------------------------------------------------------------

// GetCatalogsResp

// optional .exec.user.RequestStatus status = 1;
inline bool GetCatalogsResp::has_status() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetCatalogsResp::set_has_status() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetCatalogsResp::clear_has_status() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetCatalogsResp::clear_status() {
  status_ = 0;
  clear_has_status();
}
inline ::exec::user::RequestStatus GetCatalogsResp::status() const {
  return static_cast< ::exec::user::RequestStatus >(status_);
}
inline void GetCatalogsResp::set_status(::exec::user::RequestStatus value) {
  assert(::exec::user::RequestStatus_IsValid(value));
  set_has_status();
  status_ = value;
}

// repeated .exec.user.CatalogMetadata catalogs = 2;
inline int GetCatalogsResp::catalogs_size() const {
  return catalogs_.size();
}
inline void GetCatalogsResp::clear_catalogs() {
  catalogs_.Clear();
}
inline const ::exec::user::CatalogMetadata& GetCatalogsResp::catalogs(int index) const {
  return catalogs_.Get(index);
}
inline ::exec::user::CatalogMetadata* GetCatalogsResp::mutable_catalogs(int index) {
  return catalogs_.Mutable(index);
}
inline ::exec::user::CatalogMetadata* GetCatalogsResp::add_catalogs() {
  return catalogs_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::exec::user::CatalogMetadata >&
GetCatalogsResp::catalogs() const {
  return catalogs_;
}
inline ::google::protobuf::RepeatedPtrField< ::exec::user::CatalogMetadata >*
GetCatalogsResp::mutable_catalogs() {
  return &catalogs_;
}

// optional .exec.shared.DrillPBError error = 3;
inline bool GetCatalogsResp::has_error() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void GetCatalogsResp::set_has_error() {
  _has_bits_[0] |= 0x00000004u;
}
inline void GetCatalogsResp::clear_has_error() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void GetCatalogsResp::clear_error() {
  if (error_ != NULL) error_->::exec::shared::DrillPBError::Clear();
  clear_has_error();
}
inline const ::exec::shared::DrillPBError& GetCatalogsResp::error() const {
  return error_ != NULL ? *error_ : *default_instance_->error_;
}
inline ::exec::shared::DrillPBError* GetCatalogsResp::mutable_error() {
  set_has_error();
  if (error_ == NULL) error_ = new ::exec::shared::DrillPBError;
  return error_;
}
inline ::exec::shared::DrillPBError* GetCatalogsResp::release_error() {
  clear_has_error();
  ::exec::shared::DrillPBError* temp = error_;
  error_ = NULL;
  return temp;
}
inline void GetCatalogsResp::set_allocated_error(::exec::shared::DrillPBError* error) {
  delete error_;
  error_ = error;
  if (error) {
    set_has_error();
  } else {
    clear_has_error();
  }
}

// -------------------------------------------------------------------

// GetSchemasReq

// optional .exec.user.LikeFilter catalog_name_filter = 1;
inline bool GetSchemasReq::has_catalog_name_filter() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetSchemasReq::set_has_catalog_name_filter() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetSchemasReq::clear_has_catalog_name_filter() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetSchemasReq::clear_catalog_name_filter() {
  if (catalog_name_filter_ != NULL) catalog_name_filter_->::exec::user::LikeFilter::Clear();
  clear_has_catalog_name_filter();
}
inline const ::exec::user::LikeFilter& GetSchemasReq::catalog_name_filter() const {
  return catalog_name_filter_ != NULL ? *catalog_name_filter_ : *default_instance_->catalog_name_filter_;
}
inline ::exec::user::LikeFilter* GetSchemasReq::mutable_catalog_name_filter() {
  set_has_catalog_name_filter();
  if (catalog_name_filter_ == NULL) catalog_name_filter_ = new ::exec::user::LikeFilter;
  return catalog_name_filter_;
}
inline ::exec::user::LikeFilter* GetSchemasReq::release_catalog_name_filter() {
  clear_has_catalog_name_filter();
  ::exec::user::LikeFilter* temp = catalog_name_filter_;
  catalog_name_filter_ = NULL;
  return temp;
}
inline void GetSchemasReq::set_allocated_catalog_name_filter(::exec::user::LikeFilter* catalog_name_filter) {
  delete catalog_name_filter_;
  catalog_name_filter_ = catalog_name_filter;
  if (catalog_name_filter) {
    set_has_catalog_name_filter();
  } else {
    clear_has_catalog_name_filter();
  }
}

// optional .exec.user.LikeFilter schema_name_filter = 2;
inline bool GetSchemasReq::has_schema_name_filter() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GetSchemasReq::set_has_schema_name_filter() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GetSchemasReq::clear_has_schema_name_filter() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GetSchemasReq::clear_schema_name_filter() {
  if (schema_name_filter_ != NULL) schema_name_filter_->::exec::user::LikeFilter::Clear();
  clear_has_schema_name_filter();
}
inline const ::exec::user::LikeFilter& GetSchemasReq::schema_name_filter() const {
  return schema_name_filter_ != NULL ? *schema_name_filter_ : *default_instance_->schema_name_filter_;
}
inline ::exec::user::LikeFilter* GetSchemasReq::mutable_schema_name_filter() {
  set_has_schema_name_filter();
  if (schema_name_filter_ == NULL) schema_name_filter_ = new ::exec::user::LikeFilter;
  return schema_name_filter_;
}
inline ::exec::user::LikeFilter* GetSchemasReq::release_schema_name_filter() {
  clear_has_schema_name_filter();
  ::exec::user::LikeFilter* temp = schema_name_filter_;
  schema_name_filter_ = NULL;
  return temp;
}
inline void GetSchemasReq::set_allocated_schema_name_filter(::exec::user::LikeFilter* schema_name_filter) {
  delete schema_name_filter_;
  schema_name_filter_ = schema_name_filter;
  if (schema_name_filter) {
    set_has_schema_name_filter();
  } else {
    clear_has_schema_name_filter();
  }
}

// -------------------------------------------------------------------

// SchemaMetadata

// optional string catalog_name = 1;
inline bool SchemaMetadata::has_catalog_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SchemaMetadata::set_has_catalog_name() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SchemaMetadata::clear_has_catalog_name() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SchemaMetadata::clear_catalog_name() {
  if (catalog_name_ != &::google::protobuf::internal::kEmptyString) {
    catalog_name_->clear();
  }
  clear_has_catalog_name();
}
inline const ::std::string& SchemaMetadata::catalog_name() const {
  return *catalog_name_;
}
inline void SchemaMetadata::set_catalog_name(const ::std::string& value) {
  set_has_catalog_name();
  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
    catalog_name_ = new ::std::string;
  }
  catalog_name_->assign(value);
}
inline void SchemaMetadata::set_catalog_name(const char* value) {
  set_has_catalog_name();
  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
    catalog_name_ = new ::std::string;
  }
  catalog_name_->assign(value);
}
inline void SchemaMetadata::set_catalog_name(const char* value, size_t size) {
  set_has_catalog_name();
  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
    catalog_name_ = new ::std::string;
  }
  catalog_name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* SchemaMetadata::mutable_catalog_name() {
  set_has_catalog_name();
  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
    catalog_name_ = new ::std::string;
  }
  return catalog_name_;
}
inline ::std::string* SchemaMetadata::release_catalog_name() {
  clear_has_catalog_name();
  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = catalog_name_;
    catalog_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void SchemaMetadata::set_allocated_catalog_name(::std::string* catalog_name) {
  if (catalog_name_ != &::google::protobuf::internal::kEmptyString) {
    delete catalog_name_;
  }
  if (catalog_name) {
    set_has_catalog_name();
    catalog_name_ = catalog_name;
  } else {
    clear_has_catalog_name();
    catalog_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string schema_name = 2;
inline bool SchemaMetadata::has_schema_name() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void SchemaMetadata::set_has_schema_name() {
  _has_bits_[0] |= 0x00000002u;
}
inline void SchemaMetadata::clear_has_schema_name() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void SchemaMetadata::clear_schema_name() {
  if (schema_name_ != &::google::protobuf::internal::kEmptyString) {
    schema_name_->clear();
  }
  clear_has_schema_name();
}
inline const ::std::string& SchemaMetadata::schema_name() const {
  return *schema_name_;
}
inline void SchemaMetadata::set_schema_name(const ::std::string& value) {
  set_has_schema_name();
  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
    schema_name_ = new ::std::string;
  }
  schema_name_->assign(value);
}
inline void SchemaMetadata::set_schema_name(const char* value) {
  set_has_schema_name();
  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
    schema_name_ = new ::std::string;
  }
  schema_name_->assign(value);
}
inline void SchemaMetadata::set_schema_name(const char* value, size_t size) {
  set_has_schema_name();
  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
    schema_name_ = new ::std::string;
  }
  schema_name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* SchemaMetadata::mutable_schema_name() {
  set_has_schema_name();
  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
    schema_name_ = new ::std::string;
  }
  return schema_name_;
}
inline ::std::string* SchemaMetadata::release_schema_name() {
  clear_has_schema_name();
  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = schema_name_;
    schema_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void SchemaMetadata::set_allocated_schema_name(::std::string* schema_name) {
  if (schema_name_ != &::google::protobuf::internal::kEmptyString) {
    delete schema_name_;
  }
  if (schema_name) {
    set_has_schema_name();
    schema_name_ = schema_name;
  } else {
    clear_has_schema_name();
    schema_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string owner = 3;
inline bool SchemaMetadata::has_owner() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void SchemaMetadata::set_has_owner() {
  _has_bits_[0] |= 0x00000004u;
}
inline void SchemaMetadata::clear_has_owner() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void SchemaMetadata::clear_owner() {
  if (owner_ != &::google::protobuf::internal::kEmptyString) {
    owner_->clear();
  }
  clear_has_owner();
}
inline const ::std::string& SchemaMetadata::owner() const {
  return *owner_;
}
inline void SchemaMetadata::set_owner(const ::std::string& value) {
  set_has_owner();
  if (owner_ == &::google::protobuf::internal::kEmptyString) {
    owner_ = new ::std::string;
  }
  owner_->assign(value);
}
inline void SchemaMetadata::set_owner(const char* value) {
  set_has_owner();
  if (owner_ == &::google::protobuf::internal::kEmptyString) {
    owner_ = new ::std::string;
  }
  owner_->assign(value);
}
inline void SchemaMetadata::set_owner(const char* value, size_t size) {
  set_has_owner();
  if (owner_ == &::google::protobuf::internal::kEmptyString) {
    owner_ = new ::std::string;
  }
  owner_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* SchemaMetadata::mutable_owner() {
  set_has_owner();
  if (owner_ == &::google::protobuf::internal::kEmptyString) {
    owner_ = new ::std::string;
  }
  return owner_;
}
inline ::std::string* SchemaMetadata::release_owner() {
  clear_has_owner();
  if (owner_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = owner_;
    owner_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void SchemaMetadata::set_allocated_owner(::std::string* owner) {
  if (owner_ != &::google::protobuf::internal::kEmptyString) {
    delete owner_;
  }
  if (owner) {
    set_has_owner();
    owner_ = owner;
  } else {
    clear_has_owner();
    owner_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string type = 4;
inline bool SchemaMetadata::has_type() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void SchemaMetadata::set_has_type() {
  _has_bits_[0] |= 0x00000008u;
}
inline void SchemaMetadata::clear_has_type() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void SchemaMetadata::clear_type() {
  if (type_ != &::google::protobuf::internal::kEmptyString) {
    type_->clear();
  }
  clear_has_type();
}
inline const ::std::string& SchemaMetadata::type() const {
  return *type_;
}
inline void SchemaMetadata::set_type(const ::std::string& value) {
  set_has_type();
  if (type_ == &::google::protobuf::internal::kEmptyString) {
    type_ = new ::std::string;
  }
  type_->assign(value);
}
inline void SchemaMetadata::set_type(const char* value) {
  set_has_type();
  if (type_ == &::google::protobuf::internal::kEmptyString) {
    type_ = new ::std::string;
  }
  type_->assign(value);
}
inline void SchemaMetadata::set_type(const char* value, size_t size) {
  set_has_type();
  if (type_ == &::google::protobuf::internal::kEmptyString) {
    type_ = new ::std::string;
  }
  type_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* SchemaMetadata::mutable_type() {
  set_has_type();
  if (type_ == &::google::protobuf::internal::kEmptyString) {
    type_ = new ::std::string;
  }
  return type_;
}
inline ::std::string* SchemaMetadata::release_type() {
  clear_has_type();
  if (type_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = type_;
    type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void SchemaMetadata::set_allocated_type(::std::string* type) {
  if (type_ != &::google::protobuf::internal::kEmptyString) {
    delete type_;
  }
  if (type) {
    set_has_type();
    type_ = type;
  } else {
    clear_has_type();
    type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string mutable = 5;
inline bool SchemaMetadata::has_mutable_() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void SchemaMetadata::set_has_mutable_() {
  _has_bits_[0] |= 0x00000010u;
}
inline void SchemaMetadata::clear_has_mutable_() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void SchemaMetadata::clear_mutable_() {
  if (mutable__ != &::google::protobuf::internal::kEmptyString) {
    mutable__->clear();
  }
  clear_has_mutable_();
}
inline const ::std::string& SchemaMetadata::mutable_() const {
  return *mutable__;
}
inline void SchemaMetadata::set_mutable_(const ::std::string& value) {
  set_has_mutable_();
  if (mutable__ == &::google::protobuf::internal::kEmptyString) {
    mutable__ = new ::std::string;
  }
  mutable__->assign(value);
}
inline void SchemaMetadata::set_mutable_(const char* value) {
  set_has_mutable_();
  if (mutable__ == &::google::protobuf::internal::kEmptyString) {
    mutable__ = new ::std::string;
  }
  mutable__->assign(value);
}
inline void SchemaMetadata::set_mutable_(const char* value, size_t size) {
  set_has_mutable_();
  if (mutable__ == &::google::protobuf::internal::kEmptyString) {
    mutable__ = new ::std::string;
  }
  mutable__->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* SchemaMetadata::mutable_mutable_() {
  set_has_mutable_();
  if (mutable__ == &::google::protobuf::internal::kEmptyString) {
    mutable__ = new ::std::string;
  }
  return mutable__;
}
inline ::std::string* SchemaMetadata::release_mutable_() {
  clear_has_mutable_();
  if (mutable__ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = mutable__;
    mutable__ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void SchemaMetadata::set_allocated_mutable_(::std::string* mutable_) {
  if (mutable__ != &::google::protobuf::internal::kEmptyString) {
    delete mutable__;
  }
  if (mutable_) {
    set_has_mutable_();
    mutable__ = mutable_;
  } else {
    clear_has_mutable_();
    mutable__ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// -------------------------------------------------------------------

// GetSchemasResp

// optional .exec.user.RequestStatus status = 1;
inline bool GetSchemasResp::has_status() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetSchemasResp::set_has_status() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetSchemasResp::clear_has_status() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetSchemasResp::clear_status() {
  status_ = 0;
  clear_has_status();
}
inline ::exec::user::RequestStatus GetSchemasResp::status() const {
  return static_cast< ::exec::user::RequestStatus >(status_);
}
inline void GetSchemasResp::set_status(::exec::user::RequestStatus value) {
  assert(::exec::user::RequestStatus_IsValid(value));
  set_has_status();
  status_ = value;
}

// repeated .exec.user.SchemaMetadata schemas = 2;
inline int GetSchemasResp::schemas_size() const {
  return schemas_.size();
}
inline void GetSchemasResp::clear_schemas() {
  schemas_.Clear();
}
inline const ::exec::user::SchemaMetadata& GetSchemasResp::schemas(int index) const {
  return schemas_.Get(index);
}
inline ::exec::user::SchemaMetadata* GetSchemasResp::mutable_schemas(int index) {
  return schemas_.Mutable(index);
}
inline ::exec::user::SchemaMetadata* GetSchemasResp::add_schemas() {
  return schemas_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::exec::user::SchemaMetadata >&
GetSchemasResp::schemas() const {
  return schemas_;
}
inline ::google::protobuf::RepeatedPtrField< ::exec::user::SchemaMetadata >*
GetSchemasResp::mutable_schemas() {
  return &schemas_;
}

// optional .exec.shared.DrillPBError error = 3;
inline bool GetSchemasResp::has_error() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void GetSchemasResp::set_has_error() {
  _has_bits_[0] |= 0x00000004u;
}
inline void GetSchemasResp::clear_has_error() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void GetSchemasResp::clear_error() {
  if (error_ != NULL) error_->::exec::shared::DrillPBError::Clear();
  clear_has_error();
}
inline const ::exec::shared::DrillPBError& GetSchemasResp::error() const {
  return error_ != NULL ? *error_ : *default_instance_->error_;
}
inline ::exec::shared::DrillPBError* GetSchemasResp::mutable_error() {
  set_has_error();
  if (error_ == NULL) error_ = new ::exec::shared::DrillPBError;
  return error_;
}
inline ::exec::shared::DrillPBError* GetSchemasResp::release_error() {
  clear_has_error();
  ::exec::shared::DrillPBError* temp = error_;
  error_ = NULL;
  return temp;
}
inline void GetSchemasResp::set_allocated_error(::exec::shared::DrillPBError* error) {
  delete error_;
  error_ = error;
  if (error) {
    set_has_error();
  } else {
    clear_has_error();
  }
}

// -------------------------------------------------------------------

// GetTablesReq

// optional .exec.user.LikeFilter catalog_name_filter = 1;
inline bool GetTablesReq::has_catalog_name_filter() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetTablesReq::set_has_catalog_name_filter() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetTablesReq::clear_has_catalog_name_filter() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetTablesReq::clear_catalog_name_filter() {
  if (catalog_name_filter_ != NULL) catalog_name_filter_->::exec::user::LikeFilter::Clear();
  clear_has_catalog_name_filter();
}
inline const ::exec::user::LikeFilter& GetTablesReq::catalog_name_filter() const {
  return catalog_name_filter_ != NULL ? *catalog_name_filter_ : *default_instance_->catalog_name_filter_;
}
inline ::exec::user::LikeFilter* GetTablesReq::mutable_catalog_name_filter() {
  set_has_catalog_name_filter();
  if (catalog_name_filter_ == NULL) catalog_name_filter_ = new ::exec::user::LikeFilter;
  return catalog_name_filter_;
}
inline ::exec::user::LikeFilter* GetTablesReq::release_catalog_name_filter() {
  clear_has_catalog_name_filter();
  ::exec::user::LikeFilter* temp = catalog_name_filter_;
  catalog_name_filter_ = NULL;
  return temp;
}
inline void GetTablesReq::set_allocated_catalog_name_filter(::exec::user::LikeFilter* catalog_name_filter) {
  delete catalog_name_filter_;
  catalog_name_filter_ = catalog_name_filter;
  if (catalog_name_filter) {
    set_has_catalog_name_filter();
  } else {
    clear_has_catalog_name_filter();
  }
}

// optional .exec.user.LikeFilter schema_name_filter = 2;
inline bool GetTablesReq::has_schema_name_filter() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GetTablesReq::set_has_schema_name_filter() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GetTablesReq::clear_has_schema_name_filter() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GetTablesReq::clear_schema_name_filter() {
  if (schema_name_filter_ != NULL) schema_name_filter_->::exec::user::LikeFilter::Clear();
  clear_has_schema_name_filter();
}
inline const ::exec::user::LikeFilter& GetTablesReq::schema_name_filter() const {
  return schema_name_filter_ != NULL ? *schema_name_filter_ : *default_instance_->schema_name_filter_;
}
inline ::exec::user::LikeFilter* GetTablesReq::mutable_schema_name_filter() {
  set_has_schema_name_filter();
  if (schema_name_filter_ == NULL) schema_name_filter_ = new ::exec::user::LikeFilter;
  return schema_name_filter_;
}
inline ::exec::user::LikeFilter* GetTablesReq::release_schema_name_filter() {
  clear_has_schema_name_filter();
  ::exec::user::LikeFilter* temp = schema_name_filter_;
  schema_name_filter_ = NULL;
  return temp;
}
inline void GetTablesReq::set_allocated_schema_name_filter(::exec::user::LikeFilter* schema_name_filter) {
  delete schema_name_filter_;
  schema_name_filter_ = schema_name_filter;
  if (schema_name_filter) {
    set_has_schema_name_filter();
  } else {
    clear_has_schema_name_filter();
  }
}

// optional .exec.user.LikeFilter table_name_filter = 3;
inline bool GetTablesReq::has_table_name_filter() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void GetTablesReq::set_has_table_name_filter() {
  _has_bits_[0] |= 0x00000004u;
}
inline void GetTablesReq::clear_has_table_name_filter() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void GetTablesReq::clear_table_name_filter() {
  if (table_name_filter_ != NULL) table_name_filter_->::exec::user::LikeFilter::Clear();
  clear_has_table_name_filter();
}
inline const ::exec::user::LikeFilter& GetTablesReq::table_name_filter() const {
  return table_name_filter_ != NULL ? *table_name_filter_ : *default_instance_->table_name_filter_;
}
inline ::exec::user::LikeFilter* GetTablesReq::mutable_table_name_filter() {
  set_has_table_name_filter();
  if (table_name_filter_ == NULL) table_name_filter_ = new ::exec::user::LikeFilter;
  return table_name_filter_;
}
inline ::exec::user::LikeFilter* GetTablesReq::release_table_name_filter() {
  clear_has_table_name_filter();
  ::exec::user::LikeFilter* temp = table_name_filter_;
  table_name_filter_ = NULL;
  return temp;
}
inline void GetTablesReq::set_allocated_table_name_filter(::exec::user::LikeFilter* table_name_filter) {
  delete table_name_filter_;
  table_name_filter_ = table_name_filter;
  if (table_name_filter) {
    set_has_table_name_filter();
  } else {
    clear_has_table_name_filter();
  }
}

// repeated string table_type_filter = 4;
inline int GetTablesReq::table_type_filter_size() const {
  return table_type_filter_.size();
}
inline void GetTablesReq::clear_table_type_filter() {
  table_type_filter_.Clear();
}
inline const ::std::string& GetTablesReq::table_type_filter(int index) const {
  return table_type_filter_.Get(index);
}
inline ::std::string* GetTablesReq::mutable_table_type_filter(int index) {
  return table_type_filter_.Mutable(index);
}
inline void GetTablesReq::set_table_type_filter(int index, const ::std::string& value) {
  table_type_filter_.Mutable(index)->assign(value);
}
inline void GetTablesReq::set_table_type_filter(int index, const char* value) {
  table_type_filter_.Mutable(index)->assign(value);
}
inline void GetTablesReq::set_table_type_filter(int index, const char* value, size_t size) {
  table_type_filter_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* GetTablesReq::add_table_type_filter() {
  return table_type_filter_.Add();
}
inline void GetTablesReq::add_table_type_filter(const ::std::string& value) {
  table_type_filter_.Add()->assign(value);
}
inline void GetTablesReq::add_table_type_filter(const char* value) {
  table_type_filter_.Add()->assign(value);
}
inline void GetTablesReq::add_table_type_filter(const char* value, size_t size) {
  table_type_filter_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
GetTablesReq::table_type_filter() const {
  return table_type_filter_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
GetTablesReq::mutable_table_type_filter() {
  return &table_type_filter_;
}

// -------------------------------------------------------------------

// TableMetadata

// optional string catalog_name = 1;
inline bool TableMetadata::has_catalog_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TableMetadata::set_has_catalog_name() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TableMetadata::clear_has_catalog_name() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TableMetadata::clear_catalog_name() {
  if (catalog_name_ != &::google::protobuf::internal::kEmptyString) {
    catalog_name_->clear();
  }
  clear_has_catalog_name();
}
inline const ::std::string& TableMetadata::catalog_name() const {
  return *catalog_name_;
}
inline void TableMetadata::set_catalog_name(const ::std::string& value) {
  set_has_catalog_name();
  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
    catalog_name_ = new ::std::string;
  }
  catalog_name_->assign(value);
}
inline void TableMetadata::set_catalog_name(const char* value) {
  set_has_catalog_name();
  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
    catalog_name_ = new ::std::string;
  }
  catalog_name_->assign(value);
}
inline void TableMetadata::set_catalog_name(const char* value, size_t size) {
  set_has_catalog_name();
  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
    catalog_name_ = new ::std::string;
  }
  catalog_name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* TableMetadata::mutable_catalog_name() {
  set_has_catalog_name();
  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
    catalog_name_ = new ::std::string;
  }
  return catalog_name_;
}
inline ::std::string* TableMetadata::release_catalog_name() {
  clear_has_catalog_name();
  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = catalog_name_;
    catalog_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void TableMetadata::set_allocated_catalog_name(::std::string* catalog_name) {
  if (catalog_name_ != &::google::protobuf::internal::kEmptyString) {
    delete catalog_name_;
  }
  if (catalog_name) {
    set_has_catalog_name();
    catalog_name_ = catalog_name;
  } else {
    clear_has_catalog_name();
    catalog_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string schema_name = 2;
inline bool TableMetadata::has_schema_name() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TableMetadata::set_has_schema_name() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TableMetadata::clear_has_schema_name() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TableMetadata::clear_schema_name() {
  if (schema_name_ != &::google::protobuf::internal::kEmptyString) {
    schema_name_->clear();
  }
  clear_has_schema_name();
}
inline const ::std::string& TableMetadata::schema_name() const {
  return *schema_name_;
}
inline void TableMetadata::set_schema_name(const ::std::string& value) {
  set_has_schema_name();
  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
    schema_name_ = new ::std::string;
  }
  schema_name_->assign(value);
}
inline void TableMetadata::set_schema_name(const char* value) {
  set_has_schema_name();
  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
    schema_name_ = new ::std::string;
  }
  schema_name_->assign(value);
}
inline void TableMetadata::set_schema_name(const char* value, size_t size) {
  set_has_schema_name();
  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
    schema_name_ = new ::std::string;
  }
  schema_name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* TableMetadata::mutable_schema_name() {
  set_has_schema_name();
  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
    schema_name_ = new ::std::string;
  }
  return schema_name_;
}
inline ::std::string* TableMetadata::release_schema_name() {
  clear_has_schema_name();
  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = schema_name_;
    schema_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void TableMetadata::set_allocated_schema_name(::std::string* schema_name) {
  if (schema_name_ != &::google::protobuf::internal::kEmptyString) {
    delete schema_name_;
  }
  if (schema_name) {
    set_has_schema_name();
    schema_name_ = schema_name;
  } else {
    clear_has_schema_name();
    schema_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string table_name = 3;
inline bool TableMetadata::has_table_name() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void TableMetadata::set_has_table_name() {
  _has_bits_[0] |= 0x00000004u;
}
inline void TableMetadata::clear_has_table_name() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void TableMetadata::clear_table_name() {
  if (table_name_ != &::google::protobuf::internal::kEmptyString) {
    table_name_->clear();
  }
  clear_has_table_name();
}
inline const ::std::string& TableMetadata::table_name() const {
  return *table_name_;
}
inline void TableMetadata::set_table_name(const ::std::string& value) {
  set_has_table_name();
  if (table_name_ == &::google::protobuf::internal::kEmptyString) {
    table_name_ = new ::std::string;
  }
  table_name_->assign(value);
}
inline void TableMetadata::set_table_name(const char* value) {
  set_has_table_name();
  if (table_name_ == &::google::protobuf::internal::kEmptyString) {
    table_name_ = new ::std::string;
  }
  table_name_->assign(value);
}
inline void TableMetadata::set_table_name(const char* value, size_t size) {
  set_has_table_name();
  if (table_name_ == &::google::protobuf::internal::kEmptyString) {
    table_name_ = new ::std::string;
  }
  table_name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* TableMetadata::mutable_table_name() {
  set_has_table_name();
  if (table_name_ == &::google::protobuf::internal::kEmptyString) {
    table_name_ = new ::std::string;
  }
  return table_name_;
}
inline ::std::string* TableMetadata::release_table_name() {
  clear_has_table_name();
  if (table_name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = table_name_;
    table_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void TableMetadata::set_allocated_table_name(::std::string* table_name) {
  if (table_name_ != &::google::protobuf::internal::kEmptyString) {
    delete table_name_;
  }
  if (table_name) {
    set_has_table_name();
    table_name_ = table_name;
  } else {
    clear_has_table_name();
    table_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string type = 4;
inline bool TableMetadata::has_type() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void TableMetadata::set_has_type() {
  _has_bits_[0] |= 0x00000008u;
}
inline void TableMetadata::clear_has_type() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void TableMetadata::clear_type() {
  if (type_ != &::google::protobuf::internal::kEmptyString) {
    type_->clear();
  }
  clear_has_type();
}
inline const ::std::string& TableMetadata::type() const {
  return *type_;
}
inline void TableMetadata::set_type(const ::std::string& value) {
  set_has_type();
  if (type_ == &::google::protobuf::internal::kEmptyString) {
    type_ = new ::std::string;
  }
  type_->assign(value);
}
inline void TableMetadata::set_type(const char* value) {
  set_has_type();
  if (type_ == &::google::protobuf::internal::kEmptyString) {
    type_ = new ::std::string;
  }
  type_->assign(value);
}
inline void TableMetadata::set_type(const char* value, size_t size) {
  set_has_type();
  if (type_ == &::google::protobuf::internal::kEmptyString) {
    type_ = new ::std::string;
  }
  type_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* TableMetadata::mutable_type() {
  set_has_type();
  if (type_ == &::google::protobuf::internal::kEmptyString) {
    type_ = new ::std::string;
  }
  return type_;
}
inline ::std::string* TableMetadata::release_type() {
  clear_has_type();
  if (type_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = type_;
    type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void TableMetadata::set_allocated_type(::std::string* type) {
  if (type_ != &::google::protobuf::internal::kEmptyString) {
    delete type_;
  }
  if (type) {
    set_has_type();
    type_ = type;
  } else {
    clear_has_type();
    type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// -------------------------------------------------------------------

// GetTablesResp

// optional .exec.user.RequestStatus status = 1;
inline bool GetTablesResp::has_status() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetTablesResp::set_has_status() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetTablesResp::clear_has_status() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetTablesResp::clear_status() {
  status_ = 0;
  clear_has_status();
}
inline ::exec::user::RequestStatus GetTablesResp::status() const {
  return static_cast< ::exec::user::RequestStatus >(status_);
}
inline void GetTablesResp::set_status(::exec::user::RequestStatus value) {
  assert(::exec::user::RequestStatus_IsValid(value));
  set_has_status();
  status_ = value;
}

// repeated .exec.user.TableMetadata tables = 2;
inline int GetTablesResp::tables_size() const {
  return tables_.size();
}
inline void GetTablesResp::clear_tables() {
  tables_.Clear();
}
inline const ::exec::user::TableMetadata& GetTablesResp::tables(int index) const {
  return tables_.Get(index);
}
inline ::exec::user::TableMetadata* GetTablesResp::mutable_tables(int index) {
  return tables_.Mutable(index);
}
inline ::exec::user::TableMetadata* GetTablesResp::add_tables() {
  return tables_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::exec::user::TableMetadata >&
GetTablesResp::tables() const {
  return tables_;
}
inline ::google::protobuf::RepeatedPtrField< ::exec::user::TableMetadata >*
GetTablesResp::mutable_tables() {
  return &tables_;
}

// optional .exec.shared.DrillPBError error = 3;
inline bool GetTablesResp::has_error() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void GetTablesResp::set_has_error() {
  _has_bits_[0] |= 0x00000004u;
}
inline void GetTablesResp::clear_has_error() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void GetTablesResp::clear_error() {
  if (error_ != NULL) error_->::exec::shared::DrillPBError::Clear();
  clear_has_error();
}
inline const ::exec::shared::DrillPBError& GetTablesResp::error() const {
  return error_ != NULL ? *error_ : *default_instance_->error_;
}
inline ::exec::shared::DrillPBError* GetTablesResp::mutable_error() {
  set_has_error();
  if (error_ == NULL) error_ = new ::exec::shared::DrillPBError;
  return error_;
}
inline ::exec::shared::DrillPBError* GetTablesResp::release_error() {
  clear_has_error();
  ::exec::shared::DrillPBError* temp = error_;
  error_ = NULL;
  return temp;
}
inline void GetTablesResp::set_allocated_error(::exec::shared::DrillPBError* error) {
  delete error_;
  error_ = error;
  if (error) {
    set_has_error();
  } else {
    clear_has_error();
  }
}

// -------------------------------------------------------------------

// GetColumnsReq

// optional .exec.user.LikeFilter catalog_name_filter = 1;
inline bool GetColumnsReq::has_catalog_name_filter() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetColumnsReq::set_has_catalog_name_filter() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetColumnsReq::clear_has_catalog_name_filter() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetColumnsReq::clear_catalog_name_filter() {
  if (catalog_name_filter_ != NULL) catalog_name_filter_->::exec::user::LikeFilter::Clear();
  clear_has_catalog_name_filter();
}
inline const ::exec::user::LikeFilter& GetColumnsReq::catalog_name_filter() const {
  return catalog_name_filter_ != NULL ? *catalog_name_filter_ : *default_instance_->catalog_name_filter_;
}
inline ::exec::user::LikeFilter* GetColumnsReq::mutable_catalog_name_filter() {
  set_has_catalog_name_filter();
  if (catalog_name_filter_ == NULL) catalog_name_filter_ = new ::exec::user::LikeFilter;
  return catalog_name_filter_;
}
inline ::exec::user::LikeFilter* GetColumnsReq::release_catalog_name_filter() {
  clear_has_catalog_name_filter();
  ::exec::user::LikeFilter* temp = catalog_name_filter_;
  catalog_name_filter_ = NULL;
  return temp;
}
inline void GetColumnsReq::set_allocated_catalog_name_filter(::exec::user::LikeFilter* catalog_name_filter) {
  delete catalog_name_filter_;
  catalog_name_filter_ = catalog_name_filter;
  if (catalog_name_filter) {
    set_has_catalog_name_filter();
  } else {
    clear_has_catalog_name_filter();
  }
}

// optional .exec.user.LikeFilter schema_name_filter = 2;
inline bool GetColumnsReq::has_schema_name_filter() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GetColumnsReq::set_has_schema_name_filter() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GetColumnsReq::clear_has_schema_name_filter() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GetColumnsReq::clear_schema_name_filter() {
  if (schema_name_filter_ != NULL) schema_name_filter_->::exec::user::LikeFilter::Clear();
  clear_has_schema_name_filter();
}
inline const ::exec::user::LikeFilter& GetColumnsReq::schema_name_filter() const {
  return schema_name_filter_ != NULL ? *schema_name_filter_ : *default_instance_->schema_name_filter_;
}
inline ::exec::user::LikeFilter* GetColumnsReq::mutable_schema_name_filter() {
  set_has_schema_name_filter();
  if (schema_name_filter_ == NULL) schema_name_filter_ = new ::exec::user::LikeFilter;
  return schema_name_filter_;
}
inline ::exec::user::LikeFilter* GetColumnsReq::release_schema_name_filter() {
  clear_has_schema_name_filter();
  ::exec::user::LikeFilter* temp = schema_name_filter_;
  schema_name_filter_ = NULL;
  return temp;
}
inline void GetColumnsReq::set_allocated_schema_name_filter(::exec::user::LikeFilter* schema_name_filter) {
  delete schema_name_filter_;
  schema_name_filter_ = schema_name_filter;
  if (schema_name_filter) {
    set_has_schema_name_filter();
  } else {
    clear_has_schema_name_filter();
  }
}

// optional .exec.user.LikeFilter table_name_filter = 3;
inline bool GetColumnsReq::has_table_name_filter() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void GetColumnsReq::set_has_table_name_filter() {
  _has_bits_[0] |= 0x00000004u;
}
inline void GetColumnsReq::clear_has_table_name_filter() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void GetColumnsReq::clear_table_name_filter() {
  if (table_name_filter_ != NULL) table_name_filter_->::exec::user::LikeFilter::Clear();
  clear_has_table_name_filter();
}
inline const ::exec::user::LikeFilter& GetColumnsReq::table_name_filter() const {
  return table_name_filter_ != NULL ? *table_name_filter_ : *default_instance_->table_name_filter_;
}
inline ::exec::user::LikeFilter* GetColumnsReq::mutable_table_name_filter() {
  set_has_table_name_filter();
  if (table_name_filter_ == NULL) table_name_filter_ = new ::exec::user::LikeFilter;
  return table_name_filter_;
}
inline ::exec::user::LikeFilter* GetColumnsReq::release_table_name_filter() {
  clear_has_table_name_filter();
  ::exec::user::LikeFilter* temp = table_name_filter_;
  table_name_filter_ = NULL;
  return temp;
}
inline void GetColumnsReq::set_allocated_table_name_filter(::exec::user::LikeFilter* table_name_filter) {
  delete table_name_filter_;
  table_name_filter_ = table_name_filter;
  if (table_name_filter) {
    set_has_table_name_filter();
  } else {
    clear_has_table_name_filter();
  }
}

// optional .exec.user.LikeFilter column_name_filter = 4;
inline bool GetColumnsReq::has_column_name_filter() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void GetColumnsReq::set_has_column_name_filter() {
  _has_bits_[0] |= 0x00000008u;
}
inline void GetColumnsReq::clear_has_column_name_filter() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void GetColumnsReq::clear_column_name_filter() {
  if (column_name_filter_ != NULL) column_name_filter_->::exec::user::LikeFilter::Clear();
  clear_has_column_name_filter();
}
inline const ::exec::user::LikeFilter& GetColumnsReq::column_name_filter() const {
  return column_name_filter_ != NULL ? *column_name_filter_ : *default_instance_->column_name_filter_;
}
inline ::exec::user::LikeFilter* GetColumnsReq::mutable_column_name_filter() {
  set_has_column_name_filter();
  if (column_name_filter_ == NULL) column_name_filter_ = new ::exec::user::LikeFilter;
  return column_name_filter_;
}
inline ::exec::user::LikeFilter* GetColumnsReq::release_column_name_filter() {
  clear_has_column_name_filter();
  ::exec::user::LikeFilter* temp = column_name_filter_;
  column_name_filter_ = NULL;
  return temp;
}
inline void GetColumnsReq::set_allocated_column_name_filter(::exec::user::LikeFilter* column_name_filter) {
  delete column_name_filter_;
  column_name_filter_ = column_name_filter;
  if (column_name_filter) {
    set_has_column_name_filter();
  } else {
    clear_has_column_name_filter();
  }
}

// -------------------------------------------------------------------

// ColumnMetadata

// optional string catalog_name = 1;
inline bool ColumnMetadata::has_catalog_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ColumnMetadata::set_has_catalog_name() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ColumnMetadata::clear_has_catalog_name() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ColumnMetadata::clear_catalog_name() {
  if (catalog_name_ != &::google::protobuf::internal::kEmptyString) {
    catalog_name_->clear();
  }
  clear_has_catalog_name();
}
inline const ::std::string& ColumnMetadata::catalog_name() const {
  return *catalog_name_;
}
inline void ColumnMetadata::set_catalog_name(const ::std::string& value) {
  set_has_catalog_name();
  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
    catalog_name_ = new ::std::string;
  }
  catalog_name_->assign(value);
}
inline void ColumnMetadata::set_catalog_name(const char* value) {
  set_has_catalog_name();
  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
    catalog_name_ = new ::std::string;
  }
  catalog_name_->assign(value);
}
inline void ColumnMetadata::set_catalog_name(const char* value, size_t size) {
  set_has_catalog_name();
  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
    catalog_name_ = new ::std::string;
  }
  catalog_name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ColumnMetadata::mutable_catalog_name() {
  set_has_catalog_name();
  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
    catalog_name_ = new ::std::string;
  }
  return catalog_name_;
}
inline ::std::string* ColumnMetadata::release_catalog_name() {
  clear_has_catalog_name();
  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = catalog_name_;
    catalog_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void ColumnMetadata::set_allocated_catalog_name(::std::string* catalog_name) {
  if (catalog_name_ != &::google::protobuf::internal::kEmptyString) {
    delete catalog_name_;
  }
  if (catalog_name) {
    set_has_catalog_name();
    catalog_name_ = catalog_name;
  } else {
    clear_has_catalog_name();
    catalog_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string schema_name = 2;
inline bool ColumnMetadata::has_schema_name() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ColumnMetadata::set_has_schema_name() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ColumnMetadata::clear_has_schema_name() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ColumnMetadata::clear_schema_name() {
  if (schema_name_ != &::google::protobuf::internal::kEmptyString) {
    schema_name_->clear();
  }
  clear_has_schema_name();
}
inline const ::std::string& ColumnMetadata::schema_name() const {
  return *schema_name_;
}
inline void ColumnMetadata::set_schema_name(const ::std::string& value) {
  set_has_schema_name();
  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
    schema_name_ = new ::std::string;
  }
  schema_name_->assign(value);
}
inline void ColumnMetadata::set_schema_name(const char* value) {
  set_has_schema_name();
  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
    schema_name_ = new ::std::string;
  }
  schema_name_->assign(value);
}
inline void ColumnMetadata::set_schema_name(const char* value, size_t size) {
  set_has_schema_name();
  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
    schema_name_ = new ::std::string;
  }
  schema_name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ColumnMetadata::mutable_schema_name() {
  set_has_schema_name();
  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
    schema_name_ = new ::std::string;
  }
  return schema_name_;
}
inline ::std::string* ColumnMetadata::release_schema_name() {
  clear_has_schema_name();
  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = schema_name_;
    schema_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void ColumnMetadata::set_allocated_schema_name(::std::string* schema_name) {
  if (schema_name_ != &::google::protobuf::internal::kEmptyString) {
    delete schema_name_;
  }
  if (schema_name) {
    set_has_schema_name();
    schema_name_ = schema_name;
  } else {
    clear_has_schema_name();
    schema_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string table_name = 3;
inline bool ColumnMetadata::has_table_name() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ColumnMetadata::set_has_table_name() {
  _has_bits_[0] |= 0x00000004u;
}
inline void ColumnMetadata::clear_has_table_name() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void ColumnMetadata::clear_table_name() {
  if (table_name_ != &::google::protobuf::internal::kEmptyString) {
    table_name_->clear();
  }
  clear_has_table_name();
}
inline const ::std::string& ColumnMetadata::table_name() const {
  return *table_name_;
}
inline void ColumnMetadata::set_table_name(const ::std::string& value) {
  set_has_table_name();
  if (table_name_ == &::google::protobuf::internal::kEmptyString) {
    table_name_ = new ::std::string;
  }
  table_name_->assign(value);
}
inline void ColumnMetadata::set_table_name(const char* value) {
  set_has_table_name();
  if (table_name_ == &::google::protobuf::internal::kEmptyString) {
    table_name_ = new ::std::string;
  }
  table_name_->assign(value);
}
inline void ColumnMetadata::set_table_name(const char* value, size_t size) {
  set_has_table_name();
  if (table_name_ == &::google::protobuf::internal::kEmptyString) {
    table_name_ = new ::std::string;
  }
  table_name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ColumnMetadata::mutable_table_name() {
  set_has_table_name();
  if (table_name_ == &::google::protobuf::internal::kEmptyString) {
    table_name_ = new ::std::string;
  }
  return table_name_;
}
inline ::std::string* ColumnMetadata::release_table_name() {
  clear_has_table_name();
  if (table_name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = table_name_;
    table_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void ColumnMetadata::set_allocated_table_name(::std::string* table_name) {
  if (table_name_ != &::google::protobuf::internal::kEmptyString) {
    delete table_name_;
  }
  if (table_name) {
    set_has_table_name();
    table_name_ = table_name;
  } else {
    clear_has_table_name();
    table_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string column_name = 4;
inline bool ColumnMetadata::has_column_name() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ColumnMetadata::set_has_column_name() {
  _has_bits_[0] |= 0x00000008u;
}
inline void ColumnMetadata::clear_has_column_name() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void ColumnMetadata::clear_column_name() {
  if (column_name_ != &::google::protobuf::internal::kEmptyString) {
    column_name_->clear();
  }
  clear_has_column_name();
}
inline const ::std::string& ColumnMetadata::column_name() const {
  return *column_name_;
}
inline void ColumnMetadata::set_column_name(const ::std::string& value) {
  set_has_column_name();
  if (column_name_ == &::google::protobuf::internal::kEmptyString) {
    column_name_ = new ::std::string;
  }
  column_name_->assign(value);
}
inline void ColumnMetadata::set_column_name(const char* value) {
  set_has_column_name();
  if (column_name_ == &::google::protobuf::internal::kEmptyString) {
    column_name_ = new ::std::string;
  }
  column_name_->assign(value);
}
inline void ColumnMetadata::set_column_name(const char* value, size_t size) {
  set_has_column_name();
  if (column_name_ == &::google::protobuf::internal::kEmptyString) {
    column_name_ = new ::std::string;
  }
  column_name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ColumnMetadata::mutable_column_name() {
  set_has_column_name();
  if (column_name_ == &::google::protobuf::internal::kEmptyString) {
    column_name_ = new ::std::string;
  }
  return column_name_;
}
inline ::std::string* ColumnMetadata::release_column_name() {
  clear_has_column_name();
  if (column_name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = column_name_;
    column_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void ColumnMetadata::set_allocated_column_name(::std::string* column_name) {
  if (column_name_ != &::google::protobuf::internal::kEmptyString) {
    delete column_name_;
  }
  if (column_name) {
    set_has_column_name();
    column_name_ = column_name;
  } else {
    clear_has_column_name();
    column_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional int32 ordinal_position = 5;
inline bool ColumnMetadata::has_ordinal_position() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void ColumnMetadata::set_has_ordinal_position() {
  _has_bits_[0] |= 0x00000010u;
}
inline void ColumnMetadata::clear_has_ordinal_position() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void ColumnMetadata::clear_ordinal_position() {
  ordinal_position_ = 0;
  clear_has_ordinal_position();
}
inline ::google::protobuf::int32 ColumnMetadata::ordinal_position() const {
  return ordinal_position_;
}
inline void ColumnMetadata::set_ordinal_position(::google::protobuf::int32 value) {
  set_has_ordinal_position();
  ordinal_position_ = value;
}

// optional string default_value = 6;
inline bool ColumnMetadata::has_default_value() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void ColumnMetadata::set_has_default_value() {
  _has_bits_[0] |= 0x00000020u;
}
inline void ColumnMetadata::clear_has_default_value() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void ColumnMetadata::clear_default_value() {
  if (default_value_ != &::google::protobuf::internal::kEmptyString) {
    default_value_->clear();
  }
  clear_has_default_value();
}
inline const ::std::string& ColumnMetadata::default_value() const {
  return *default_value_;
}
inline void ColumnMetadata::set_default_value(const ::std::string& value) {
  set_has_default_value();
  if (default_value_ == &::google::protobuf::internal::kEmptyString) {
    default_value_ = new ::std::string;
  }
  default_value_->assign(value);
}
inline void ColumnMetadata::set_default_value(const char* value) {
  set_has_default_value();
  if (default_value_ == &::google::protobuf::internal::kEmptyString) {
    default_value_ = new ::std::string;
  }
  default_value_->assign(value);
}
inline void ColumnMetadata::set_default_value(const char* value, size_t size) {
  set_has_default_value();
  if (default_value_ == &::google::protobuf::internal::kEmptyString) {
    default_value_ = new ::std::string;
  }
  default_value_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ColumnMetadata::mutable_default_value() {
  set_has_default_value();
  if (default_value_ == &::google::protobuf::internal::kEmptyString) {
    default_value_ = new ::std::string;
  }
  return default_value_;
}
inline ::std::string* ColumnMetadata::release_default_value() {
  clear_has_default_value();
  if (default_value_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = default_value_;
    default_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void ColumnMetadata::set_allocated_default_value(::std::string* default_value) {
  if (default_value_ != &::google::protobuf::internal::kEmptyString) {
    delete default_value_;
  }
  if (default_value) {
    set_has_default_value();
    default_value_ = default_value;
  } else {
    clear_has_default_value();
    default_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional bool is_nullable = 7;
inline bool ColumnMetadata::has_is_nullable() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void ColumnMetadata::set_has_is_nullable() {
  _has_bits_[0] |= 0x00000040u;
}
inline void ColumnMetadata::clear_has_is_nullable() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void ColumnMetadata::clear_is_nullable() {
  is_nullable_ = false;
  clear_has_is_nullable();
}
inline bool ColumnMetadata::is_nullable() const {
  return is_nullable_;
}
inline void ColumnMetadata::set_is_nullable(bool value) {
  set_has_is_nullable();
  is_nullable_ = value;
}

// optional string data_type = 8;
inline bool ColumnMetadata::has_data_type() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void ColumnMetadata::set_has_data_type() {
  _has_bits_[0] |= 0x00000080u;
}
inline void ColumnMetadata::clear_has_data_type() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void ColumnMetadata::clear_data_type() {
  if (data_type_ != &::google::protobuf::internal::kEmptyString) {
    data_type_->clear();
  }
  clear_has_data_type();
}
inline const ::std::string& ColumnMetadata::data_type() const {
  return *data_type_;
}
inline void ColumnMetadata::set_data_type(const ::std::string& value) {
  set_has_data_type();
  if (data_type_ == &::google::protobuf::internal::kEmptyString) {
    data_type_ = new ::std::string;
  }
  data_type_->assign(value);
}
inline void ColumnMetadata::set_data_type(const char* value) {
  set_has_data_type();
  if (data_type_ == &::google::protobuf::internal::kEmptyString) {
    data_type_ = new ::std::string;
  }
  data_type_->assign(value);
}
inline void ColumnMetadata::set_data_type(const char* value, size_t size) {
  set_has_data_type();
  if (data_type_ == &::google::protobuf::internal::kEmptyString) {
    data_type_ = new ::std::string;
  }
  data_type_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ColumnMetadata::mutable_data_type() {
  set_has_data_type();
  if (data_type_ == &::google::protobuf::internal::kEmptyString) {
    data_type_ = new ::std::string;
  }
  return data_type_;
}
inline ::std::string* ColumnMetadata::release_data_type() {
  clear_has_data_type();
  if (data_type_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = data_type_;
    data_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void ColumnMetadata::set_allocated_data_type(::std::string* data_type) {
  if (data_type_ != &::google::protobuf::internal::kEmptyString) {
    delete data_type_;
  }
  if (data_type) {
    set_has_data_type();
    data_type_ = data_type;
  } else {
    clear_has_data_type();
    data_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional int32 char_max_length = 9;
inline bool ColumnMetadata::has_char_max_length() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void ColumnMetadata::set_has_char_max_length() {
  _has_bits_[0] |= 0x00000100u;
}
inline void ColumnMetadata::clear_has_char_max_length() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void ColumnMetadata::clear_char_max_length() {
  char_max_length_ = 0;
  clear_has_char_max_length();
}
inline ::google::protobuf::int32 ColumnMetadata::char_max_length() const {
  return char_max_length_;
}
inline void ColumnMetadata::set_char_max_length(::google::protobuf::int32 value) {
  set_has_char_max_length();
  char_max_length_ = value;
}

// optional int32 char_octet_length = 10;
inline bool ColumnMetadata::has_char_octet_length() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void ColumnMetadata::set_has_char_octet_length() {
  _has_bits_[0] |= 0x00000200u;
}
inline void ColumnMetadata::clear_has_char_octet_length() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void ColumnMetadata::clear_char_octet_length() {
  char_octet_length_ = 0;
  clear_has_char_octet_length();
}
inline ::google::protobuf::int32 ColumnMetadata::char_octet_length() const {
  return char_octet_length_;
}
inline void ColumnMetadata::set_char_octet_length(::google::protobuf::int32 value) {
  set_has_char_octet_length();
  char_octet_length_ = value;
}

// optional int32 numeric_precision = 11;
inline bool ColumnMetadata::has_numeric_precision() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void ColumnMetadata::set_has_numeric_precision() {
  _has_bits_[0] |= 0x00000400u;
}
inline void ColumnMetadata::clear_has_numeric_precision() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void ColumnMetadata::clear_numeric_precision() {
  numeric_precision_ = 0;
  clear_has_numeric_precision();
}
inline ::google::protobuf::int32 ColumnMetadata::numeric_precision() const {
  return numeric_precision_;
}
inline void ColumnMetadata::set_numeric_precision(::google::protobuf::int32 value) {
  set_has_numeric_precision();
  numeric_precision_ = value;
}

// optional int32 numeric_precision_radix = 12;
inline bool ColumnMetadata::has_numeric_precision_radix() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void ColumnMetadata::set_has_numeric_precision_radix() {
  _has_bits_[0] |= 0x00000800u;
}
inline void ColumnMetadata::clear_has_numeric_precision_radix() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void ColumnMetadata::clear_numeric_precision_radix() {
  numeric_precision_radix_ = 0;
  clear_has_numeric_precision_radix();
}
inline ::google::protobuf::int32 ColumnMetadata::numeric_precision_radix() const {
  return numeric_precision_radix_;
}
inline void ColumnMetadata::set_numeric_precision_radix(::google::protobuf::int32 value) {
  set_has_numeric_precision_radix();
  numeric_precision_radix_ = value;
}

// optional int32 numeric_scale = 13;
inline bool ColumnMetadata::has_numeric_scale() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void ColumnMetadata::set_has_numeric_scale() {
  _has_bits_[0] |= 0x00001000u;
}
inline void ColumnMetadata::clear_has_numeric_scale() {
  _has_bits_[0] &= ~0x00001000u;
}
inline void ColumnMetadata::clear_numeric_scale() {
  numeric_scale_ = 0;
  clear_has_numeric_scale();
}
inline ::google::protobuf::int32 ColumnMetadata::numeric_scale() const {
  return numeric_scale_;
}
inline void ColumnMetadata::set_numeric_scale(::google::protobuf::int32 value) {
  set_has_numeric_scale();
  numeric_scale_ = value;
}

// optional int32 date_time_precision = 14;
inline bool ColumnMetadata::has_date_time_precision() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void ColumnMetadata::set_has_date_time_precision() {
  _has_bits_[0] |= 0x00002000u;
}
inline void ColumnMetadata::clear_has_date_time_precision() {
  _has_bits_[0] &= ~0x00002000u;
}
inline void ColumnMetadata::clear_date_time_precision() {
  date_time_precision_ = 0;
  clear_has_date_time_precision();
}
inline ::google::protobuf::int32 ColumnMetadata::date_time_precision() const {
  return date_time_precision_;
}
inline void ColumnMetadata::set_date_time_precision(::google::protobuf::int32 value) {
  set_has_date_time_precision();
  date_time_precision_ = value;
}

// optional string interval_type = 15;
inline bool ColumnMetadata::has_interval_type() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void ColumnMetadata::set_has_interval_type() {
  _has_bits_[0] |= 0x00004000u;
}
inline void ColumnMetadata::clear_has_interval_type() {
  _has_bits_[0] &= ~0x00004000u;
}
inline void ColumnMetadata::clear_interval_type() {
  if (interval_type_ != &::google::protobuf::internal::kEmptyString) {
    interval_type_->clear();
  }
  clear_has_interval_type();
}
inline const ::std::string& ColumnMetadata::interval_type() const {
  return *interval_type_;
}
inline void ColumnMetadata::set_interval_type(const ::std::string& value) {
  set_has_interval_type();
  if (interval_type_ == &::google::protobuf::internal::kEmptyString) {
    interval_type_ = new ::std::string;
  }
  interval_type_->assign(value);
}
inline void ColumnMetadata::set_interval_type(const char* value) {
  set_has_interval_type();
  if (interval_type_ == &::google::protobuf::internal::kEmptyString) {
    interval_type_ = new ::std::string;
  }
  interval_type_->assign(value);
}
inline void ColumnMetadata::set_interval_type(const char* value, size_t size) {
  set_has_interval_type();
  if (interval_type_ == &::google::protobuf::internal::kEmptyString) {
    interval_type_ = new ::std::string;
  }
  interval_type_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ColumnMetadata::mutable_interval_type() {
  set_has_interval_type();
  if (interval_type_ == &::google::protobuf::internal::kEmptyString) {
    interval_type_ = new ::std::string;
  }
  return interval_type_;
}
inline ::std::string* ColumnMetadata::release_interval_type() {
  clear_has_interval_type();
  if (interval_type_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = interval_type_;
    interval_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void ColumnMetadata::set_allocated_interval_type(::std::string* interval_type) {
  if (interval_type_ != &::google::protobuf::internal::kEmptyString) {
    delete interval_type_;
  }
  if (interval_type) {
    set_has_interval_type();
    interval_type_ = interval_type;
  } else {
    clear_has_interval_type();
    interval_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional int32 interval_precision = 16;
inline bool ColumnMetadata::has_interval_precision() const {
  return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void ColumnMetadata::set_has_interval_precision() {
  _has_bits_[0] |= 0x00008000u;
}
inline void ColumnMetadata::clear_has_interval_precision() {
  _has_bits_[0] &= ~0x00008000u;
}
inline void ColumnMetadata::clear_interval_precision() {
  interval_precision_ = 0;
  clear_has_interval_precision();
}
inline ::google::protobuf::int32 ColumnMetadata::interval_precision() const {
  return interval_precision_;
}
inline void ColumnMetadata::set_interval_precision(::google::protobuf::int32 value) {
  set_has_interval_precision();
  interval_precision_ = value;
}

// optional int32 column_size = 17;
inline bool ColumnMetadata::has_column_size() const {
  return (_has_bits_[0] & 0x00010000u) != 0;
}
inline void ColumnMetadata::set_has_column_size() {
  _has_bits_[0] |= 0x00010000u;
}
inline void ColumnMetadata::clear_has_column_size() {
  _has_bits_[0] &= ~0x00010000u;
}
inline void ColumnMetadata::clear_column_size() {
  column_size_ = 0;
  clear_has_column_size();
}
inline ::google::protobuf::int32 ColumnMetadata::column_size() const {
  return column_size_;
}
inline void ColumnMetadata::set_column_size(::google::protobuf::int32 value) {
  set_has_column_size();
  column_size_ = value;
}

// -------------------------------------------------------------------

// GetColumnsResp

// optional .exec.user.RequestStatus status = 1;
inline bool GetColumnsResp::has_status() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetColumnsResp::set_has_status() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetColumnsResp::clear_has_status() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetColumnsResp::clear_status() {
  status_ = 0;
  clear_has_status();
}
inline ::exec::user::RequestStatus GetColumnsResp::status() const {
  return static_cast< ::exec::user::RequestStatus >(status_);
}
inline void GetColumnsResp::set_status(::exec::user::RequestStatus value) {
  assert(::exec::user::RequestStatus_IsValid(value));
  set_has_status();
  status_ = value;
}

// repeated .exec.user.ColumnMetadata columns = 2;
inline int GetColumnsResp::columns_size() const {
  return columns_.size();
}
inline void GetColumnsResp::clear_columns() {
  columns_.Clear();
}
inline const ::exec::user::ColumnMetadata& GetColumnsResp::columns(int index) const {
  return columns_.Get(index);
}
inline ::exec::user::ColumnMetadata* GetColumnsResp::mutable_columns(int index) {
  return columns_.Mutable(index);
}
inline ::exec::user::ColumnMetadata* GetColumnsResp::add_columns() {
  return columns_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::exec::user::ColumnMetadata >&
GetColumnsResp::columns() const {
  return columns_;
}
inline ::google::protobuf::RepeatedPtrField< ::exec::user::ColumnMetadata >*
GetColumnsResp::mutable_columns() {
  return &columns_;
}

// optional .exec.shared.DrillPBError error = 3;
inline bool GetColumnsResp::has_error() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void GetColumnsResp::set_has_error() {
  _has_bits_[0] |= 0x00000004u;
}
inline void GetColumnsResp::clear_has_error() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void GetColumnsResp::clear_error() {
  if (error_ != NULL) error_->::exec::shared::DrillPBError::Clear();
  clear_has_error();
}
inline const ::exec::shared::DrillPBError& GetColumnsResp::error() const {
  return error_ != NULL ? *error_ : *default_instance_->error_;
}
inline ::exec::shared::DrillPBError* GetColumnsResp::mutable_error() {
  set_has_error();
  if (error_ == NULL) error_ = new ::exec::shared::DrillPBError;
  return error_;
}
inline ::exec::shared::DrillPBError* GetColumnsResp::release_error() {
  clear_has_error();
  ::exec::shared::DrillPBError* temp = error_;
  error_ = NULL;
  return temp;
}
inline void GetColumnsResp::set_allocated_error(::exec::shared::DrillPBError* error) {
  delete error_;
  error_ = error;
  if (error) {
    set_has_error();
  } else {
    clear_has_error();
  }
}

// -------------------------------------------------------------------

// CreatePreparedStatementReq

// optional string sql_query = 1;
inline bool CreatePreparedStatementReq::has_sql_query() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CreatePreparedStatementReq::set_has_sql_query() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CreatePreparedStatementReq::clear_has_sql_query() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CreatePreparedStatementReq::clear_sql_query() {
  if (sql_query_ != &::google::protobuf::internal::kEmptyString) {
    sql_query_->clear();
  }
  clear_has_sql_query();
}
inline const ::std::string& CreatePreparedStatementReq::sql_query() const {
  return *sql_query_;
}
inline void CreatePreparedStatementReq::set_sql_query(const ::std::string& value) {
  set_has_sql_query();
  if (sql_query_ == &::google::protobuf::internal::kEmptyString) {
    sql_query_ = new ::std::string;
  }
  sql_query_->assign(value);
}
inline void CreatePreparedStatementReq::set_sql_query(const char* value) {
  set_has_sql_query();
  if (sql_query_ == &::google::protobuf::internal::kEmptyString) {
    sql_query_ = new ::std::string;
  }
  sql_query_->assign(value);
}
inline void CreatePreparedStatementReq::set_sql_query(const char* value, size_t size) {
  set_has_sql_query();
  if (sql_query_ == &::google::protobuf::internal::kEmptyString) {
    sql_query_ = new ::std::string;
  }
  sql_query_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CreatePreparedStatementReq::mutable_sql_query() {
  set_has_sql_query();
  if (sql_query_ == &::google::protobuf::internal::kEmptyString) {
    sql_query_ = new ::std::string;
  }
  return sql_query_;
}
inline ::std::string* CreatePreparedStatementReq::release_sql_query() {
  clear_has_sql_query();
  if (sql_query_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = sql_query_;
    sql_query_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void CreatePreparedStatementReq::set_allocated_sql_query(::std::string* sql_query) {
  if (sql_query_ != &::google::protobuf::internal::kEmptyString) {
    delete sql_query_;
  }
  if (sql_query) {
    set_has_sql_query();
    sql_query_ = sql_query;
  } else {
    clear_has_sql_query();
    sql_query_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// -------------------------------------------------------------------

// ResultColumnMetadata

// optional string catalog_name = 1;
inline bool ResultColumnMetadata::has_catalog_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ResultColumnMetadata::set_has_catalog_name() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ResultColumnMetadata::clear_has_catalog_name() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ResultColumnMetadata::clear_catalog_name() {
  if (catalog_name_ != &::google::protobuf::internal::kEmptyString) {
    catalog_name_->clear();
  }
  clear_has_catalog_name();
}
inline const ::std::string& ResultColumnMetadata::catalog_name() const {
  return *catalog_name_;
}
inline void ResultColumnMetadata::set_catalog_name(const ::std::string& value) {
  set_has_catalog_name();
  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
    catalog_name_ = new ::std::string;
  }
  catalog_name_->assign(value);
}
inline void ResultColumnMetadata::set_catalog_name(const char* value) {
  set_has_catalog_name();
  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
    catalog_name_ = new ::std::string;
  }
  catalog_name_->assign(value);
}
inline void ResultColumnMetadata::set_catalog_name(const char* value, size_t size) {
  set_has_catalog_name();
  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
    catalog_name_ = new ::std::string;
  }
  catalog_name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ResultColumnMetadata::mutable_catalog_name() {
  set_has_catalog_name();
  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
    catalog_name_ = new ::std::string;
  }
  return catalog_name_;
}
inline ::std::string* ResultColumnMetadata::release_catalog_name() {
  clear_has_catalog_name();
  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = catalog_name_;
    catalog_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void ResultColumnMetadata::set_allocated_catalog_name(::std::string* catalog_name) {
  if (catalog_name_ != &::google::protobuf::internal::kEmptyString) {
    delete catalog_name_;
  }
  if (catalog_name) {
    set_has_catalog_name();
    catalog_name_ = catalog_name;
  } else {
    clear_has_catalog_name();
    catalog_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string schema_name = 2;
inline bool ResultColumnMetadata::has_schema_name() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ResultColumnMetadata::set_has_schema_name() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ResultColumnMetadata::clear_has_schema_name() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ResultColumnMetadata::clear_schema_name() {
  if (schema_name_ != &::google::protobuf::internal::kEmptyString) {
    schema_name_->clear();
  }
  clear_has_schema_name();
}
inline const ::std::string& ResultColumnMetadata::schema_name() const {
  return *schema_name_;
}
inline void ResultColumnMetadata::set_schema_name(const ::std::string& value) {
  set_has_schema_name();
  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
    schema_name_ = new ::std::string;
  }
  schema_name_->assign(value);
}
inline void ResultColumnMetadata::set_schema_name(const char* value) {
  set_has_schema_name();
  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
    schema_name_ = new ::std::string;
  }
  schema_name_->assign(value);
}
inline void ResultColumnMetadata::set_schema_name(const char* value, size_t size) {
  set_has_schema_name();
  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
    schema_name_ = new ::std::string;
  }
  schema_name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ResultColumnMetadata::mutable_schema_name() {
  set_has_schema_name();
  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
    schema_name_ = new ::std::string;
  }
  return schema_name_;
}
inline ::std::string* ResultColumnMetadata::release_schema_name() {
  clear_has_schema_name();
  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = schema_name_;
    schema_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void ResultColumnMetadata::set_allocated_schema_name(::std::string* schema_name) {
  if (schema_name_ != &::google::protobuf::internal::kEmptyString) {
    delete schema_name_;
  }
  if (schema_name) {
    set_has_schema_name();
    schema_name_ = schema_name;
  } else {
    clear_has_schema_name();
    schema_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string table_name = 3;
inline bool ResultColumnMetadata::has_table_name() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ResultColumnMetadata::set_has_table_name() {
  _has_bits_[0] |= 0x00000004u;
}
inline void ResultColumnMetadata::clear_has_table_name() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void ResultColumnMetadata::clear_table_name() {
  if (table_name_ != &::google::protobuf::internal::kEmptyString) {
    table_name_->clear();
  }
  clear_has_table_name();
}
inline const ::std::string& ResultColumnMetadata::table_name() const {
  return *table_name_;
}
inline void ResultColumnMetadata::set_table_name(const ::std::string& value) {
  set_has_table_name();
  if (table_name_ == &::google::protobuf::internal::kEmptyString) {
    table_name_ = new ::std::string;
  }
  table_name_->assign(value);
}
inline void ResultColumnMetadata::set_table_name(const char* value) {
  set_has_table_name();
  if (table_name_ == &::google::protobuf::internal::kEmptyString) {
    table_name_ = new ::std::string;
  }
  table_name_->assign(value);
}
inline void ResultColumnMetadata::set_table_name(const char* value, size_t size) {
  set_has_table_name();
  if (table_name_ == &::google::protobuf::internal::kEmptyString) {
    table_name_ = new ::std::string;
  }
  table_name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ResultColumnMetadata::mutable_table_name() {
  set_has_table_name();
  if (table_name_ == &::google::protobuf::internal::kEmptyString) {
    table_name_ = new ::std::string;
  }
  return table_name_;
}
inline ::std::string* ResultColumnMetadata::release_table_name() {
  clear_has_table_name();
  if (table_name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = table_name_;
    table_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void ResultColumnMetadata::set_allocated_table_name(::std::string* table_name) {
  if (table_name_ != &::google::protobuf::internal::kEmptyString) {
    delete table_name_;
  }
  if (table_name) {
    set_has_table_name();
    table_name_ = table_name;
  } else {
    clear_has_table_name();
    table_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string column_name = 4;
inline bool ResultColumnMetadata::has_column_name() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ResultColumnMetadata::set_has_column_name() {
  _has_bits_[0] |= 0x00000008u;
}
inline void ResultColumnMetadata::clear_has_column_name() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void ResultColumnMetadata::clear_column_name() {
  if (column_name_ != &::google::protobuf::internal::kEmptyString) {
    column_name_->clear();
  }
  clear_has_column_name();
}
inline const ::std::string& ResultColumnMetadata::column_name() const {
  return *column_name_;
}
inline void ResultColumnMetadata::set_column_name(const ::std::string& value) {
  set_has_column_name();
  if (column_name_ == &::google::protobuf::internal::kEmptyString) {
    column_name_ = new ::std::string;
  }
  column_name_->assign(value);
}
inline void ResultColumnMetadata::set_column_name(const char* value) {
  set_has_column_name();
  if (column_name_ == &::google::protobuf::internal::kEmptyString) {
    column_name_ = new ::std::string;
  }
  column_name_->assign(value);
}
inline void ResultColumnMetadata::set_column_name(const char* value, size_t size) {
  set_has_column_name();
  if (column_name_ == &::google::protobuf::internal::kEmptyString) {
    column_name_ = new ::std::string;
  }
  column_name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ResultColumnMetadata::mutable_column_name() {
  set_has_column_name();
  if (column_name_ == &::google::protobuf::internal::kEmptyString) {
    column_name_ = new ::std::string;
  }
  return column_name_;
}
inline ::std::string* ResultColumnMetadata::release_column_name() {
  clear_has_column_name();
  if (column_name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = column_name_;
    column_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void ResultColumnMetadata::set_allocated_column_name(::std::string* column_name) {
  if (column_name_ != &::google::protobuf::internal::kEmptyString) {
    delete column_name_;
  }
  if (column_name) {
    set_has_column_name();
    column_name_ = column_name;
  } else {
    clear_has_column_name();
    column_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string label = 5;
inline bool ResultColumnMetadata::has_label() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void ResultColumnMetadata::set_has_label() {
  _has_bits_[0] |= 0x00000010u;
}
inline void ResultColumnMetadata::clear_has_label() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void ResultColumnMetadata::clear_label() {
  if (label_ != &::google::protobuf::internal::kEmptyString) {
    label_->clear();
  }
  clear_has_label();
}
inline const ::std::string& ResultColumnMetadata::label() const {
  return *label_;
}
inline void ResultColumnMetadata::set_label(const ::std::string& value) {
  set_has_label();
  if (label_ == &::google::protobuf::internal::kEmptyString) {
    label_ = new ::std::string;
  }
  label_->assign(value);
}
inline void ResultColumnMetadata::set_label(const char* value) {
  set_has_label();
  if (label_ == &::google::protobuf::internal::kEmptyString) {
    label_ = new ::std::string;
  }
  label_->assign(value);
}
inline void ResultColumnMetadata::set_label(const char* value, size_t size) {
  set_has_label();
  if (label_ == &::google::protobuf::internal::kEmptyString) {
    label_ = new ::std::string;
  }
  label_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ResultColumnMetadata::mutable_label() {
  set_has_label();
  if (label_ == &::google::protobuf::internal::kEmptyString) {
    label_ = new ::std::string;
  }
  return label_;
}
inline ::std::string* ResultColumnMetadata::release_label() {
  clear_has_label();
  if (label_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = label_;
    label_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void ResultColumnMetadata::set_allocated_label(::std::string* label) {
  if (label_ != &::google::protobuf::internal::kEmptyString) {
    delete label_;
  }
  if (label) {
    set_has_label();
    label_ = label;
  } else {
    clear_has_label();
    label_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string data_type = 6;
inline bool ResultColumnMetadata::has_data_type() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void ResultColumnMetadata::set_has_data_type() {
  _has_bits_[0] |= 0x00000020u;
}
inline void ResultColumnMetadata::clear_has_data_type() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void ResultColumnMetadata::clear_data_type() {
  if (data_type_ != &::google::protobuf::internal::kEmptyString) {
    data_type_->clear();
  }
  clear_has_data_type();
}
inline const ::std::string& ResultColumnMetadata::data_type() const {
  return *data_type_;
}
inline void ResultColumnMetadata::set_data_type(const ::std::string& value) {
  set_has_data_type();
  if (data_type_ == &::google::protobuf::internal::kEmptyString) {
    data_type_ = new ::std::string;
  }
  data_type_->assign(value);
}
inline void ResultColumnMetadata::set_data_type(const char* value) {
  set_has_data_type();
  if (data_type_ == &::google::protobuf::internal::kEmptyString) {
    data_type_ = new ::std::string;
  }
  data_type_->assign(value);
}
inline void ResultColumnMetadata::set_data_type(const char* value, size_t size) {
  set_has_data_type();
  if (data_type_ == &::google::protobuf::internal::kEmptyString) {
    data_type_ = new ::std::string;
  }
  data_type_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ResultColumnMetadata::mutable_data_type() {
  set_has_data_type();
  if (data_type_ == &::google::protobuf::internal::kEmptyString) {
    data_type_ = new ::std::string;
  }
  return data_type_;
}
inline ::std::string* ResultColumnMetadata::release_data_type() {
  clear_has_data_type();
  if (data_type_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = data_type_;
    data_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void ResultColumnMetadata::set_allocated_data_type(::std::string* data_type) {
  if (data_type_ != &::google::protobuf::internal::kEmptyString) {
    delete data_type_;
  }
  if (data_type) {
    set_has_data_type();
    data_type_ = data_type;
  } else {
    clear_has_data_type();
    data_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional bool is_nullable = 7;
inline bool ResultColumnMetadata::has_is_nullable() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void ResultColumnMetadata::set_has_is_nullable() {
  _has_bits_[0] |= 0x00000040u;
}
inline void ResultColumnMetadata::clear_has_is_nullable() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void ResultColumnMetadata::clear_is_nullable() {
  is_nullable_ = false;
  clear_has_is_nullable();
}
inline bool ResultColumnMetadata::is_nullable() const {
  return is_nullable_;
}
inline void ResultColumnMetadata::set_is_nullable(bool value) {
  set_has_is_nullable();
  is_nullable_ = value;
}

// optional int32 precision = 8;
inline bool ResultColumnMetadata::has_precision() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void ResultColumnMetadata::set_has_precision() {
  _has_bits_[0] |= 0x00000080u;
}
inline void ResultColumnMetadata::clear_has_precision() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void ResultColumnMetadata::clear_precision() {
  precision_ = 0;
  clear_has_precision();
}
inline ::google::protobuf::int32 ResultColumnMetadata::precision() const {
  return precision_;
}
inline void ResultColumnMetadata::set_precision(::google::protobuf::int32 value) {
  set_has_precision();
  precision_ = value;
}

// optional int32 scale = 9;
inline bool ResultColumnMetadata::has_scale() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void ResultColumnMetadata::set_has_scale() {
  _has_bits_[0] |= 0x00000100u;
}
inline void ResultColumnMetadata::clear_has_scale() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void ResultColumnMetadata::clear_scale() {
  scale_ = 0;
  clear_has_scale();
}
inline ::google::protobuf::int32 ResultColumnMetadata::scale() const {
  return scale_;
}
inline void ResultColumnMetadata::set_scale(::google::protobuf::int32 value) {
  set_has_scale();
  scale_ = value;
}

// optional bool signed = 10;
inline bool ResultColumnMetadata::has_signed_() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void ResultColumnMetadata::set_has_signed_() {
  _has_bits_[0] |= 0x00000200u;
}
inline void ResultColumnMetadata::clear_has_signed_() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void ResultColumnMetadata::clear_signed_() {
  signed__ = false;
  clear_has_signed_();
}
inline bool ResultColumnMetadata::signed_() const {
  return signed__;
}
inline void ResultColumnMetadata::set_signed_(bool value) {
  set_has_signed_();
  signed__ = value;
}

// optional int32 display_size = 11;
inline bool ResultColumnMetadata::has_display_size() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void ResultColumnMetadata::set_has_display_size() {
  _has_bits_[0] |= 0x00000400u;
}
inline void ResultColumnMetadata::clear_has_display_size() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void ResultColumnMetadata::clear_display_size() {
  display_size_ = 0;
  clear_has_display_size();
}
inline ::google::protobuf::int32 ResultColumnMetadata::display_size() const {
  return display_size_;
}
inline void ResultColumnMetadata::set_display_size(::google::protobuf::int32 value) {
  set_has_display_size();
  display_size_ = value;
}

// optional bool is_aliased = 12;
inline bool ResultColumnMetadata::has_is_aliased() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void ResultColumnMetadata::set_has_is_aliased() {
  _has_bits_[0] |= 0x00000800u;
}
inline void ResultColumnMetadata::clear_has_is_aliased() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void ResultColumnMetadata::clear_is_aliased() {
  is_aliased_ = false;
  clear_has_is_aliased();
}
inline bool ResultColumnMetadata::is_aliased() const {
  return is_aliased_;
}
inline void ResultColumnMetadata::set_is_aliased(bool value) {
  set_has_is_aliased();
  is_aliased_ = value;
}

// optional .exec.user.ColumnSearchability searchability = 13;
inline bool ResultColumnMetadata::has_searchability() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void ResultColumnMetadata::set_has_searchability() {
  _has_bits_[0] |= 0x00001000u;
}
inline void ResultColumnMetadata::clear_has_searchability() {
  _has_bits_[0] &= ~0x00001000u;
}
inline void ResultColumnMetadata::clear_searchability() {
  searchability_ = 0;
  clear_has_searchability();
}
inline ::exec::user::ColumnSearchability ResultColumnMetadata::searchability() const {
  return static_cast< ::exec::user::ColumnSearchability >(searchability_);
}
inline void ResultColumnMetadata::set_searchability(::exec::user::ColumnSearchability value) {
  assert(::exec::user::ColumnSearchability_IsValid(value));
  set_has_searchability();
  searchability_ = value;
}

// optional .exec.user.ColumnUpdatability updatability = 14;
inline bool ResultColumnMetadata::has_updatability() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void ResultColumnMetadata::set_has_updatability() {
  _has_bits_[0] |= 0x00002000u;
}
inline void ResultColumnMetadata::clear_has_updatability() {
  _has_bits_[0] &= ~0x00002000u;
}
inline void ResultColumnMetadata::clear_updatability() {
  updatability_ = 0;
  clear_has_updatability();
}
inline ::exec::user::ColumnUpdatability ResultColumnMetadata::updatability() const {
  return static_cast< ::exec::user::ColumnUpdatability >(updatability_);
}
inline void ResultColumnMetadata::set_updatability(::exec::user::ColumnUpdatability value) {
  assert(::exec::user::ColumnUpdatability_IsValid(value));
  set_has_updatability();
  updatability_ = value;
}

// optional bool auto_increment = 15;
inline bool ResultColumnMetadata::has_auto_increment() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void ResultColumnMetadata::set_has_auto_increment() {
  _has_bits_[0] |= 0x00004000u;
}
inline void ResultColumnMetadata::clear_has_auto_increment() {
  _has_bits_[0] &= ~0x00004000u;
}
inline void ResultColumnMetadata::clear_auto_increment() {
  auto_increment_ = false;
  clear_has_auto_increment();
}
inline bool ResultColumnMetadata::auto_increment() const {
  return auto_increment_;
}
inline void ResultColumnMetadata::set_auto_increment(bool value) {
  set_has_auto_increment();
  auto_increment_ = value;
}

// optional bool case_sensitivity = 16;
inline bool ResultColumnMetadata::has_case_sensitivity() const {
  return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void ResultColumnMetadata::set_has_case_sensitivity() {
  _has_bits_[0] |= 0x00008000u;
}
inline void ResultColumnMetadata::clear_has_case_sensitivity() {
  _has_bits_[0] &= ~0x00008000u;
}
inline void ResultColumnMetadata::clear_case_sensitivity() {
  case_sensitivity_ = false;
  clear_has_case_sensitivity();
}
inline bool ResultColumnMetadata::case_sensitivity() const {
  return case_sensitivity_;
}
inline void ResultColumnMetadata::set_case_sensitivity(bool value) {
  set_has_case_sensitivity();
  case_sensitivity_ = value;
}

// optional bool sortable = 17;
inline bool ResultColumnMetadata::has_sortable() const {
  return (_has_bits_[0] & 0x00010000u) != 0;
}
inline void ResultColumnMetadata::set_has_sortable() {
  _has_bits_[0] |= 0x00010000u;
}
inline void ResultColumnMetadata::clear_has_sortable() {
  _has_bits_[0] &= ~0x00010000u;
}
inline void ResultColumnMetadata::clear_sortable() {
  sortable_ = false;
  clear_has_sortable();
}
inline bool ResultColumnMetadata::sortable() const {
  return sortable_;
}
inline void ResultColumnMetadata::set_sortable(bool value) {
  set_has_sortable();
  sortable_ = value;
}

// optional string class_name = 18;
inline bool ResultColumnMetadata::has_class_name() const {
  return (_has_bits_[0] & 0x00020000u) != 0;
}
inline void ResultColumnMetadata::set_has_class_name() {
  _has_bits_[0] |= 0x00020000u;
}
inline void ResultColumnMetadata::clear_has_class_name() {
  _has_bits_[0] &= ~0x00020000u;
}
inline void ResultColumnMetadata::clear_class_name() {
  if (class_name_ != &::google::protobuf::internal::kEmptyString) {
    class_name_->clear();
  }
  clear_has_class_name();
}
inline const ::std::string& ResultColumnMetadata::class_name() const {
  return *class_name_;
}
inline void ResultColumnMetadata::set_class_name(const ::std::string& value) {
  set_has_class_name();
  if (class_name_ == &::google::protobuf::internal::kEmptyString) {
    class_name_ = new ::std::string;
  }
  class_name_->assign(value);
}
inline void ResultColumnMetadata::set_class_name(const char* value) {
  set_has_class_name();
  if (class_name_ == &::google::protobuf::internal::kEmptyString) {
    class_name_ = new ::std::string;
  }
  class_name_->assign(value);
}
inline void ResultColumnMetadata::set_class_name(const char* value, size_t size) {
  set_has_class_name();
  if (class_name_ == &::google::protobuf::internal::kEmptyString) {
    class_name_ = new ::std::string;
  }
  class_name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ResultColumnMetadata::mutable_class_name() {
  set_has_class_name();
  if (class_name_ == &::google::protobuf::internal::kEmptyString) {
    class_name_ = new ::std::string;
  }
  return class_name_;
}
inline ::std::string* ResultColumnMetadata::release_class_name() {
  clear_has_class_name();
  if (class_name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = class_name_;
    class_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void ResultColumnMetadata::set_allocated_class_name(::std::string* class_name) {
  if (class_name_ != &::google::protobuf::internal::kEmptyString) {
    delete class_name_;
  }
  if (class_name) {
    set_has_class_name();
    class_name_ = class_name;
  } else {
    clear_has_class_name();
    class_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional bool is_currency = 20;
inline bool ResultColumnMetadata::has_is_currency() const {
  return (_has_bits_[0] & 0x00040000u) != 0;
}
inline void ResultColumnMetadata::set_has_is_currency() {
  _has_bits_[0] |= 0x00040000u;
}
inline void ResultColumnMetadata::clear_has_is_currency() {
  _has_bits_[0] &= ~0x00040000u;
}
inline void ResultColumnMetadata::clear_is_currency() {
  is_currency_ = false;
  clear_has_is_currency();
}
inline bool ResultColumnMetadata::is_currency() const {
  return is_currency_;
}
inline void ResultColumnMetadata::set_is_currency(bool value) {
  set_has_is_currency();
  is_currency_ = value;
}

// -------------------------------------------------------------------

// PreparedStatementHandle

// optional bytes server_info = 1;
inline bool PreparedStatementHandle::has_server_info() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void PreparedStatementHandle::set_has_server_info() {
  _has_bits_[0] |= 0x00000001u;
}
inline void PreparedStatementHandle::clear_has_server_info() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void PreparedStatementHandle::clear_server_info() {
  if (server_info_ != &::google::protobuf::internal::kEmptyString) {
    server_info_->clear();
  }
  clear_has_server_info();
}
inline const ::std::string& PreparedStatementHandle::server_info() const {
  return *server_info_;
}
inline void PreparedStatementHandle::set_server_info(const ::std::string& value) {
  set_has_server_info();
  if (server_info_ == &::google::protobuf::internal::kEmptyString) {
    server_info_ = new ::std::string;
  }
  server_info_->assign(value);
}
inline void PreparedStatementHandle::set_server_info(const char* value) {
  set_has_server_info();
  if (server_info_ == &::google::protobuf::internal::kEmptyString) {
    server_info_ = new ::std::string;
  }
  server_info_->assign(value);
}
inline void PreparedStatementHandle::set_server_info(const void* value, size_t size) {
  set_has_server_info();
  if (server_info_ == &::google::protobuf::internal::kEmptyString) {
    server_info_ = new ::std::string;
  }
  server_info_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* PreparedStatementHandle::mutable_server_info() {
  set_has_server_info();
  if (server_info_ == &::google::protobuf::internal::kEmptyString) {
    server_info_ = new ::std::string;
  }
  return server_info_;
}
inline ::std::string* PreparedStatementHandle::release_server_info() {
  clear_has_server_info();
  if (server_info_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = server_info_;
    server_info_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void PreparedStatementHandle::set_allocated_server_info(::std::string* server_info) {
  if (server_info_ != &::google::protobuf::internal::kEmptyString) {
    delete server_info_;
  }
  if (server_info) {
    set_has_server_info();
    server_info_ = server_info;
  } else {
    clear_has_server_info();
    server_info_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// -------------------------------------------------------------------

// PreparedStatement

// repeated .exec.user.ResultColumnMetadata columns = 1;
inline int PreparedStatement::columns_size() const {
  return columns_.size();
}
inline void PreparedStatement::clear_columns() {
  columns_.Clear();
}
inline const ::exec::user::ResultColumnMetadata& PreparedStatement::columns(int index) const {
  return columns_.Get(index);
}
inline ::exec::user::ResultColumnMetadata* PreparedStatement::mutable_columns(int index) {
  return columns_.Mutable(index);
}
inline ::exec::user::ResultColumnMetadata* PreparedStatement::add_columns() {
  return columns_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::exec::user::ResultColumnMetadata >&
PreparedStatement::columns() const {
  return columns_;
}
inline ::google::protobuf::RepeatedPtrField< ::exec::user::ResultColumnMetadata >*
PreparedStatement::mutable_columns() {
  return &columns_;
}

// optional .exec.user.PreparedStatementHandle server_handle = 2;
inline bool PreparedStatement::has_server_handle() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void PreparedStatement::set_has_server_handle() {
  _has_bits_[0] |= 0x00000002u;
}
inline void PreparedStatement::clear_has_server_handle() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void PreparedStatement::clear_server_handle() {
  if (server_handle_ != NULL) server_handle_->::exec::user::PreparedStatementHandle::Clear();
  clear_has_server_handle();
}
inline const ::exec::user::PreparedStatementHandle& PreparedStatement::server_handle() const {
  return server_handle_ != NULL ? *server_handle_ : *default_instance_->server_handle_;
}
inline ::exec::user::PreparedStatementHandle* PreparedStatement::mutable_server_handle() {
  set_has_server_handle();
  if (server_handle_ == NULL) server_handle_ = new ::exec::user::PreparedStatementHandle;
  return server_handle_;
}
inline ::exec::user::PreparedStatementHandle* PreparedStatement::release_server_handle() {
  clear_has_server_handle();
  ::exec::user::PreparedStatementHandle* temp = server_handle_;
  server_handle_ = NULL;
  return temp;
}
inline void PreparedStatement::set_allocated_server_handle(::exec::user::PreparedStatementHandle* server_handle) {
  delete server_handle_;
  server_handle_ = server_handle;
  if (server_handle) {
    set_has_server_handle();
  } else {
    clear_has_server_handle();
  }
}

// -------------------------------------------------------------------

// CreatePreparedStatementResp

// optional .exec.user.RequestStatus status = 1;
inline bool CreatePreparedStatementResp::has_status() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CreatePreparedStatementResp::set_has_status() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CreatePreparedStatementResp::clear_has_status() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CreatePreparedStatementResp::clear_status() {
  status_ = 0;
  clear_has_status();
}
inline ::exec::user::RequestStatus CreatePreparedStatementResp::status() const {
  return static_cast< ::exec::user::RequestStatus >(status_);
}
inline void CreatePreparedStatementResp::set_status(::exec::user::RequestStatus value) {
  assert(::exec::user::RequestStatus_IsValid(value));
  set_has_status();
  status_ = value;
}

// optional .exec.user.PreparedStatement prepared_statement = 2;
inline bool CreatePreparedStatementResp::has_prepared_statement() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CreatePreparedStatementResp::set_has_prepared_statement() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CreatePreparedStatementResp::clear_has_prepared_statement() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CreatePreparedStatementResp::clear_prepared_statement() {
  if (prepared_statement_ != NULL) prepared_statement_->::exec::user::PreparedStatement::Clear();
  clear_has_prepared_statement();
}
inline const ::exec::user::PreparedStatement& CreatePreparedStatementResp::prepared_statement() const {
  return prepared_statement_ != NULL ? *prepared_statement_ : *default_instance_->prepared_statement_;
}
inline ::exec::user::PreparedStatement* CreatePreparedStatementResp::mutable_prepared_statement() {
  set_has_prepared_statement();
  if (prepared_statement_ == NULL) prepared_statement_ = new ::exec::user::PreparedStatement;
  return prepared_statement_;
}
inline ::exec::user::PreparedStatement* CreatePreparedStatementResp::release_prepared_statement() {
  clear_has_prepared_statement();
  ::exec::user::PreparedStatement* temp = prepared_statement_;
  prepared_statement_ = NULL;
  return temp;
}
inline void CreatePreparedStatementResp::set_allocated_prepared_statement(::exec::user::PreparedStatement* prepared_statement) {
  delete prepared_statement_;
  prepared_statement_ = prepared_statement;
  if (prepared_statement) {
    set_has_prepared_statement();
  } else {
    clear_has_prepared_statement();
  }
}

// optional .exec.shared.DrillPBError error = 3;
inline bool CreatePreparedStatementResp::has_error() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void CreatePreparedStatementResp::set_has_error() {
  _has_bits_[0] |= 0x00000004u;
}
inline void CreatePreparedStatementResp::clear_has_error() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void CreatePreparedStatementResp::clear_error() {
  if (error_ != NULL) error_->::exec::shared::DrillPBError::Clear();
  clear_has_error();
}
inline const ::exec::shared::DrillPBError& CreatePreparedStatementResp::error() const {
  return error_ != NULL ? *error_ : *default_instance_->error_;
}
inline ::exec::shared::DrillPBError* CreatePreparedStatementResp::mutable_error() {
  set_has_error();
  if (error_ == NULL) error_ = new ::exec::shared::DrillPBError;
  return error_;
}
inline ::exec::shared::DrillPBError* CreatePreparedStatementResp::release_error() {
  clear_has_error();
  ::exec::shared::DrillPBError* temp = error_;
  error_ = NULL;
  return temp;
}
inline void CreatePreparedStatementResp::set_allocated_error(::exec::shared::DrillPBError* error) {
  delete error_;
  error_ = error;
  if (error) {
    set_has_error();
  } else {
    clear_has_error();
  }
}

// -------------------------------------------------------------------

// GetServerMetaReq

// -------------------------------------------------------------------

// ConvertSupport

// required .common.MinorType from = 1;
inline bool ConvertSupport::has_from() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ConvertSupport::set_has_from() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ConvertSupport::clear_has_from() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ConvertSupport::clear_from() {
  from_ = 0;
  clear_has_from();
}
inline ::common::MinorType ConvertSupport::from() const {
  return static_cast< ::common::MinorType >(from_);
}
inline void ConvertSupport::set_from(::common::MinorType value) {
  assert(::common::MinorType_IsValid(value));
  set_has_from();
  from_ = value;
}

// required .common.MinorType to = 2;
inline bool ConvertSupport::has_to() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ConvertSupport::set_has_to() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ConvertSupport::clear_has_to() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ConvertSupport::clear_to() {
  to_ = 0;
  clear_has_to();
}
inline ::common::MinorType ConvertSupport::to() const {
  return static_cast< ::common::MinorType >(to_);
}
inline void ConvertSupport::set_to(::common::MinorType value) {
  assert(::common::MinorType_IsValid(value));
  set_has_to();
  to_ = value;
}

// -------------------------------------------------------------------

// GetServerMetaResp

// optional .exec.user.RequestStatus status = 1;
inline bool GetServerMetaResp::has_status() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetServerMetaResp::set_has_status() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetServerMetaResp::clear_has_status() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetServerMetaResp::clear_status() {
  status_ = 0;
  clear_has_status();
}
inline ::exec::user::RequestStatus GetServerMetaResp::status() const {
  return static_cast< ::exec::user::RequestStatus >(status_);
}
inline void GetServerMetaResp::set_status(::exec::user::RequestStatus value) {
  assert(::exec::user::RequestStatus_IsValid(value));
  set_has_status();
  status_ = value;
}

// optional .exec.user.ServerMeta server_meta = 2;
inline bool GetServerMetaResp::has_server_meta() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GetServerMetaResp::set_has_server_meta() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GetServerMetaResp::clear_has_server_meta() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GetServerMetaResp::clear_server_meta() {
  if (server_meta_ != NULL) server_meta_->::exec::user::ServerMeta::Clear();
  clear_has_server_meta();
}
inline const ::exec::user::ServerMeta& GetServerMetaResp::server_meta() const {
  return server_meta_ != NULL ? *server_meta_ : *default_instance_->server_meta_;
}
inline ::exec::user::ServerMeta* GetServerMetaResp::mutable_server_meta() {
  set_has_server_meta();
  if (server_meta_ == NULL) server_meta_ = new ::exec::user::ServerMeta;
  return server_meta_;
}
inline ::exec::user::ServerMeta* GetServerMetaResp::release_server_meta() {
  clear_has_server_meta();
  ::exec::user::ServerMeta* temp = server_meta_;
  server_meta_ = NULL;
  return temp;
}
inline void GetServerMetaResp::set_allocated_server_meta(::exec::user::ServerMeta* server_meta) {
  delete server_meta_;
  server_meta_ = server_meta;
  if (server_meta) {
    set_has_server_meta();
  } else {
    clear_has_server_meta();
  }
}

// optional .exec.shared.DrillPBError error = 3;
inline bool GetServerMetaResp::has_error() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void GetServerMetaResp::set_has_error() {
  _has_bits_[0] |= 0x00000004u;
}
inline void GetServerMetaResp::clear_has_error() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void GetServerMetaResp::clear_error() {
  if (error_ != NULL) error_->::exec::shared::DrillPBError::Clear();
  clear_has_error();
}
inline const ::exec::shared::DrillPBError& GetServerMetaResp::error() const {
  return error_ != NULL ? *error_ : *default_instance_->error_;
}
inline ::exec::shared::DrillPBError* GetServerMetaResp::mutable_error() {
  set_has_error();
  if (error_ == NULL) error_ = new ::exec::shared::DrillPBError;
  return error_;
}
inline ::exec::shared::DrillPBError* GetServerMetaResp::release_error() {
  clear_has_error();
  ::exec::shared::DrillPBError* temp = error_;
  error_ = NULL;
  return temp;
}
inline void GetServerMetaResp::set_allocated_error(::exec::shared::DrillPBError* error) {
  delete error_;
  error_ = error;
  if (error) {
    set_has_error();
  } else {
    clear_has_error();
  }
}

// -------------------------------------------------------------------

// ServerMeta

// optional bool all_tables_selectable = 1;
inline bool ServerMeta::has_all_tables_selectable() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ServerMeta::set_has_all_tables_selectable() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ServerMeta::clear_has_all_tables_selectable() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ServerMeta::clear_all_tables_selectable() {
  all_tables_selectable_ = false;
  clear_has_all_tables_selectable();
}
inline bool ServerMeta::all_tables_selectable() const {
  return all_tables_selectable_;
}
inline void ServerMeta::set_all_tables_selectable(bool value) {
  set_has_all_tables_selectable();
  all_tables_selectable_ = value;
}

// optional bool blob_included_in_max_row_size = 2;
inline bool ServerMeta::has_blob_included_in_max_row_size() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ServerMeta::set_has_blob_included_in_max_row_size() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ServerMeta::clear_has_blob_included_in_max_row_size() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ServerMeta::clear_blob_included_in_max_row_size() {
  blob_included_in_max_row_size_ = false;
  clear_has_blob_included_in_max_row_size();
}
inline bool ServerMeta::blob_included_in_max_row_size() const {
  return blob_included_in_max_row_size_;
}
inline void ServerMeta::set_blob_included_in_max_row_size(bool value) {
  set_has_blob_included_in_max_row_size();
  blob_included_in_max_row_size_ = value;
}

// optional bool catalog_at_start = 3;
inline bool ServerMeta::has_catalog_at_start() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ServerMeta::set_has_catalog_at_start() {
  _has_bits_[0] |= 0x00000004u;
}
inline void ServerMeta::clear_has_catalog_at_start() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void ServerMeta::clear_catalog_at_start() {
  catalog_at_start_ = false;
  clear_has_catalog_at_start();
}
inline bool ServerMeta::catalog_at_start() const {
  return catalog_at_start_;
}
inline void ServerMeta::set_catalog_at_start(bool value) {
  set_has_catalog_at_start();
  catalog_at_start_ = value;
}

// optional string catalog_separator = 4;
inline bool ServerMeta::has_catalog_separator() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ServerMeta::set_has_catalog_separator() {
  _has_bits_[0] |= 0x00000008u;
}
inline void ServerMeta::clear_has_catalog_separator() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void ServerMeta::clear_catalog_separator() {
  if (catalog_separator_ != &::google::protobuf::internal::kEmptyString) {
    catalog_separator_->clear();
  }
  clear_has_catalog_separator();
}
inline const ::std::string& ServerMeta::catalog_separator() const {
  return *catalog_separator_;
}
inline void ServerMeta::set_catalog_separator(const ::std::string& value) {
  set_has_catalog_separator();
  if (catalog_separator_ == &::google::protobuf::internal::kEmptyString) {
    catalog_separator_ = new ::std::string;
  }
  catalog_separator_->assign(value);
}
inline void ServerMeta::set_catalog_separator(const char* value) {
  set_has_catalog_separator();
  if (catalog_separator_ == &::google::protobuf::internal::kEmptyString) {
    catalog_separator_ = new ::std::string;
  }
  catalog_separator_->assign(value);
}
inline void ServerMeta::set_catalog_separator(const char* value, size_t size) {
  set_has_catalog_separator();
  if (catalog_separator_ == &::google::protobuf::internal::kEmptyString) {
    catalog_separator_ = new ::std::string;
  }
  catalog_separator_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ServerMeta::mutable_catalog_separator() {
  set_has_catalog_separator();
  if (catalog_separator_ == &::google::protobuf::internal::kEmptyString) {
    catalog_separator_ = new ::std::string;
  }
  return catalog_separator_;
}
inline ::std::string* ServerMeta::release_catalog_separator() {
  clear_has_catalog_separator();
  if (catalog_separator_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = catalog_separator_;
    catalog_separator_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void ServerMeta::set_allocated_catalog_separator(::std::string* catalog_separator) {
  if (catalog_separator_ != &::google::protobuf::internal::kEmptyString) {
    delete catalog_separator_;
  }
  if (catalog_separator) {
    set_has_catalog_separator();
    catalog_separator_ = catalog_separator;
  } else {
    clear_has_catalog_separator();
    catalog_separator_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string catalog_term = 5;
inline bool ServerMeta::has_catalog_term() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void ServerMeta::set_has_catalog_term() {
  _has_bits_[0] |= 0x00000010u;
}
inline void ServerMeta::clear_has_catalog_term() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void ServerMeta::clear_catalog_term() {
  if (catalog_term_ != &::google::protobuf::internal::kEmptyString) {
    catalog_term_->clear();
  }
  clear_has_catalog_term();
}
inline const ::std::string& ServerMeta::catalog_term() const {
  return *catalog_term_;
}
inline void ServerMeta::set_catalog_term(const ::std::string& value) {
  set_has_catalog_term();
  if (catalog_term_ == &::google::protobuf::internal::kEmptyString) {
    catalog_term_ = new ::std::string;
  }
  catalog_term_->assign(value);
}
inline void ServerMeta::set_catalog_term(const char* value) {
  set_has_catalog_term();
  if (catalog_term_ == &::google::protobuf::internal::kEmptyString) {
    catalog_term_ = new ::std::string;
  }
  catalog_term_->assign(value);
}
inline void ServerMeta::set_catalog_term(const char* value, size_t size) {
  set_has_catalog_term();
  if (catalog_term_ == &::google::protobuf::internal::kEmptyString) {
    catalog_term_ = new ::std::string;
  }
  catalog_term_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ServerMeta::mutable_catalog_term() {
  set_has_catalog_term();
  if (catalog_term_ == &::google::protobuf::internal::kEmptyString) {
    catalog_term_ = new ::std::string;
  }
  return catalog_term_;
}
inline ::std::string* ServerMeta::release_catalog_term() {
  clear_has_catalog_term();
  if (catalog_term_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = catalog_term_;
    catalog_term_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void ServerMeta::set_allocated_catalog_term(::std::string* catalog_term) {
  if (catalog_term_ != &::google::protobuf::internal::kEmptyString) {
    delete catalog_term_;
  }
  if (catalog_term) {
    set_has_catalog_term();
    catalog_term_ = catalog_term;
  } else {
    clear_has_catalog_term();
    catalog_term_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// repeated .exec.user.CollateSupport collate_support = 6;
inline int ServerMeta::collate_support_size() const {
  return collate_support_.size();
}
inline void ServerMeta::clear_collate_support() {
  collate_support_.Clear();
}
inline ::exec::user::CollateSupport ServerMeta::collate_support(int index) const {
  return static_cast< ::exec::user::CollateSupport >(collate_support_.Get(index));
}
inline void ServerMeta::set_collate_support(int index, ::exec::user::CollateSupport value) {
  assert(::exec::user::CollateSupport_IsValid(value));
  collate_support_.Set(index, value);
}
inline void ServerMeta::add_collate_support(::exec::user::CollateSupport value) {
  assert(::exec::user::CollateSupport_IsValid(value));
  collate_support_.Add(value);
}
inline const ::google::protobuf::RepeatedField<int>&
ServerMeta::collate_support() const {
  return collate_support_;
}
inline ::google::protobuf::RepeatedField<int>*
ServerMeta::mutable_collate_support() {
  return &collate_support_;
}

// optional bool column_aliasing_supported = 7;
inline bool ServerMeta::has_column_aliasing_supported() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void ServerMeta::set_has_column_aliasing_supported() {
  _has_bits_[0] |= 0x00000040u;
}
inline void ServerMeta::clear_has_column_aliasing_supported() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void ServerMeta::clear_column_aliasing_supported() {
  column_aliasing_supported_ = false;
  clear_has_column_aliasing_supported();
}
inline bool ServerMeta::column_aliasing_supported() const {
  return column_aliasing_supported_;
}
inline void ServerMeta::set_column_aliasing_supported(bool value) {
  set_has_column_aliasing_supported();
  column_aliasing_supported_ = value;
}

// repeated .exec.user.ConvertSupport convert_support = 8;
inline int ServerMeta::convert_support_size() const {
  return convert_support_.size();
}
inline void ServerMeta::clear_convert_support() {
  convert_support_.Clear();
}
inline const ::exec::user::ConvertSupport& ServerMeta::convert_support(int index) const {
  return convert_support_.Get(index);
}
inline ::exec::user::ConvertSupport* ServerMeta::mutable_convert_support(int index) {
  return convert_support_.Mutable(index);
}
inline ::exec::user::ConvertSupport* ServerMeta::add_convert_support() {
  return convert_support_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::exec::user::ConvertSupport >&
ServerMeta::convert_support() const {
  return convert_support_;
}
inline ::google::protobuf::RepeatedPtrField< ::exec::user::ConvertSupport >*
ServerMeta::mutable_convert_support() {
  return &convert_support_;
}

// optional .exec.user.CorrelationNamesSupport correlation_names_support = 9;
inline bool ServerMeta::has_correlation_names_support() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void ServerMeta::set_has_correlation_names_support() {
  _has_bits_[0] |= 0x00000100u;
}
inline void ServerMeta::clear_has_correlation_names_support() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void ServerMeta::clear_correlation_names_support() {
  correlation_names_support_ = 1;
  clear_has_correlation_names_support();
}
inline ::exec::user::CorrelationNamesSupport ServerMeta::correlation_names_support() const {
  return static_cast< ::exec::user::CorrelationNamesSupport >(correlation_names_support_);
}
inline void ServerMeta::set_correlation_names_support(::exec::user::CorrelationNamesSupport value) {
  assert(::exec::user::CorrelationNamesSupport_IsValid(value));
  set_has_correlation_names_support();
  correlation_names_support_ = value;
}

// repeated string date_time_functions = 10;
inline int ServerMeta::date_time_functions_size() const {
  return date_time_functions_.size();
}
inline void ServerMeta::clear_date_time_functions() {
  date_time_functions_.Clear();
}
inline const ::std::string& ServerMeta::date_time_functions(int index) const {
  return date_time_functions_.Get(index);
}
inline ::std::string* ServerMeta::mutable_date_time_functions(int index) {
  return date_time_functions_.Mutable(index);
}
inline void ServerMeta::set_date_time_functions(int index, const ::std::string& value) {
  date_time_functions_.Mutable(index)->assign(value);
}
inline void ServerMeta::set_date_time_functions(int index, const char* value) {
  date_time_functions_.Mutable(index)->assign(value);
}
inline void ServerMeta::set_date_time_functions(int index, const char* value, size_t size) {
  date_time_functions_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ServerMeta::add_date_time_functions() {
  return date_time_functions_.Add();
}
inline void ServerMeta::add_date_time_functions(const ::std::string& value) {
  date_time_functions_.Add()->assign(value);
}
inline void ServerMeta::add_date_time_functions(const char* value) {
  date_time_functions_.Add()->assign(value);
}
inline void ServerMeta::add_date_time_functions(const char* value, size_t size) {
  date_time_functions_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
ServerMeta::date_time_functions() const {
  return date_time_functions_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
ServerMeta::mutable_date_time_functions() {
  return &date_time_functions_;
}

// repeated .exec.user.DateTimeLiteralsSupport date_time_literals_support = 11;
inline int ServerMeta::date_time_literals_support_size() const {
  return date_time_literals_support_.size();
}
inline void ServerMeta::clear_date_time_literals_support() {
  date_time_literals_support_.Clear();
}
inline ::exec::user::DateTimeLiteralsSupport ServerMeta::date_time_literals_support(int index) const {
  return static_cast< ::exec::user::DateTimeLiteralsSupport >(date_time_literals_support_.Get(index));
}
inline void ServerMeta::set_date_time_literals_support(int index, ::exec::user::DateTimeLiteralsSupport value) {
  assert(::exec::user::DateTimeLiteralsSupport_IsValid(value));
  date_time_literals_support_.Set(index, value);
}
inline void ServerMeta::add_date_time_literals_support(::exec::user::DateTimeLiteralsSupport value) {
  assert(::exec::user::DateTimeLiteralsSupport_IsValid(value));
  date_time_literals_support_.Add(value);
}
inline const ::google::protobuf::RepeatedField<int>&
ServerMeta::date_time_literals_support() const {
  return date_time_literals_support_;
}
inline ::google::protobuf::RepeatedField<int>*
ServerMeta::mutable_date_time_literals_support() {
  return &date_time_literals_support_;
}

// optional .exec.user.GroupBySupport group_by_support = 12;
inline bool ServerMeta::has_group_by_support() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void ServerMeta::set_has_group_by_support() {
  _has_bits_[0] |= 0x00000800u;
}
inline void ServerMeta::clear_has_group_by_support() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void ServerMeta::clear_group_by_support() {
  group_by_support_ = 1;
  clear_has_group_by_support();
}
inline ::exec::user::GroupBySupport ServerMeta::group_by_support() const {
  return static_cast< ::exec::user::GroupBySupport >(group_by_support_);
}
inline void ServerMeta::set_group_by_support(::exec::user::GroupBySupport value) {
  assert(::exec::user::GroupBySupport_IsValid(value));
  set_has_group_by_support();
  group_by_support_ = value;
}

// optional .exec.user.IdentifierCasing identifier_casing = 13;
inline bool ServerMeta::has_identifier_casing() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void ServerMeta::set_has_identifier_casing() {
  _has_bits_[0] |= 0x00001000u;
}
inline void ServerMeta::clear_has_identifier_casing() {
  _has_bits_[0] &= ~0x00001000u;
}
inline void ServerMeta::clear_identifier_casing() {
  identifier_casing_ = 0;
  clear_has_identifier_casing();
}
inline ::exec::user::IdentifierCasing ServerMeta::identifier_casing() const {
  return static_cast< ::exec::user::IdentifierCasing >(identifier_casing_);
}
inline void ServerMeta::set_identifier_casing(::exec::user::IdentifierCasing value) {
  assert(::exec::user::IdentifierCasing_IsValid(value));
  set_has_identifier_casing();
  identifier_casing_ = value;
}

// optional string identifier_quote_string = 14;
inline bool ServerMeta::has_identifier_quote_string() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void ServerMeta::set_has_identifier_quote_string() {
  _has_bits_[0] |= 0x00002000u;
}
inline void ServerMeta::clear_has_identifier_quote_string() {
  _has_bits_[0] &= ~0x00002000u;
}
inline void ServerMeta::clear_identifier_quote_string() {
  if (identifier_quote_string_ != &::google::protobuf::internal::kEmptyString) {
    identifier_quote_string_->clear();
  }
  clear_has_identifier_quote_string();
}
inline const ::std::string& ServerMeta::identifier_quote_string() const {
  return *identifier_quote_string_;
}
inline void ServerMeta::set_identifier_quote_string(const ::std::string& value) {
  set_has_identifier_quote_string();
  if (identifier_quote_string_ == &::google::protobuf::internal::kEmptyString) {
    identifier_quote_string_ = new ::std::string;
  }
  identifier_quote_string_->assign(value);
}
inline void ServerMeta::set_identifier_quote_string(const char* value) {
  set_has_identifier_quote_string();
  if (identifier_quote_string_ == &::google::protobuf::internal::kEmptyString) {
    identifier_quote_string_ = new ::std::string;
  }
  identifier_quote_string_->assign(value);
}
inline void ServerMeta::set_identifier_quote_string(const char* value, size_t size) {
  set_has_identifier_quote_string();
  if (identifier_quote_string_ == &::google::protobuf::internal::kEmptyString) {
    identifier_quote_string_ = new ::std::string;
  }
  identifier_quote_string_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ServerMeta::mutable_identifier_quote_string() {
  set_has_identifier_quote_string();
  if (identifier_quote_string_ == &::google::protobuf::internal::kEmptyString) {
    identifier_quote_string_ = new ::std::string;
  }
  return identifier_quote_string_;
}
inline ::std::string* ServerMeta::release_identifier_quote_string() {
  clear_has_identifier_quote_string();
  if (identifier_quote_string_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = identifier_quote_string_;
    identifier_quote_string_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void ServerMeta::set_allocated_identifier_quote_string(::std::string* identifier_quote_string) {
  if (identifier_quote_string_ != &::google::protobuf::internal::kEmptyString) {
    delete identifier_quote_string_;
  }
  if (identifier_quote_string) {
    set_has_identifier_quote_string();
    identifier_quote_string_ = identifier_quote_string;
  } else {
    clear_has_identifier_quote_string();
    identifier_quote_string_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional bool like_escape_clause_supported = 15;
inline bool ServerMeta::has_like_escape_clause_supported() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void ServerMeta::set_has_like_escape_clause_supported() {
  _has_bits_[0] |= 0x00004000u;
}
inline void ServerMeta::clear_has_like_escape_clause_supported() {
  _has_bits_[0] &= ~0x00004000u;
}
inline void ServerMeta::clear_like_escape_clause_supported() {
  like_escape_clause_supported_ = false;
  clear_has_like_escape_clause_supported();
}
inline bool ServerMeta::like_escape_clause_supported() const {
  return like_escape_clause_supported_;
}
inline void ServerMeta::set_like_escape_clause_supported(bool value) {
  set_has_like_escape_clause_supported();
  like_escape_clause_supported_ = value;
}

// optional uint32 max_binary_literal_length = 16;
inline bool ServerMeta::has_max_binary_literal_length() const {
  return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void ServerMeta::set_has_max_binary_literal_length() {
  _has_bits_[0] |= 0x00008000u;
}
inline void ServerMeta::clear_has_max_binary_literal_length() {
  _has_bits_[0] &= ~0x00008000u;
}
inline void ServerMeta::clear_max_binary_literal_length() {
  max_binary_literal_length_ = 0u;
  clear_has_max_binary_literal_length();
}
inline ::google::protobuf::uint32 ServerMeta::max_binary_literal_length() const {
  return max_binary_literal_length_;
}
inline void ServerMeta::set_max_binary_literal_length(::google::protobuf::uint32 value) {
  set_has_max_binary_literal_length();
  max_binary_literal_length_ = value;
}

// optional uint32 max_catalog_name_length = 17;
inline bool ServerMeta::has_max_catalog_name_length() const {
  return (_has_bits_[0] & 0x00010000u) != 0;
}
inline void ServerMeta::set_has_max_catalog_name_length() {
  _has_bits_[0] |= 0x00010000u;
}
inline void ServerMeta::clear_has_max_catalog_name_length() {
  _has_bits_[0] &= ~0x00010000u;
}
inline void ServerMeta::clear_max_catalog_name_length() {
  max_catalog_name_length_ = 0u;
  clear_has_max_catalog_name_length();
}
inline ::google::protobuf::uint32 ServerMeta::max_catalog_name_length() const {
  return max_catalog_name_length_;
}
inline void ServerMeta::set_max_catalog_name_length(::google::protobuf::uint32 value) {
  set_has_max_catalog_name_length();
  max_catalog_name_length_ = value;
}

// optional uint32 max_char_literal_length = 18;
inline bool ServerMeta::has_max_char_literal_length() const {
  return (_has_bits_[0] & 0x00020000u) != 0;
}
inline void ServerMeta::set_has_max_char_literal_length() {
  _has_bits_[0] |= 0x00020000u;
}
inline void ServerMeta::clear_has_max_char_literal_length() {
  _has_bits_[0] &= ~0x00020000u;
}
inline void ServerMeta::clear_max_char_literal_length() {
  max_char_literal_length_ = 0u;
  clear_has_max_char_literal_length();
}
inline ::google::protobuf::uint32 ServerMeta::max_char_literal_length() const {
  return max_char_literal_length_;
}
inline void ServerMeta::set_max_char_literal_length(::google::protobuf::uint32 value) {
  set_has_max_char_literal_length();
  max_char_literal_length_ = value;
}

// optional uint32 max_column_name_length = 19;
inline bool ServerMeta::has_max_column_name_length() const {
  return (_has_bits_[0] & 0x00040000u) != 0;
}
inline void ServerMeta::set_has_max_column_name_length() {
  _has_bits_[0] |= 0x00040000u;
}
inline void ServerMeta::clear_has_max_column_name_length() {
  _has_bits_[0] &= ~0x00040000u;
}
inline void ServerMeta::clear_max_column_name_length() {
  max_column_name_length_ = 0u;
  clear_has_max_column_name_length();
}
inline ::google::protobuf::uint32 ServerMeta::max_column_name_length() const {
  return max_column_name_length_;
}
inline void ServerMeta::set_max_column_name_length(::google::protobuf::uint32 value) {
  set_has_max_column_name_length();
  max_column_name_length_ = value;
}

// optional uint32 max_columns_in_group_by = 20;
inline bool ServerMeta::has_max_columns_in_group_by() const {
  return (_has_bits_[0] & 0x00080000u) != 0;
}
inline void ServerMeta::set_has_max_columns_in_group_by() {
  _has_bits_[0] |= 0x00080000u;
}
inline void ServerMeta::clear_has_max_columns_in_group_by() {
  _has_bits_[0] &= ~0x00080000u;
}
inline void ServerMeta::clear_max_columns_in_group_by() {
  max_columns_in_group_by_ = 0u;
  clear_has_max_columns_in_group_by();
}
inline ::google::protobuf::uint32 ServerMeta::max_columns_in_group_by() const {
  return max_columns_in_group_by_;
}
inline void ServerMeta::set_max_columns_in_group_by(::google::protobuf::uint32 value) {
  set_has_max_columns_in_group_by();
  max_columns_in_group_by_ = value;
}

// optional uint32 max_columns_in_order_by = 21;
inline bool ServerMeta::has_max_columns_in_order_by() const {
  return (_has_bits_[0] & 0x00100000u) != 0;
}
inline void ServerMeta::set_has_max_columns_in_order_by() {
  _has_bits_[0] |= 0x00100000u;
}
inline void ServerMeta::clear_has_max_columns_in_order_by() {
  _has_bits_[0] &= ~0x00100000u;
}
inline void ServerMeta::clear_max_columns_in_order_by() {
  max_columns_in_order_by_ = 0u;
  clear_has_max_columns_in_order_by();
}
inline ::google::protobuf::uint32 ServerMeta::max_columns_in_order_by() const {
  return max_columns_in_order_by_;
}
inline void ServerMeta::set_max_columns_in_order_by(::google::protobuf::uint32 value) {
  set_has_max_columns_in_order_by();
  max_columns_in_order_by_ = value;
}

// optional uint32 max_columns_in_select = 22;
inline bool ServerMeta::has_max_columns_in_select() const {
  return (_has_bits_[0] & 0x00200000u) != 0;
}
inline void ServerMeta::set_has_max_columns_in_select() {
  _has_bits_[0] |= 0x00200000u;
}
inline void ServerMeta::clear_has_max_columns_in_select() {
  _has_bits_[0] &= ~0x00200000u;
}
inline void ServerMeta::clear_max_columns_in_select() {
  max_columns_in_select_ = 0u;
  clear_has_max_columns_in_select();
}
inline ::google::protobuf::uint32 ServerMeta::max_columns_in_select() const {
  return max_columns_in_select_;
}
inline void ServerMeta::set_max_columns_in_select(::google::protobuf::uint32 value) {
  set_has_max_columns_in_select();
  max_columns_in_select_ = value;
}

// optional uint32 max_cursor_name_length = 23;
inline bool ServerMeta::has_max_cursor_name_length() const {
  return (_has_bits_[0] & 0x00400000u) != 0;
}
inline void ServerMeta::set_has_max_cursor_name_length() {
  _has_bits_[0] |= 0x00400000u;
}
inline void ServerMeta::clear_has_max_cursor_name_length() {
  _has_bits_[0] &= ~0x00400000u;
}
inline void ServerMeta::clear_max_cursor_name_length() {
  max_cursor_name_length_ = 0u;
  clear_has_max_cursor_name_length();
}
inline ::google::protobuf::uint32 ServerMeta::max_cursor_name_length() const {
  return max_cursor_name_length_;
}
inline void ServerMeta::set_max_cursor_name_length(::google::protobuf::uint32 value) {
  set_has_max_cursor_name_length();
  max_cursor_name_length_ = value;
}

// optional uint32 max_logical_lob_size = 24;
inline bool ServerMeta::has_max_logical_lob_size() const {
  return (_has_bits_[0] & 0x00800000u) != 0;
}
inline void ServerMeta::set_has_max_logical_lob_size() {
  _has_bits_[0] |= 0x00800000u;
}
inline void ServerMeta::clear_has_max_logical_lob_size() {
  _has_bits_[0] &= ~0x00800000u;
}
inline void ServerMeta::clear_max_logical_lob_size() {
  max_logical_lob_size_ = 0u;
  clear_has_max_logical_lob_size();
}
inline ::google::protobuf::uint32 ServerMeta::max_logical_lob_size() const {
  return max_logical_lob_size_;
}
inline void ServerMeta::set_max_logical_lob_size(::google::protobuf::uint32 value) {
  set_has_max_logical_lob_size();
  max_logical_lob_size_ = value;
}

// optional uint32 max_row_size = 25;
inline bool ServerMeta::has_max_row_size() const {
  return (_has_bits_[0] & 0x01000000u) != 0;
}
inline void ServerMeta::set_has_max_row_size() {
  _has_bits_[0] |= 0x01000000u;
}
inline void ServerMeta::clear_has_max_row_size() {
  _has_bits_[0] &= ~0x01000000u;
}
inline void ServerMeta::clear_max_row_size() {
  max_row_size_ = 0u;
  clear_has_max_row_size();
}
inline ::google::protobuf::uint32 ServerMeta::max_row_size() const {
  return max_row_size_;
}
inline void ServerMeta::set_max_row_size(::google::protobuf::uint32 value) {
  set_has_max_row_size();
  max_row_size_ = value;
}

// optional uint32 max_schema_name_length = 26;
inline bool ServerMeta::has_max_schema_name_length() const {
  return (_has_bits_[0] & 0x02000000u) != 0;
}
inline void ServerMeta::set_has_max_schema_name_length() {
  _has_bits_[0] |= 0x02000000u;
}
inline void ServerMeta::clear_has_max_schema_name_length() {
  _has_bits_[0] &= ~0x02000000u;
}
inline void ServerMeta::clear_max_schema_name_length() {
  max_schema_name_length_ = 0u;
  clear_has_max_schema_name_length();
}
inline ::google::protobuf::uint32 ServerMeta::max_schema_name_length() const {
  return max_schema_name_length_;
}
inline void ServerMeta::set_max_schema_name_length(::google::protobuf::uint32 value) {
  set_has_max_schema_name_length();
  max_schema_name_length_ = value;
}

// optional uint32 max_statement_length = 27;
inline bool ServerMeta::has_max_statement_length() const {
  return (_has_bits_[0] & 0x04000000u) != 0;
}
inline void ServerMeta::set_has_max_statement_length() {
  _has_bits_[0] |= 0x04000000u;
}
inline void ServerMeta::clear_has_max_statement_length() {
  _has_bits_[0] &= ~0x04000000u;
}
inline void ServerMeta::clear_max_statement_length() {
  max_statement_length_ = 0u;
  clear_has_max_statement_length();
}
inline ::google::protobuf::uint32 ServerMeta::max_statement_length() const {
  return max_statement_length_;
}
inline void ServerMeta::set_max_statement_length(::google::protobuf::uint32 value) {
  set_has_max_statement_length();
  max_statement_length_ = value;
}

// optional uint32 max_statements = 28;
inline bool ServerMeta::has_max_statements() const {
  return (_has_bits_[0] & 0x08000000u) != 0;
}
inline void ServerMeta::set_has_max_statements() {
  _has_bits_[0] |= 0x08000000u;
}
inline void ServerMeta::clear_has_max_statements() {
  _has_bits_[0] &= ~0x08000000u;
}
inline void ServerMeta::clear_max_statements() {
  max_statements_ = 0u;
  clear_has_max_statements();
}
inline ::google::protobuf::uint32 ServerMeta::max_statements() const {
  return max_statements_;
}
inline void ServerMeta::set_max_statements(::google::protobuf::uint32 value) {
  set_has_max_statements();
  max_statements_ = value;
}

// optional uint32 max_table_name_length = 29;
inline bool ServerMeta::has_max_table_name_length() const {
  return (_has_bits_[0] & 0x10000000u) != 0;
}
inline void ServerMeta::set_has_max_table_name_length() {
  _has_bits_[0] |= 0x10000000u;
}
inline void ServerMeta::clear_has_max_table_name_length() {
  _has_bits_[0] &= ~0x10000000u;
}
inline void ServerMeta::clear_max_table_name_length() {
  max_table_name_length_ = 0u;
  clear_has_max_table_name_length();
}
inline ::google::protobuf::uint32 ServerMeta::max_table_name_length() const {
  return max_table_name_length_;
}
inline void ServerMeta::set_max_table_name_length(::google::protobuf::uint32 value) {
  set_has_max_table_name_length();
  max_table_name_length_ = value;
}

// optional uint32 max_tables_in_select = 30;
inline bool ServerMeta::has_max_tables_in_select() const {
  return (_has_bits_[0] & 0x20000000u) != 0;
}
inline void ServerMeta::set_has_max_tables_in_select() {
  _has_bits_[0] |= 0x20000000u;
}
inline void ServerMeta::clear_has_max_tables_in_select() {
  _has_bits_[0] &= ~0x20000000u;
}
inline void ServerMeta::clear_max_tables_in_select() {
  max_tables_in_select_ = 0u;
  clear_has_max_tables_in_select();
}
inline ::google::protobuf::uint32 ServerMeta::max_tables_in_select() const {
  return max_tables_in_select_;
}
inline void ServerMeta::set_max_tables_in_select(::google::protobuf::uint32 value) {
  set_has_max_tables_in_select();
  max_tables_in_select_ = value;
}

// optional uint32 max_user_name_length = 31;
inline bool ServerMeta::has_max_user_name_length() const {
  return (_has_bits_[0] & 0x40000000u) != 0;
}
inline void ServerMeta::set_has_max_user_name_length() {
  _has_bits_[0] |= 0x40000000u;
}
inline void ServerMeta::clear_has_max_user_name_length() {
  _has_bits_[0] &= ~0x40000000u;
}
inline void ServerMeta::clear_max_user_name_length() {
  max_user_name_length_ = 0u;
  clear_has_max_user_name_length();
}
inline ::google::protobuf::uint32 ServerMeta::max_user_name_length() const {
  return max_user_name_length_;
}
inline void ServerMeta::set_max_user_name_length(::google::protobuf::uint32 value) {
  set_has_max_user_name_length();
  max_user_name_length_ = value;
}

// optional .exec.user.NullCollation null_collation = 32;
inline bool ServerMeta::has_null_collation() const {
  return (_has_bits_[0] & 0x80000000u) != 0;
}
inline void ServerMeta::set_has_null_collation() {
  _has_bits_[0] |= 0x80000000u;
}
inline void ServerMeta::clear_has_null_collation() {
  _has_bits_[0] &= ~0x80000000u;
}
inline void ServerMeta::clear_null_collation() {
  null_collation_ = 0;
  clear_has_null_collation();
}
inline ::exec::user::NullCollation ServerMeta::null_collation() const {
  return static_cast< ::exec::user::NullCollation >(null_collation_);
}
inline void ServerMeta::set_null_collation(::exec::user::NullCollation value) {
  assert(::exec::user::NullCollation_IsValid(value));
  set_has_null_collation();
  null_collation_ = value;
}

// optional bool null_plus_non_null_equals_null = 33;
inline bool ServerMeta::has_null_plus_non_null_equals_null() const {
  return (_has_bits_[1] & 0x00000001u) != 0;
}
inline void ServerMeta::set_has_null_plus_non_null_equals_null() {
  _has_bits_[1] |= 0x00000001u;
}
inline void ServerMeta::clear_has_null_plus_non_null_equals_null() {
  _has_bits_[1] &= ~0x00000001u;
}
inline void ServerMeta::clear_null_plus_non_null_equals_null() {
  null_plus_non_null_equals_null_ = false;
  clear_has_null_plus_non_null_equals_null();
}
inline bool ServerMeta::null_plus_non_null_equals_null() const {
  return null_plus_non_null_equals_null_;
}
inline void ServerMeta::set_null_plus_non_null_equals_null(bool value) {
  set_has_null_plus_non_null_equals_null();
  null_plus_non_null_equals_null_ = value;
}

// repeated string numeric_functions = 34;
inline int ServerMeta::numeric_functions_size() const {
  return numeric_functions_.size();
}
inline void ServerMeta::clear_numeric_functions() {
  numeric_functions_.Clear();
}
inline const ::std::string& ServerMeta::numeric_functions(int index) const {
  return numeric_functions_.Get(index);
}
inline ::std::string* ServerMeta::mutable_numeric_functions(int index) {
  return numeric_functions_.Mutable(index);
}
inline void ServerMeta::set_numeric_functions(int index, const ::std::string& value) {
  numeric_functions_.Mutable(index)->assign(value);
}
inline void ServerMeta::set_numeric_functions(int index, const char* value) {
  numeric_functions_.Mutable(index)->assign(value);
}
inline void ServerMeta::set_numeric_functions(int index, const char* value, size_t size) {
  numeric_functions_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ServerMeta::add_numeric_functions() {
  return numeric_functions_.Add();
}
inline void ServerMeta::add_numeric_functions(const ::std::string& value) {
  numeric_functions_.Add()->assign(value);
}
inline void ServerMeta::add_numeric_functions(const char* value) {
  numeric_functions_.Add()->assign(value);
}
inline void ServerMeta::add_numeric_functions(const char* value, size_t size) {
  numeric_functions_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
ServerMeta::numeric_functions() const {
  return numeric_functions_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
ServerMeta::mutable_numeric_functions() {
  return &numeric_functions_;
}

// repeated .exec.user.OrderBySupport order_by_support = 35;
inline int ServerMeta::order_by_support_size() const {
  return order_by_support_.size();
}
inline void ServerMeta::clear_order_by_support() {
  order_by_support_.Clear();
}
inline ::exec::user::OrderBySupport ServerMeta::order_by_support(int index) const {
  return static_cast< ::exec::user::OrderBySupport >(order_by_support_.Get(index));
}
inline void ServerMeta::set_order_by_support(int index, ::exec::user::OrderBySupport value) {
  assert(::exec::user::OrderBySupport_IsValid(value));
  order_by_support_.Set(index, value);
}
inline void ServerMeta::add_order_by_support(::exec::user::OrderBySupport value) {
  assert(::exec::user::OrderBySupport_IsValid(value));
  order_by_support_.Add(value);
}
inline const ::google::protobuf::RepeatedField<int>&
ServerMeta::order_by_support() const {
  return order_by_support_;
}
inline ::google::protobuf::RepeatedField<int>*
ServerMeta::mutable_order_by_support() {
  return &order_by_support_;
}

// repeated .exec.user.OuterJoinSupport outer_join_support = 36;
inline int ServerMeta::outer_join_support_size() const {
  return outer_join_support_.size();
}
inline void ServerMeta::clear_outer_join_support() {
  outer_join_support_.Clear();
}
inline ::exec::user::OuterJoinSupport ServerMeta::outer_join_support(int index) const {
  return static_cast< ::exec::user::OuterJoinSupport >(outer_join_support_.Get(index));
}
inline void ServerMeta::set_outer_join_support(int index, ::exec::user::OuterJoinSupport value) {
  assert(::exec::user::OuterJoinSupport_IsValid(value));
  outer_join_support_.Set(index, value);
}
inline void ServerMeta::add_outer_join_support(::exec::user::OuterJoinSupport value) {
  assert(::exec::user::OuterJoinSupport_IsValid(value));
  outer_join_support_.Add(value);
}
inline const ::google::protobuf::RepeatedField<int>&
ServerMeta::outer_join_support() const {
  return outer_join_support_;
}
inline ::google::protobuf::RepeatedField<int>*
ServerMeta::mutable_outer_join_support() {
  return &outer_join_support_;
}

// optional .exec.user.IdentifierCasing quoted_identifier_casing = 37;
inline bool ServerMeta::has_quoted_identifier_casing() const {
  return (_has_bits_[1] & 0x00000010u) != 0;
}
inline void ServerMeta::set_has_quoted_identifier_casing() {
  _has_bits_[1] |= 0x00000010u;
}
inline void ServerMeta::clear_has_quoted_identifier_casing() {
  _has_bits_[1] &= ~0x00000010u;
}
inline void ServerMeta::clear_quoted_identifier_casing() {
  quoted_identifier_casing_ = 0;
  clear_has_quoted_identifier_casing();
}
inline ::exec::user::IdentifierCasing ServerMeta::quoted_identifier_casing() const {
  return static_cast< ::exec::user::IdentifierCasing >(quoted_identifier_casing_);
}
inline void ServerMeta::set_quoted_identifier_casing(::exec::user::IdentifierCasing value) {
  assert(::exec::user::IdentifierCasing_IsValid(value));
  set_has_quoted_identifier_casing();
  quoted_identifier_casing_ = value;
}

// optional bool read_only = 38;
inline bool ServerMeta::has_read_only() const {
  return (_has_bits_[1] & 0x00000020u) != 0;
}
inline void ServerMeta::set_has_read_only() {
  _has_bits_[1] |= 0x00000020u;
}
inline void ServerMeta::clear_has_read_only() {
  _has_bits_[1] &= ~0x00000020u;
}
inline void ServerMeta::clear_read_only() {
  read_only_ = false;
  clear_has_read_only();
}
inline bool ServerMeta::read_only() const {
  return read_only_;
}
inline void ServerMeta::set_read_only(bool value) {
  set_has_read_only();
  read_only_ = value;
}

// optional string schema_term = 39;
inline bool ServerMeta::has_schema_term() const {
  return (_has_bits_[1] & 0x00000040u) != 0;
}
inline void ServerMeta::set_has_schema_term() {
  _has_bits_[1] |= 0x00000040u;
}
inline void ServerMeta::clear_has_schema_term() {
  _has_bits_[1] &= ~0x00000040u;
}
inline void ServerMeta::clear_schema_term() {
  if (schema_term_ != &::google::protobuf::internal::kEmptyString) {
    schema_term_->clear();
  }
  clear_has_schema_term();
}
inline const ::std::string& ServerMeta::schema_term() const {
  return *schema_term_;
}
inline void ServerMeta::set_schema_term(const ::std::string& value) {
  set_has_schema_term();
  if (schema_term_ == &::google::protobuf::internal::kEmptyString) {
    schema_term_ = new ::std::string;
  }
  schema_term_->assign(value);
}
inline void ServerMeta::set_schema_term(const char* value) {
  set_has_schema_term();
  if (schema_term_ == &::google::protobuf::internal::kEmptyString) {
    schema_term_ = new ::std::string;
  }
  schema_term_->assign(value);
}
inline void ServerMeta::set_schema_term(const char* value, size_t size) {
  set_has_schema_term();
  if (schema_term_ == &::google::protobuf::internal::kEmptyString) {
    schema_term_ = new ::std::string;
  }
  schema_term_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ServerMeta::mutable_schema_term() {
  set_has_schema_term();
  if (schema_term_ == &::google::protobuf::internal::kEmptyString) {
    schema_term_ = new ::std::string;
  }
  return schema_term_;
}
inline ::std::string* ServerMeta::release_schema_term() {
  clear_has_schema_term();
  if (schema_term_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = schema_term_;
    schema_term_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void ServerMeta::set_allocated_schema_term(::std::string* schema_term) {
  if (schema_term_ != &::google::protobuf::internal::kEmptyString) {
    delete schema_term_;
  }
  if (schema_term) {
    set_has_schema_term();
    schema_term_ = schema_term;
  } else {
    clear_has_schema_term();
    schema_term_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string search_escape_string = 40;
inline bool ServerMeta::has_search_escape_string() const {
  return (_has_bits_[1] & 0x00000080u) != 0;
}
inline void ServerMeta::set_has_search_escape_string() {
  _has_bits_[1] |= 0x00000080u;
}
inline void ServerMeta::clear_has_search_escape_string() {
  _has_bits_[1] &= ~0x00000080u;
}
inline void ServerMeta::clear_search_escape_string() {
  if (search_escape_string_ != &::google::protobuf::internal::kEmptyString) {
    search_escape_string_->clear();
  }
  clear_has_search_escape_string();
}
inline const ::std::string& ServerMeta::search_escape_string() const {
  return *search_escape_string_;
}
inline void ServerMeta::set_search_escape_string(const ::std::string& value) {
  set_has_search_escape_string();
  if (search_escape_string_ == &::google::protobuf::internal::kEmptyString) {
    search_escape_string_ = new ::std::string;
  }
  search_escape_string_->assign(value);
}
inline void ServerMeta::set_search_escape_string(const char* value) {
  set_has_search_escape_string();
  if (search_escape_string_ == &::google::protobuf::internal::kEmptyString) {
    search_escape_string_ = new ::std::string;
  }
  search_escape_string_->assign(value);
}
inline void ServerMeta::set_search_escape_string(const char* value, size_t size) {
  set_has_search_escape_string();
  if (search_escape_string_ == &::google::protobuf::internal::kEmptyString) {
    search_escape_string_ = new ::std::string;
  }
  search_escape_string_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ServerMeta::mutable_search_escape_string() {
  set_has_search_escape_string();
  if (search_escape_string_ == &::google::protobuf::internal::kEmptyString) {
    search_escape_string_ = new ::std::string;
  }
  return search_escape_string_;
}
inline ::std::string* ServerMeta::release_search_escape_string() {
  clear_has_search_escape_string();
  if (search_escape_string_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = search_escape_string_;
    search_escape_string_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void ServerMeta::set_allocated_search_escape_string(::std::string* search_escape_string) {
  if (search_escape_string_ != &::google::protobuf::internal::kEmptyString) {
    delete search_escape_string_;
  }
  if (search_escape_string) {
    set_has_search_escape_string();
    search_escape_string_ = search_escape_string;
  } else {
    clear_has_search_escape_string();
    search_escape_string_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional bool select_for_update_supported = 41;
inline bool ServerMeta::has_select_for_update_supported() const {
  return (_has_bits_[1] & 0x00000100u) != 0;
}
inline void ServerMeta::set_has_select_for_update_supported() {
  _has_bits_[1] |= 0x00000100u;
}
inline void ServerMeta::clear_has_select_for_update_supported() {
  _has_bits_[1] &= ~0x00000100u;
}
inline void ServerMeta::clear_select_for_update_supported() {
  select_for_update_supported_ = false;
  clear_has_select_for_update_supported();
}
inline bool ServerMeta::select_for_update_supported() const {
  return select_for_update_supported_;
}
inline void ServerMeta::set_select_for_update_supported(bool value) {
  set_has_select_for_update_supported();
  select_for_update_supported_ = value;
}

// optional string special_characters = 42;
inline bool ServerMeta::has_special_characters() const {
  return (_has_bits_[1] & 0x00000200u) != 0;
}
inline void ServerMeta::set_has_special_characters() {
  _has_bits_[1] |= 0x00000200u;
}
inline void ServerMeta::clear_has_special_characters() {
  _has_bits_[1] &= ~0x00000200u;
}
inline void ServerMeta::clear_special_characters() {
  if (special_characters_ != &::google::protobuf::internal::kEmptyString) {
    special_characters_->clear();
  }
  clear_has_special_characters();
}
inline const ::std::string& ServerMeta::special_characters() const {
  return *special_characters_;
}
inline void ServerMeta::set_special_characters(const ::std::string& value) {
  set_has_special_characters();
  if (special_characters_ == &::google::protobuf::internal::kEmptyString) {
    special_characters_ = new ::std::string;
  }
  special_characters_->assign(value);
}
inline void ServerMeta::set_special_characters(const char* value) {
  set_has_special_characters();
  if (special_characters_ == &::google::protobuf::internal::kEmptyString) {
    special_characters_ = new ::std::string;
  }
  special_characters_->assign(value);
}
inline void ServerMeta::set_special_characters(const char* value, size_t size) {
  set_has_special_characters();
  if (special_characters_ == &::google::protobuf::internal::kEmptyString) {
    special_characters_ = new ::std::string;
  }
  special_characters_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ServerMeta::mutable_special_characters() {
  set_has_special_characters();
  if (special_characters_ == &::google::protobuf::internal::kEmptyString) {
    special_characters_ = new ::std::string;
  }
  return special_characters_;
}
inline ::std::string* ServerMeta::release_special_characters() {
  clear_has_special_characters();
  if (special_characters_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = special_characters_;
    special_characters_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void ServerMeta::set_allocated_special_characters(::std::string* special_characters) {
  if (special_characters_ != &::google::protobuf::internal::kEmptyString) {
    delete special_characters_;
  }
  if (special_characters) {
    set_has_special_characters();
    special_characters_ = special_characters;
  } else {
    clear_has_special_characters();
    special_characters_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// repeated string sql_keywords = 43;
inline int ServerMeta::sql_keywords_size() const {
  return sql_keywords_.size();
}
inline void ServerMeta::clear_sql_keywords() {
  sql_keywords_.Clear();
}
inline const ::std::string& ServerMeta::sql_keywords(int index) const {
  return sql_keywords_.Get(index);
}
inline ::std::string* ServerMeta::mutable_sql_keywords(int index) {
  return sql_keywords_.Mutable(index);
}
inline void ServerMeta::set_sql_keywords(int index, const ::std::string& value) {
  sql_keywords_.Mutable(index)->assign(value);
}
inline void ServerMeta::set_sql_keywords(int index, const char* value) {
  sql_keywords_.Mutable(index)->assign(value);
}
inline void ServerMeta::set_sql_keywords(int index, const char* value, size_t size) {
  sql_keywords_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ServerMeta::add_sql_keywords() {
  return sql_keywords_.Add();
}
inline void ServerMeta::add_sql_keywords(const ::std::string& value) {
  sql_keywords_.Add()->assign(value);
}
inline void ServerMeta::add_sql_keywords(const char* value) {
  sql_keywords_.Add()->assign(value);
}
inline void ServerMeta::add_sql_keywords(const char* value, size_t size) {
  sql_keywords_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
ServerMeta::sql_keywords() const {
  return sql_keywords_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
ServerMeta::mutable_sql_keywords() {
  return &sql_keywords_;
}

// repeated string string_functions = 44;
inline int ServerMeta::string_functions_size() const {
  return string_functions_.size();
}
inline void ServerMeta::clear_string_functions() {
  string_functions_.Clear();
}
inline const ::std::string& ServerMeta::string_functions(int index) const {
  return string_functions_.Get(index);
}
inline ::std::string* ServerMeta::mutable_string_functions(int index) {
  return string_functions_.Mutable(index);
}
inline void ServerMeta::set_string_functions(int index, const ::std::string& value) {
  string_functions_.Mutable(index)->assign(value);
}
inline void ServerMeta::set_string_functions(int index, const char* value) {
  string_functions_.Mutable(index)->assign(value);
}
inline void ServerMeta::set_string_functions(int index, const char* value, size_t size) {
  string_functions_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ServerMeta::add_string_functions() {
  return string_functions_.Add();
}
inline void ServerMeta::add_string_functions(const ::std::string& value) {
  string_functions_.Add()->assign(value);
}
inline void ServerMeta::add_string_functions(const char* value) {
  string_functions_.Add()->assign(value);
}
inline void ServerMeta::add_string_functions(const char* value, size_t size) {
  string_functions_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
ServerMeta::string_functions() const {
  return string_functions_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
ServerMeta::mutable_string_functions() {
  return &string_functions_;
}

// repeated .exec.user.SubQuerySupport subquery_support = 45;
inline int ServerMeta::subquery_support_size() const {
  return subquery_support_.size();
}
inline void ServerMeta::clear_subquery_support() {
  subquery_support_.Clear();
}
inline ::exec::user::SubQuerySupport ServerMeta::subquery_support(int index) const {
  return static_cast< ::exec::user::SubQuerySupport >(subquery_support_.Get(index));
}
inline void ServerMeta::set_subquery_support(int index, ::exec::user::SubQuerySupport value) {
  assert(::exec::user::SubQuerySupport_IsValid(value));
  subquery_support_.Set(index, value);
}
inline void ServerMeta::add_subquery_support(::exec::user::SubQuerySupport value) {
  assert(::exec::user::SubQuerySupport_IsValid(value));
  subquery_support_.Add(value);
}
inline const ::google::protobuf::RepeatedField<int>&
ServerMeta::subquery_support() const {
  return subquery_support_;
}
inline ::google::protobuf::RepeatedField<int>*
ServerMeta::mutable_subquery_support() {
  return &subquery_support_;
}

// repeated string system_functions = 46;
inline int ServerMeta::system_functions_size() const {
  return system_functions_.size();
}
inline void ServerMeta::clear_system_functions() {
  system_functions_.Clear();
}
inline const ::std::string& ServerMeta::system_functions(int index) const {
  return system_functions_.Get(index);
}
inline ::std::string* ServerMeta::mutable_system_functions(int index) {
  return system_functions_.Mutable(index);
}
inline void ServerMeta::set_system_functions(int index, const ::std::string& value) {
  system_functions_.Mutable(index)->assign(value);
}
inline void ServerMeta::set_system_functions(int index, const char* value) {
  system_functions_.Mutable(index)->assign(value);
}
inline void ServerMeta::set_system_functions(int index, const char* value, size_t size) {
  system_functions_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ServerMeta::add_system_functions() {
  return system_functions_.Add();
}
inline void ServerMeta::add_system_functions(const ::std::string& value) {
  system_functions_.Add()->assign(value);
}
inline void ServerMeta::add_system_functions(const char* value) {
  system_functions_.Add()->assign(value);
}
inline void ServerMeta::add_system_functions(const char* value, size_t size) {
  system_functions_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
ServerMeta::system_functions() const {
  return system_functions_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
ServerMeta::mutable_system_functions() {
  return &system_functions_;
}

// optional string table_term = 47;
inline bool ServerMeta::has_table_term() const {
  return (_has_bits_[1] & 0x00004000u) != 0;
}
inline void ServerMeta::set_has_table_term() {
  _has_bits_[1] |= 0x00004000u;
}
inline void ServerMeta::clear_has_table_term() {
  _has_bits_[1] &= ~0x00004000u;
}
inline void ServerMeta::clear_table_term() {
  if (table_term_ != &::google::protobuf::internal::kEmptyString) {
    table_term_->clear();
  }
  clear_has_table_term();
}
inline const ::std::string& ServerMeta::table_term() const {
  return *table_term_;
}
inline void ServerMeta::set_table_term(const ::std::string& value) {
  set_has_table_term();
  if (table_term_ == &::google::protobuf::internal::kEmptyString) {
    table_term_ = new ::std::string;
  }
  table_term_->assign(value);
}
inline void ServerMeta::set_table_term(const char* value) {
  set_has_table_term();
  if (table_term_ == &::google::protobuf::internal::kEmptyString) {
    table_term_ = new ::std::string;
  }
  table_term_->assign(value);
}
inline void ServerMeta::set_table_term(const char* value, size_t size) {
  set_has_table_term();
  if (table_term_ == &::google::protobuf::internal::kEmptyString) {
    table_term_ = new ::std::string;
  }
  table_term_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ServerMeta::mutable_table_term() {
  set_has_table_term();
  if (table_term_ == &::google::protobuf::internal::kEmptyString) {
    table_term_ = new ::std::string;
  }
  return table_term_;
}
inline ::std::string* ServerMeta::release_table_term() {
  clear_has_table_term();
  if (table_term_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = table_term_;
    table_term_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void ServerMeta::set_allocated_table_term(::std::string* table_term) {
  if (table_term_ != &::google::protobuf::internal::kEmptyString) {
    delete table_term_;
  }
  if (table_term) {
    set_has_table_term();
    table_term_ = table_term;
  } else {
    clear_has_table_term();
    table_term_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional bool transaction_supported = 48;
inline bool ServerMeta::has_transaction_supported() const {
  return (_has_bits_[1] & 0x00008000u) != 0;
}
inline void ServerMeta::set_has_transaction_supported() {
  _has_bits_[1] |= 0x00008000u;
}
inline void ServerMeta::clear_has_transaction_supported() {
  _has_bits_[1] &= ~0x00008000u;
}
inline void ServerMeta::clear_transaction_supported() {
  transaction_supported_ = false;
  clear_has_transaction_supported();
}
inline bool ServerMeta::transaction_supported() const {
  return transaction_supported_;
}
inline void ServerMeta::set_transaction_supported(bool value) {
  set_has_transaction_supported();
  transaction_supported_ = value;
}

// repeated .exec.user.UnionSupport union_support = 49;
inline int ServerMeta::union_support_size() const {
  return union_support_.size();
}
inline void ServerMeta::clear_union_support() {
  union_support_.Clear();
}
inline ::exec::user::UnionSupport ServerMeta::union_support(int index) const {
  return static_cast< ::exec::user::UnionSupport >(union_support_.Get(index));
}
inline void ServerMeta::set_union_support(int index, ::exec::user::UnionSupport value) {
  assert(::exec::user::UnionSupport_IsValid(value));
  union_support_.Set(index, value);
}
inline void ServerMeta::add_union_support(::exec::user::UnionSupport value) {
  assert(::exec::user::UnionSupport_IsValid(value));
  union_support_.Add(value);
}
inline const ::google::protobuf::RepeatedField<int>&
ServerMeta::union_support() const {
  return union_support_;
}
inline ::google::protobuf::RepeatedField<int>*
ServerMeta::mutable_union_support() {
  return &union_support_;
}

// -------------------------------------------------------------------

// RunQuery

// optional .exec.user.QueryResultsMode results_mode = 1;
inline bool RunQuery::has_results_mode() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void RunQuery::set_has_results_mode() {
  _has_bits_[0] |= 0x00000001u;
}
inline void RunQuery::clear_has_results_mode() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void RunQuery::clear_results_mode() {
  results_mode_ = 1;
  clear_has_results_mode();
}
inline ::exec::user::QueryResultsMode RunQuery::results_mode() const {
  return static_cast< ::exec::user::QueryResultsMode >(results_mode_);
}
inline void RunQuery::set_results_mode(::exec::user::QueryResultsMode value) {
  assert(::exec::user::QueryResultsMode_IsValid(value));
  set_has_results_mode();
  results_mode_ = value;
}

// optional .exec.shared.QueryType type = 2;
inline bool RunQuery::has_type() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void RunQuery::set_has_type() {
  _has_bits_[0] |= 0x00000002u;
}
inline void RunQuery::clear_has_type() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void RunQuery::clear_type() {
  type_ = 1;
  clear_has_type();
}
inline ::exec::shared::QueryType RunQuery::type() const {
  return static_cast< ::exec::shared::QueryType >(type_);
}
inline void RunQuery::set_type(::exec::shared::QueryType value) {
  assert(::exec::shared::QueryType_IsValid(value));
  set_has_type();
  type_ = value;
}

// optional string plan = 3;
inline bool RunQuery::has_plan() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void RunQuery::set_has_plan() {
  _has_bits_[0] |= 0x00000004u;
}
inline void RunQuery::clear_has_plan() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void RunQuery::clear_plan() {
  if (plan_ != &::google::protobuf::internal::kEmptyString) {
    plan_->clear();
  }
  clear_has_plan();
}
inline const ::std::string& RunQuery::plan() const {
  return *plan_;
}
inline void RunQuery::set_plan(const ::std::string& value) {
  set_has_plan();
  if (plan_ == &::google::protobuf::internal::kEmptyString) {
    plan_ = new ::std::string;
  }
  plan_->assign(value);
}
inline void RunQuery::set_plan(const char* value) {
  set_has_plan();
  if (plan_ == &::google::protobuf::internal::kEmptyString) {
    plan_ = new ::std::string;
  }
  plan_->assign(value);
}
inline void RunQuery::set_plan(const char* value, size_t size) {
  set_has_plan();
  if (plan_ == &::google::protobuf::internal::kEmptyString) {
    plan_ = new ::std::string;
  }
  plan_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* RunQuery::mutable_plan() {
  set_has_plan();
  if (plan_ == &::google::protobuf::internal::kEmptyString) {
    plan_ = new ::std::string;
  }
  return plan_;
}
inline ::std::string* RunQuery::release_plan() {
  clear_has_plan();
  if (plan_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = plan_;
    plan_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void RunQuery::set_allocated_plan(::std::string* plan) {
  if (plan_ != &::google::protobuf::internal::kEmptyString) {
    delete plan_;
  }
  if (plan) {
    set_has_plan();
    plan_ = plan;
  } else {
    clear_has_plan();
    plan_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// repeated .exec.bit.control.PlanFragment fragments = 4;
inline int RunQuery::fragments_size() const {
  return fragments_.size();
}
inline void RunQuery::clear_fragments() {
  fragments_.Clear();
}
inline const ::exec::bit::control::PlanFragment& RunQuery::fragments(int index) const {
  return fragments_.Get(index);
}
inline ::exec::bit::control::PlanFragment* RunQuery::mutable_fragments(int index) {
  return fragments_.Mutable(index);
}
inline ::exec::bit::control::PlanFragment* RunQuery::add_fragments() {
  return fragments_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::exec::bit::control::PlanFragment >&
RunQuery::fragments() const {
  return fragments_;
}
inline ::google::protobuf::RepeatedPtrField< ::exec::bit::control::PlanFragment >*
RunQuery::mutable_fragments() {
  return &fragments_;
}

// optional .exec.user.PreparedStatementHandle prepared_statement_handle = 5;
inline bool RunQuery::has_prepared_statement_handle() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void RunQuery::set_has_prepared_statement_handle() {
  _has_bits_[0] |= 0x00000010u;
}
inline void RunQuery::clear_has_prepared_statement_handle() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void RunQuery::clear_prepared_statement_handle() {
  if (prepared_statement_handle_ != NULL) prepared_statement_handle_->::exec::user::PreparedStatementHandle::Clear();
  clear_has_prepared_statement_handle();
}
inline const ::exec::user::PreparedStatementHandle& RunQuery::prepared_statement_handle() const {
  return prepared_statement_handle_ != NULL ? *prepared_statement_handle_ : *default_instance_->prepared_statement_handle_;
}
inline ::exec::user::PreparedStatementHandle* RunQuery::mutable_prepared_statement_handle() {
  set_has_prepared_statement_handle();
  if (prepared_statement_handle_ == NULL) prepared_statement_handle_ = new ::exec::user::PreparedStatementHandle;
  return prepared_statement_handle_;
}
inline ::exec::user::PreparedStatementHandle* RunQuery::release_prepared_statement_handle() {
  clear_has_prepared_statement_handle();
  ::exec::user::PreparedStatementHandle* temp = prepared_statement_handle_;
  prepared_statement_handle_ = NULL;
  return temp;
}
inline void RunQuery::set_allocated_prepared_statement_handle(::exec::user::PreparedStatementHandle* prepared_statement_handle) {
  delete prepared_statement_handle_;
  prepared_statement_handle_ = prepared_statement_handle;
  if (prepared_statement_handle) {
    set_has_prepared_statement_handle();
  } else {
    clear_has_prepared_statement_handle();
  }
}


// @@protoc_insertion_point(namespace_scope)

}  // namespace user
}  // namespace exec

#ifndef SWIG
namespace google {
namespace protobuf {

template <>
inline const EnumDescriptor* GetEnumDescriptor< ::exec::user::RpcType>() {
  return ::exec::user::RpcType_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::exec::user::SaslSupport>() {
  return ::exec::user::SaslSupport_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::exec::user::QueryResultsMode>() {
  return ::exec::user::QueryResultsMode_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::exec::user::HandshakeStatus>() {
  return ::exec::user::HandshakeStatus_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::exec::user::RequestStatus>() {
  return ::exec::user::RequestStatus_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::exec::user::ColumnSearchability>() {
  return ::exec::user::ColumnSearchability_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::exec::user::ColumnUpdatability>() {
  return ::exec::user::ColumnUpdatability_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::exec::user::CollateSupport>() {
  return ::exec::user::CollateSupport_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::exec::user::CorrelationNamesSupport>() {
  return ::exec::user::CorrelationNamesSupport_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::exec::user::DateTimeLiteralsSupport>() {
  return ::exec::user::DateTimeLiteralsSupport_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::exec::user::GroupBySupport>() {
  return ::exec::user::GroupBySupport_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::exec::user::IdentifierCasing>() {
  return ::exec::user::IdentifierCasing_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::exec::user::NullCollation>() {
  return ::exec::user::NullCollation_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::exec::user::OrderBySupport>() {
  return ::exec::user::OrderBySupport_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::exec::user::OuterJoinSupport>() {
  return ::exec::user::OuterJoinSupport_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::exec::user::SubQuerySupport>() {
  return ::exec::user::SubQuerySupport_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::exec::user::UnionSupport>() {
  return ::exec::user::UnionSupport_descriptor();
}

}  // namespace google
}  // namespace protobuf
#endif  // SWIG

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_User_2eproto__INCLUDED
