// Generated by the protocol buffer compiler.  DO NOT EDIT!
// NO CHECKED-IN PROTOBUF GENCODE
// source: clickhouse_grpc.proto
// Protobuf C++ Version: 7.35.1

#ifndef clickhouse_5fgrpc_2eproto_2epb_2eh
#define clickhouse_5fgrpc_2eproto_2epb_2eh

#include <limits>
#include <string>
#include <type_traits>
#include <utility>

// clang-format off
#include "google/protobuf/runtime_version.h"
#if PROTOBUF_VERSION != 7035001
#error "Protobuf C++ gencode is built with an incompatible version of"
#error "Protobuf C++ headers/runtime. See"
#error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp"
#endif
#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/arena.h"
#include "google/protobuf/arenastring.h"
#include "google/protobuf/generated_message_tctable_decl.h"
#include "google/protobuf/generated_message_util.h"
#include "google/protobuf/metadata_lite.h"
#include "google/protobuf/generated_message_reflection.h"
#include "google/protobuf/message.h"
#include "google/protobuf/message_lite.h"
#include "google/protobuf/repeated_field.h"  // IWYU pragma: export
#include "google/protobuf/extension_set.h"  // IWYU pragma: export
#include "google/protobuf/map.h"  // IWYU pragma: export
#include "google/protobuf/map_type_handler.h"  // IWYU pragma: export
#include "google/protobuf/map_entry.h"
#include "google/protobuf/map_field.h"
#include "google/protobuf/generated_enum_reflection.h"
#include "google/protobuf/unknown_field_set.h"
// @@protoc_insertion_point(includes)

// Must be included last.
#include "google/protobuf/port_def.inc"

#define PROTOBUF_INTERNAL_EXPORT_clickhouse_5fgrpc_2eproto

namespace google {
namespace protobuf {
namespace internal {
template <typename T>
::absl::string_view GetAnyMessageName();
}  // namespace internal
}  // namespace protobuf
}  // namespace google

// Internal implementation detail -- do not use these members.
struct TableStruct_clickhouse_5fgrpc_2eproto {
  static const ::uint32_t offsets[];
};
extern "C" {
extern const ::google::protobuf::internal::DescriptorTable descriptor_table_clickhouse_5fgrpc_2eproto;
}  // extern "C"
namespace clickhouse {
namespace grpc {
enum LogsLevel : int;
extern const uint32_t LogsLevel_internal_data_[];
enum ObsoleteTransportCompression_CompressionAlgorithm : int;
extern const uint32_t ObsoleteTransportCompression_CompressionAlgorithm_internal_data_[];
enum ObsoleteTransportCompression_CompressionLevel : int;
extern const uint32_t ObsoleteTransportCompression_CompressionLevel_internal_data_[];
class Exception;
struct ExceptionGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern ExceptionGlobalsTypeInternal Exception_globals_;
extern const ::google::protobuf::internal::ClassDataFull Exception_class_data_;
#else
extern const ExceptionGlobalsTypeInternal Exception_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class ExternalTable;
struct ExternalTableGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern ExternalTableGlobalsTypeInternal ExternalTable_globals_;
extern const ::google::protobuf::internal::ClassDataFull ExternalTable_class_data_;
#else
extern const ExternalTableGlobalsTypeInternal ExternalTable_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class ExternalTable_SettingsEntry_DoNotUse;
struct ExternalTable_SettingsEntry_DoNotUseGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern ExternalTable_SettingsEntry_DoNotUseGlobalsTypeInternal ExternalTable_SettingsEntry_DoNotUse_globals_;
extern const ::google::protobuf::internal::ClassDataFull ExternalTable_SettingsEntry_DoNotUse_class_data_;
#else
extern const ExternalTable_SettingsEntry_DoNotUseGlobalsTypeInternal ExternalTable_SettingsEntry_DoNotUse_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class LogEntry;
struct LogEntryGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern LogEntryGlobalsTypeInternal LogEntry_globals_;
extern const ::google::protobuf::internal::ClassDataFull LogEntry_class_data_;
#else
extern const LogEntryGlobalsTypeInternal LogEntry_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class NameAndType;
struct NameAndTypeGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern NameAndTypeGlobalsTypeInternal NameAndType_globals_;
extern const ::google::protobuf::internal::ClassDataFull NameAndType_class_data_;
#else
extern const NameAndTypeGlobalsTypeInternal NameAndType_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class ObsoleteTransportCompression;
struct ObsoleteTransportCompressionGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern ObsoleteTransportCompressionGlobalsTypeInternal ObsoleteTransportCompression_globals_;
extern const ::google::protobuf::internal::ClassDataFull ObsoleteTransportCompression_class_data_;
#else
extern const ObsoleteTransportCompressionGlobalsTypeInternal ObsoleteTransportCompression_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class Progress;
struct ProgressGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern ProgressGlobalsTypeInternal Progress_globals_;
extern const ::google::protobuf::internal::ClassDataFull Progress_class_data_;
#else
extern const ProgressGlobalsTypeInternal Progress_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class QueryInfo;
struct QueryInfoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern QueryInfoGlobalsTypeInternal QueryInfo_globals_;
extern const ::google::protobuf::internal::ClassDataFull QueryInfo_class_data_;
#else
extern const QueryInfoGlobalsTypeInternal QueryInfo_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class QueryInfo_SettingsEntry_DoNotUse;
struct QueryInfo_SettingsEntry_DoNotUseGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern QueryInfo_SettingsEntry_DoNotUseGlobalsTypeInternal QueryInfo_SettingsEntry_DoNotUse_globals_;
extern const ::google::protobuf::internal::ClassDataFull QueryInfo_SettingsEntry_DoNotUse_class_data_;
#else
extern const QueryInfo_SettingsEntry_DoNotUseGlobalsTypeInternal QueryInfo_SettingsEntry_DoNotUse_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class Result;
struct ResultGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern ResultGlobalsTypeInternal Result_globals_;
extern const ::google::protobuf::internal::ClassDataFull Result_class_data_;
#else
extern const ResultGlobalsTypeInternal Result_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class Stats;
struct StatsGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern StatsGlobalsTypeInternal Stats_globals_;
extern const ::google::protobuf::internal::ClassDataFull Stats_class_data_;
#else
extern const StatsGlobalsTypeInternal Stats_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
}  // namespace grpc
}  // namespace clickhouse
namespace google {
namespace protobuf {
template <>
internal::EnumTraitsT<::clickhouse::grpc::LogsLevel_internal_data_>
    internal::EnumTraitsImpl::value<::clickhouse::grpc::LogsLevel>;
template <>
internal::EnumTraitsT<::clickhouse::grpc::ObsoleteTransportCompression_CompressionAlgorithm_internal_data_>
    internal::EnumTraitsImpl::value<::clickhouse::grpc::ObsoleteTransportCompression_CompressionAlgorithm>;
template <>
internal::EnumTraitsT<::clickhouse::grpc::ObsoleteTransportCompression_CompressionLevel_internal_data_>
    internal::EnumTraitsImpl::value<::clickhouse::grpc::ObsoleteTransportCompression_CompressionLevel>;
}  // namespace protobuf
}  // namespace google

namespace clickhouse {
namespace grpc {
enum ObsoleteTransportCompression_CompressionAlgorithm : int {
  ObsoleteTransportCompression_CompressionAlgorithm_NO_COMPRESSION = 0,
  ObsoleteTransportCompression_CompressionAlgorithm_DEFLATE = 1,
  ObsoleteTransportCompression_CompressionAlgorithm_GZIP = 2,
  ObsoleteTransportCompression_CompressionAlgorithm_STREAM_GZIP = 3,
  ObsoleteTransportCompression_CompressionAlgorithm_ObsoleteTransportCompression_CompressionAlgorithm_INT_MIN_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::min(),
  ObsoleteTransportCompression_CompressionAlgorithm_ObsoleteTransportCompression_CompressionAlgorithm_INT_MAX_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::max(),
};

extern const uint32_t ObsoleteTransportCompression_CompressionAlgorithm_internal_data_[];
inline constexpr ObsoleteTransportCompression_CompressionAlgorithm ObsoleteTransportCompression_CompressionAlgorithm_CompressionAlgorithm_MIN =
    static_cast<ObsoleteTransportCompression_CompressionAlgorithm>(0);
inline constexpr ObsoleteTransportCompression_CompressionAlgorithm ObsoleteTransportCompression_CompressionAlgorithm_CompressionAlgorithm_MAX =
    static_cast<ObsoleteTransportCompression_CompressionAlgorithm>(3);
[[nodiscard]] inline bool ObsoleteTransportCompression_CompressionAlgorithm_IsValid(int value) {
  return 0 <= value && value <= 3;
}
inline constexpr int ObsoleteTransportCompression_CompressionAlgorithm_CompressionAlgorithm_ARRAYSIZE = 3 + 1;
[[nodiscard]] const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL
ObsoleteTransportCompression_CompressionAlgorithm_descriptor();
[[nodiscard]] inline auto ProtobufInternalGetEnumDescriptor(ObsoleteTransportCompression_CompressionAlgorithm) {
  return ObsoleteTransportCompression_CompressionAlgorithm_descriptor();
}
template <typename T>
[[nodiscard]] const ::std::string& ObsoleteTransportCompression_CompressionAlgorithm_Name(T value) {
  static_assert(::std::is_same<T, ObsoleteTransportCompression_CompressionAlgorithm>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to CompressionAlgorithm_Name().");
  return ObsoleteTransportCompression_CompressionAlgorithm_Name(static_cast<ObsoleteTransportCompression_CompressionAlgorithm>(value));
}
template <>
[[nodiscard]] inline const ::std::string& ObsoleteTransportCompression_CompressionAlgorithm_Name(ObsoleteTransportCompression_CompressionAlgorithm value) {
  return ::google::protobuf::internal::NameOfDenseEnum<ObsoleteTransportCompression_CompressionAlgorithm_descriptor, 0, 3>(
      static_cast<int>(value));
}
[[nodiscard]] inline bool ObsoleteTransportCompression_CompressionAlgorithm_Parse(
    ::absl::string_view name, ObsoleteTransportCompression_CompressionAlgorithm* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<ObsoleteTransportCompression_CompressionAlgorithm>(ObsoleteTransportCompression_CompressionAlgorithm_descriptor(), name,
                                           value);
}
enum ObsoleteTransportCompression_CompressionLevel : int {
  ObsoleteTransportCompression_CompressionLevel_COMPRESSION_NONE = 0,
  ObsoleteTransportCompression_CompressionLevel_COMPRESSION_LOW = 1,
  ObsoleteTransportCompression_CompressionLevel_COMPRESSION_MEDIUM = 2,
  ObsoleteTransportCompression_CompressionLevel_COMPRESSION_HIGH = 3,
  ObsoleteTransportCompression_CompressionLevel_ObsoleteTransportCompression_CompressionLevel_INT_MIN_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::min(),
  ObsoleteTransportCompression_CompressionLevel_ObsoleteTransportCompression_CompressionLevel_INT_MAX_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::max(),
};

extern const uint32_t ObsoleteTransportCompression_CompressionLevel_internal_data_[];
inline constexpr ObsoleteTransportCompression_CompressionLevel ObsoleteTransportCompression_CompressionLevel_CompressionLevel_MIN =
    static_cast<ObsoleteTransportCompression_CompressionLevel>(0);
inline constexpr ObsoleteTransportCompression_CompressionLevel ObsoleteTransportCompression_CompressionLevel_CompressionLevel_MAX =
    static_cast<ObsoleteTransportCompression_CompressionLevel>(3);
[[nodiscard]] inline bool ObsoleteTransportCompression_CompressionLevel_IsValid(int value) {
  return 0 <= value && value <= 3;
}
inline constexpr int ObsoleteTransportCompression_CompressionLevel_CompressionLevel_ARRAYSIZE = 3 + 1;
[[nodiscard]] const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL
ObsoleteTransportCompression_CompressionLevel_descriptor();
[[nodiscard]] inline auto ProtobufInternalGetEnumDescriptor(ObsoleteTransportCompression_CompressionLevel) {
  return ObsoleteTransportCompression_CompressionLevel_descriptor();
}
template <typename T>
[[nodiscard]] const ::std::string& ObsoleteTransportCompression_CompressionLevel_Name(T value) {
  static_assert(::std::is_same<T, ObsoleteTransportCompression_CompressionLevel>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to CompressionLevel_Name().");
  return ObsoleteTransportCompression_CompressionLevel_Name(static_cast<ObsoleteTransportCompression_CompressionLevel>(value));
}
template <>
[[nodiscard]] inline const ::std::string& ObsoleteTransportCompression_CompressionLevel_Name(ObsoleteTransportCompression_CompressionLevel value) {
  return ::google::protobuf::internal::NameOfDenseEnum<ObsoleteTransportCompression_CompressionLevel_descriptor, 0, 3>(
      static_cast<int>(value));
}
[[nodiscard]] inline bool ObsoleteTransportCompression_CompressionLevel_Parse(
    ::absl::string_view name, ObsoleteTransportCompression_CompressionLevel* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<ObsoleteTransportCompression_CompressionLevel>(ObsoleteTransportCompression_CompressionLevel_descriptor(), name,
                                           value);
}
enum LogsLevel : int {
  CH_LOG_NONE = 0,
  CH_LOG_FATAL = 1,
  CH_LOG_CRITICAL = 2,
  CH_LOG_ERROR = 3,
  CH_LOG_WARNING = 4,
  CH_LOG_NOTICE = 5,
  CH_LOG_INFORMATION = 6,
  CH_LOG_DEBUG = 7,
  CH_LOG_TRACE = 8,
  LogsLevel_INT_MIN_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::min(),
  LogsLevel_INT_MAX_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::max(),
};

extern const uint32_t LogsLevel_internal_data_[];
inline constexpr LogsLevel LogsLevel_MIN =
    static_cast<LogsLevel>(0);
inline constexpr LogsLevel LogsLevel_MAX =
    static_cast<LogsLevel>(8);
[[nodiscard]] inline bool LogsLevel_IsValid(int value) {
  return 0 <= value && value <= 8;
}
inline constexpr int LogsLevel_ARRAYSIZE = 8 + 1;
[[nodiscard]] const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL
LogsLevel_descriptor();
[[nodiscard]] inline auto ProtobufInternalGetEnumDescriptor(LogsLevel) {
  return LogsLevel_descriptor();
}
template <typename T>
[[nodiscard]] const ::std::string& LogsLevel_Name(T value) {
  static_assert(::std::is_same<T, LogsLevel>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to LogsLevel_Name().");
  return LogsLevel_Name(static_cast<LogsLevel>(value));
}
template <>
[[nodiscard]] inline const ::std::string& LogsLevel_Name(LogsLevel value) {
  return ::google::protobuf::internal::NameOfDenseEnum<LogsLevel_descriptor, 0, 8>(
      static_cast<int>(value));
}
[[nodiscard]] inline bool LogsLevel_Parse(
    ::absl::string_view name, LogsLevel* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<LogsLevel>(LogsLevel_descriptor(), name,
                                           value);
}
using ::google::protobuf::internal::generated_enum::AbslParseFlag;
using ::google::protobuf::internal::generated_enum::AbslUnparseFlag;

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


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

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED Stats final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:clickhouse.grpc.Stats) */ {
 public:
  inline Stats() : Stats(nullptr) {}
  ~Stats() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(Stats* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(Stats));
  }
#endif

  template <typename = void>
  explicit constexpr Stats(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline Stats(const Stats& from) : Stats(nullptr, from) {}
  inline Stats(Stats&& from) noexcept : Stats(nullptr, ::std::move(from)) {}
  inline Stats& operator=(const Stats& from) {
    CopyFrom(from);
    return *this;
  }
  inline Stats& operator=(Stats&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const Stats& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<Stats>(&Stats_globals_);
  }
  static constexpr int kIndexInFileMessages = 8;
  friend void swap(Stats& a, Stats& b) { a.Swap(&b); }
  inline void Swap(Stats* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Stats* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] Stats* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<Stats>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const Stats& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const Stats& from) { Stats::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(Stats* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "clickhouse.grpc.Stats"; }

  explicit Stats(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  Stats(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Stats& from);
  Stats(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, Stats&& from) noexcept
      : Stats(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kRowsFieldNumber = 1,
    kBlocksFieldNumber = 2,
    kAllocatedBytesFieldNumber = 3,
    kRowsBeforeLimitFieldNumber = 5,
    kRowsBeforeAggregationFieldNumber = 7,
    kAppliedLimitFieldNumber = 4,
    kAppliedAggregationFieldNumber = 6,
  };
  // uint64 rows = 1;
  void clear_rows() ;
  [[nodiscard]] ::uint64_t rows() const;
  void set_rows(::uint64_t value);

  private:
  ::uint64_t _internal_rows() const;
  void _internal_set_rows(::uint64_t value);

  public:
  // uint64 blocks = 2;
  void clear_blocks() ;
  [[nodiscard]] ::uint64_t blocks() const;
  void set_blocks(::uint64_t value);

  private:
  ::uint64_t _internal_blocks() const;
  void _internal_set_blocks(::uint64_t value);

  public:
  // uint64 allocated_bytes = 3;
  void clear_allocated_bytes() ;
  [[nodiscard]] ::uint64_t allocated_bytes() const;
  void set_allocated_bytes(::uint64_t value);

  private:
  ::uint64_t _internal_allocated_bytes() const;
  void _internal_set_allocated_bytes(::uint64_t value);

  public:
  // uint64 rows_before_limit = 5;
  void clear_rows_before_limit() ;
  [[nodiscard]] ::uint64_t rows_before_limit() const;
  void set_rows_before_limit(::uint64_t value);

  private:
  ::uint64_t _internal_rows_before_limit() const;
  void _internal_set_rows_before_limit(::uint64_t value);

  public:
  // uint64 rows_before_aggregation = 7;
  void clear_rows_before_aggregation() ;
  [[nodiscard]] ::uint64_t rows_before_aggregation() const;
  void set_rows_before_aggregation(::uint64_t value);

  private:
  ::uint64_t _internal_rows_before_aggregation() const;
  void _internal_set_rows_before_aggregation(::uint64_t value);

  public:
  // bool applied_limit = 4;
  void clear_applied_limit() ;
  [[nodiscard]] bool applied_limit() const;
  void set_applied_limit(bool value);

  private:
  bool _internal_applied_limit() const;
  void _internal_set_applied_limit(bool value);

  public:
  // bool applied_aggregation = 6;
  void clear_applied_aggregation() ;
  [[nodiscard]] bool applied_aggregation() const;
  void set_applied_aggregation(bool value);

  private:
  bool _internal_applied_aggregation() const;
  void _internal_set_applied_aggregation(bool value);

  public:
  // @@protoc_insertion_point(class_scope:clickhouse.grpc.Stats)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<3, 7,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const Stats& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::uint64_t rows_;
    ::uint64_t blocks_;
    ::uint64_t allocated_bytes_;
    ::uint64_t rows_before_limit_;
    ::uint64_t rows_before_aggregation_;
    bool applied_limit_;
    bool applied_aggregation_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_clickhouse_5fgrpc_2eproto;
};
// -------------------------------------------------------------------

class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED QueryInfo_SettingsEntry_DoNotUse final
    : public ::google::protobuf::internal::MapEntry<::std::string, ::std::string,
                             ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
                             ::google::protobuf::internal::WireFormatLite::TYPE_STRING> {
 public:
  using SuperType =
      ::google::protobuf::internal::MapEntry<::std::string, ::std::string,
                      ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
                      ::google::protobuf::internal::WireFormatLite::TYPE_STRING>;
  QueryInfo_SettingsEntry_DoNotUse();
  template <typename = void>
  explicit constexpr QueryInfo_SettingsEntry_DoNotUse(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);
  explicit QueryInfo_SettingsEntry_DoNotUse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr const void* PROTOBUF_NONNULL internal_message_globals() {
    return &QueryInfo_SettingsEntry_DoNotUse_globals_;
  }


  static constexpr auto InternalGenerateClassData_(
      const ::google::protobuf::MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

 private:
  friend class ::google::protobuf::MessageLite;
  friend struct ::TableStruct_clickhouse_5fgrpc_2eproto;
  friend ::google::protobuf::internal::PrivateAccess;
  friend QueryInfo_SettingsEntry_DoNotUseGlobalsTypeInternal;

  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<1, 2,
                          0, 56,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED Progress final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:clickhouse.grpc.Progress) */ {
 public:
  inline Progress() : Progress(nullptr) {}
  ~Progress() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(Progress* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(Progress));
  }
#endif

  template <typename = void>
  explicit constexpr Progress(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline Progress(const Progress& from) : Progress(nullptr, from) {}
  inline Progress(Progress&& from) noexcept : Progress(nullptr, ::std::move(from)) {}
  inline Progress& operator=(const Progress& from) {
    CopyFrom(from);
    return *this;
  }
  inline Progress& operator=(Progress&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const Progress& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<Progress>(&Progress_globals_);
  }
  static constexpr int kIndexInFileMessages = 7;
  friend void swap(Progress& a, Progress& b) { a.Swap(&b); }
  inline void Swap(Progress* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Progress* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] Progress* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<Progress>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const Progress& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const Progress& from) { Progress::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(Progress* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "clickhouse.grpc.Progress"; }

  explicit Progress(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  Progress(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Progress& from);
  Progress(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, Progress&& from) noexcept
      : Progress(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kReadRowsFieldNumber = 1,
    kReadBytesFieldNumber = 2,
    kTotalRowsToReadFieldNumber = 3,
    kWrittenRowsFieldNumber = 4,
    kWrittenBytesFieldNumber = 5,
  };
  // uint64 read_rows = 1;
  void clear_read_rows() ;
  [[nodiscard]] ::uint64_t read_rows() const;
  void set_read_rows(::uint64_t value);

  private:
  ::uint64_t _internal_read_rows() const;
  void _internal_set_read_rows(::uint64_t value);

  public:
  // uint64 read_bytes = 2;
  void clear_read_bytes() ;
  [[nodiscard]] ::uint64_t read_bytes() const;
  void set_read_bytes(::uint64_t value);

  private:
  ::uint64_t _internal_read_bytes() const;
  void _internal_set_read_bytes(::uint64_t value);

  public:
  // uint64 total_rows_to_read = 3;
  void clear_total_rows_to_read() ;
  [[nodiscard]] ::uint64_t total_rows_to_read() const;
  void set_total_rows_to_read(::uint64_t value);

  private:
  ::uint64_t _internal_total_rows_to_read() const;
  void _internal_set_total_rows_to_read(::uint64_t value);

  public:
  // uint64 written_rows = 4;
  void clear_written_rows() ;
  [[nodiscard]] ::uint64_t written_rows() const;
  void set_written_rows(::uint64_t value);

  private:
  ::uint64_t _internal_written_rows() const;
  void _internal_set_written_rows(::uint64_t value);

  public:
  // uint64 written_bytes = 5;
  void clear_written_bytes() ;
  [[nodiscard]] ::uint64_t written_bytes() const;
  void set_written_bytes(::uint64_t value);

  private:
  ::uint64_t _internal_written_bytes() const;
  void _internal_set_written_bytes(::uint64_t value);

  public:
  // @@protoc_insertion_point(class_scope:clickhouse.grpc.Progress)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<3, 5,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const Progress& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::uint64_t read_rows_;
    ::uint64_t read_bytes_;
    ::uint64_t total_rows_to_read_;
    ::uint64_t written_rows_;
    ::uint64_t written_bytes_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_clickhouse_5fgrpc_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED ObsoleteTransportCompression final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:clickhouse.grpc.ObsoleteTransportCompression) */ {
 public:
  inline ObsoleteTransportCompression() : ObsoleteTransportCompression(nullptr) {}
  ~ObsoleteTransportCompression() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(ObsoleteTransportCompression* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(ObsoleteTransportCompression));
  }
#endif

  template <typename = void>
  explicit constexpr ObsoleteTransportCompression(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline ObsoleteTransportCompression(const ObsoleteTransportCompression& from) : ObsoleteTransportCompression(nullptr, from) {}
  inline ObsoleteTransportCompression(ObsoleteTransportCompression&& from) noexcept : ObsoleteTransportCompression(nullptr, ::std::move(from)) {}
  inline ObsoleteTransportCompression& operator=(const ObsoleteTransportCompression& from) {
    CopyFrom(from);
    return *this;
  }
  inline ObsoleteTransportCompression& operator=(ObsoleteTransportCompression&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const ObsoleteTransportCompression& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<ObsoleteTransportCompression>(&ObsoleteTransportCompression_globals_);
  }
  static constexpr int kIndexInFileMessages = 3;
  friend void swap(ObsoleteTransportCompression& a, ObsoleteTransportCompression& b) { a.Swap(&b); }
  inline void Swap(ObsoleteTransportCompression* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ObsoleteTransportCompression* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] ObsoleteTransportCompression* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<ObsoleteTransportCompression>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const ObsoleteTransportCompression& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const ObsoleteTransportCompression& from) { ObsoleteTransportCompression::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(ObsoleteTransportCompression* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "clickhouse.grpc.ObsoleteTransportCompression"; }

  explicit ObsoleteTransportCompression(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  ObsoleteTransportCompression(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ObsoleteTransportCompression& from);
  ObsoleteTransportCompression(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ObsoleteTransportCompression&& from) noexcept
      : ObsoleteTransportCompression(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------
  using CompressionAlgorithm = ObsoleteTransportCompression_CompressionAlgorithm;
  static constexpr CompressionAlgorithm NO_COMPRESSION = ObsoleteTransportCompression_CompressionAlgorithm_NO_COMPRESSION;
  static constexpr CompressionAlgorithm DEFLATE = ObsoleteTransportCompression_CompressionAlgorithm_DEFLATE;
  static constexpr CompressionAlgorithm GZIP = ObsoleteTransportCompression_CompressionAlgorithm_GZIP;
  static constexpr CompressionAlgorithm STREAM_GZIP = ObsoleteTransportCompression_CompressionAlgorithm_STREAM_GZIP;
  [[nodiscard]] static inline bool CompressionAlgorithm_IsValid(int value) {
    return ObsoleteTransportCompression_CompressionAlgorithm_IsValid(value);
  }
  static constexpr CompressionAlgorithm CompressionAlgorithm_MIN = ObsoleteTransportCompression_CompressionAlgorithm_CompressionAlgorithm_MIN;
  static constexpr CompressionAlgorithm CompressionAlgorithm_MAX = ObsoleteTransportCompression_CompressionAlgorithm_CompressionAlgorithm_MAX;
  static constexpr int CompressionAlgorithm_ARRAYSIZE = ObsoleteTransportCompression_CompressionAlgorithm_CompressionAlgorithm_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL CompressionAlgorithm_descriptor() {
    return ObsoleteTransportCompression_CompressionAlgorithm_descriptor();
  }
  template <typename T>
  [[nodiscard]] static inline const ::std::string& CompressionAlgorithm_Name(T value) {
    return ObsoleteTransportCompression_CompressionAlgorithm_Name(value);
  }
  [[nodiscard]] static inline bool CompressionAlgorithm_Parse(
      ::absl::string_view name, CompressionAlgorithm* PROTOBUF_NONNULL value) {
    return ObsoleteTransportCompression_CompressionAlgorithm_Parse(name, value);
  }
  using CompressionLevel = ObsoleteTransportCompression_CompressionLevel;
  static constexpr CompressionLevel COMPRESSION_NONE = ObsoleteTransportCompression_CompressionLevel_COMPRESSION_NONE;
  static constexpr CompressionLevel COMPRESSION_LOW = ObsoleteTransportCompression_CompressionLevel_COMPRESSION_LOW;
  static constexpr CompressionLevel COMPRESSION_MEDIUM = ObsoleteTransportCompression_CompressionLevel_COMPRESSION_MEDIUM;
  static constexpr CompressionLevel COMPRESSION_HIGH = ObsoleteTransportCompression_CompressionLevel_COMPRESSION_HIGH;
  [[nodiscard]] static inline bool CompressionLevel_IsValid(int value) {
    return ObsoleteTransportCompression_CompressionLevel_IsValid(value);
  }
  static constexpr CompressionLevel CompressionLevel_MIN = ObsoleteTransportCompression_CompressionLevel_CompressionLevel_MIN;
  static constexpr CompressionLevel CompressionLevel_MAX = ObsoleteTransportCompression_CompressionLevel_CompressionLevel_MAX;
  static constexpr int CompressionLevel_ARRAYSIZE = ObsoleteTransportCompression_CompressionLevel_CompressionLevel_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL CompressionLevel_descriptor() {
    return ObsoleteTransportCompression_CompressionLevel_descriptor();
  }
  template <typename T>
  [[nodiscard]] static inline const ::std::string& CompressionLevel_Name(T value) {
    return ObsoleteTransportCompression_CompressionLevel_Name(value);
  }
  [[nodiscard]] static inline bool CompressionLevel_Parse(
      ::absl::string_view name, CompressionLevel* PROTOBUF_NONNULL value) {
    return ObsoleteTransportCompression_CompressionLevel_Parse(name, value);
  }

  // accessors -------------------------------------------------------
  enum : int {
    kAlgorithmFieldNumber = 1,
    kLevelFieldNumber = 2,
  };
  // .clickhouse.grpc.ObsoleteTransportCompression.CompressionAlgorithm algorithm = 1;
  void clear_algorithm() ;
  [[nodiscard]] ::clickhouse::grpc::ObsoleteTransportCompression_CompressionAlgorithm algorithm() const;
  void set_algorithm(::clickhouse::grpc::ObsoleteTransportCompression_CompressionAlgorithm value);

  private:
  ::clickhouse::grpc::ObsoleteTransportCompression_CompressionAlgorithm _internal_algorithm() const;
  void _internal_set_algorithm(::clickhouse::grpc::ObsoleteTransportCompression_CompressionAlgorithm value);

  public:
  // .clickhouse.grpc.ObsoleteTransportCompression.CompressionLevel level = 2;
  void clear_level() ;
  [[nodiscard]] ::clickhouse::grpc::ObsoleteTransportCompression_CompressionLevel level() const;
  void set_level(::clickhouse::grpc::ObsoleteTransportCompression_CompressionLevel value);

  private:
  ::clickhouse::grpc::ObsoleteTransportCompression_CompressionLevel _internal_level() const;
  void _internal_set_level(::clickhouse::grpc::ObsoleteTransportCompression_CompressionLevel value);

  public:
  // @@protoc_insertion_point(class_scope:clickhouse.grpc.ObsoleteTransportCompression)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<1, 2,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const ObsoleteTransportCompression& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    int algorithm_;
    int level_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_clickhouse_5fgrpc_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED NameAndType final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:clickhouse.grpc.NameAndType) */ {
 public:
  inline NameAndType() : NameAndType(nullptr) {}
  ~NameAndType() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(NameAndType* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(NameAndType));
  }
#endif

  template <typename = void>
  explicit constexpr NameAndType(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline NameAndType(const NameAndType& from) : NameAndType(nullptr, from) {}
  inline NameAndType(NameAndType&& from) noexcept : NameAndType(nullptr, ::std::move(from)) {}
  inline NameAndType& operator=(const NameAndType& from) {
    CopyFrom(from);
    return *this;
  }
  inline NameAndType& operator=(NameAndType&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const NameAndType& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<NameAndType>(&NameAndType_globals_);
  }
  static constexpr int kIndexInFileMessages = 0;
  friend void swap(NameAndType& a, NameAndType& b) { a.Swap(&b); }
  inline void Swap(NameAndType* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(NameAndType* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] NameAndType* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<NameAndType>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const NameAndType& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const NameAndType& from) { NameAndType::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(NameAndType* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "clickhouse.grpc.NameAndType"; }

  explicit NameAndType(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  NameAndType(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const NameAndType& from);
  NameAndType(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, NameAndType&& from) noexcept
      : NameAndType(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kNameFieldNumber = 1,
    kTypeFieldNumber = 2,
  };
  // string name = 1;
  void clear_name() ;
  [[nodiscard]] const ::std::string& name() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_name();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_name();
  void set_allocated_name(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_name() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_name(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_name();

  public:
  // string type = 2;
  void clear_type() ;
  [[nodiscard]] const ::std::string& type() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_type(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_type();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_type();
  void set_allocated_type(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_type() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_type(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_type();

  public:
  // @@protoc_insertion_point(class_scope:clickhouse.grpc.NameAndType)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<1, 2,
                          0, 44,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const NameAndType& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr name_;
    ::google::protobuf::internal::ArenaStringPtr type_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_clickhouse_5fgrpc_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED LogEntry final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:clickhouse.grpc.LogEntry) */ {
 public:
  inline LogEntry() : LogEntry(nullptr) {}
  ~LogEntry() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(LogEntry* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(LogEntry));
  }
#endif

  template <typename = void>
  explicit constexpr LogEntry(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline LogEntry(const LogEntry& from) : LogEntry(nullptr, from) {}
  inline LogEntry(LogEntry&& from) noexcept : LogEntry(nullptr, ::std::move(from)) {}
  inline LogEntry& operator=(const LogEntry& from) {
    CopyFrom(from);
    return *this;
  }
  inline LogEntry& operator=(LogEntry&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const LogEntry& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<LogEntry>(&LogEntry_globals_);
  }
  static constexpr int kIndexInFileMessages = 6;
  friend void swap(LogEntry& a, LogEntry& b) { a.Swap(&b); }
  inline void Swap(LogEntry* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(LogEntry* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] LogEntry* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<LogEntry>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const LogEntry& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const LogEntry& from) { LogEntry::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(LogEntry* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "clickhouse.grpc.LogEntry"; }

  explicit LogEntry(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  LogEntry(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const LogEntry& from);
  LogEntry(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, LogEntry&& from) noexcept
      : LogEntry(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kQueryIdFieldNumber = 4,
    kSourceFieldNumber = 6,
    kTextFieldNumber = 7,
    kTimeFieldNumber = 1,
    kTimeMicrosecondsFieldNumber = 2,
    kThreadIdFieldNumber = 3,
    kLevelFieldNumber = 5,
  };
  // string query_id = 4;
  void clear_query_id() ;
  [[nodiscard]] const ::std::string& query_id() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_query_id(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_query_id();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_query_id();
  void set_allocated_query_id(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_query_id() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_query_id(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_query_id();

  public:
  // string source = 6;
  void clear_source() ;
  [[nodiscard]] const ::std::string& source() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_source(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_source();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_source();
  void set_allocated_source(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_source() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_source(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_source();

  public:
  // string text = 7;
  void clear_text() ;
  [[nodiscard]] const ::std::string& text() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_text(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_text();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_text();
  void set_allocated_text(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_text() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_text(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_text();

  public:
  // uint32 time = 1;
  void clear_time() ;
  [[nodiscard]] ::uint32_t time() const;
  void set_time(::uint32_t value);

  private:
  ::uint32_t _internal_time() const;
  void _internal_set_time(::uint32_t value);

  public:
  // uint32 time_microseconds = 2;
  void clear_time_microseconds() ;
  [[nodiscard]] ::uint32_t time_microseconds() const;
  void set_time_microseconds(::uint32_t value);

  private:
  ::uint32_t _internal_time_microseconds() const;
  void _internal_set_time_microseconds(::uint32_t value);

  public:
  // uint64 thread_id = 3;
  void clear_thread_id() ;
  [[nodiscard]] ::uint64_t thread_id() const;
  void set_thread_id(::uint64_t value);

  private:
  ::uint64_t _internal_thread_id() const;
  void _internal_set_thread_id(::uint64_t value);

  public:
  // .clickhouse.grpc.LogsLevel level = 5;
  void clear_level() ;
  [[nodiscard]] ::clickhouse::grpc::LogsLevel level() const;
  void set_level(::clickhouse::grpc::LogsLevel value);

  private:
  ::clickhouse::grpc::LogsLevel _internal_level() const;
  void _internal_set_level(::clickhouse::grpc::LogsLevel value);

  public:
  // @@protoc_insertion_point(class_scope:clickhouse.grpc.LogEntry)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<3, 7,
                          0, 51,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const LogEntry& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr query_id_;
    ::google::protobuf::internal::ArenaStringPtr source_;
    ::google::protobuf::internal::ArenaStringPtr text_;
    ::uint32_t time_;
    ::uint32_t time_microseconds_;
    ::uint64_t thread_id_;
    int level_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_clickhouse_5fgrpc_2eproto;
};
// -------------------------------------------------------------------

class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED ExternalTable_SettingsEntry_DoNotUse final
    : public ::google::protobuf::internal::MapEntry<::std::string, ::std::string,
                             ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
                             ::google::protobuf::internal::WireFormatLite::TYPE_STRING> {
 public:
  using SuperType =
      ::google::protobuf::internal::MapEntry<::std::string, ::std::string,
                      ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
                      ::google::protobuf::internal::WireFormatLite::TYPE_STRING>;
  ExternalTable_SettingsEntry_DoNotUse();
  template <typename = void>
  explicit constexpr ExternalTable_SettingsEntry_DoNotUse(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);
  explicit ExternalTable_SettingsEntry_DoNotUse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr const void* PROTOBUF_NONNULL internal_message_globals() {
    return &ExternalTable_SettingsEntry_DoNotUse_globals_;
  }


  static constexpr auto InternalGenerateClassData_(
      const ::google::protobuf::MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

 private:
  friend class ::google::protobuf::MessageLite;
  friend struct ::TableStruct_clickhouse_5fgrpc_2eproto;
  friend ::google::protobuf::internal::PrivateAccess;
  friend ExternalTable_SettingsEntry_DoNotUseGlobalsTypeInternal;

  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<1, 2,
                          0, 60,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED Exception final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:clickhouse.grpc.Exception) */ {
 public:
  inline Exception() : Exception(nullptr) {}
  ~Exception() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(Exception* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(Exception));
  }
#endif

  template <typename = void>
  explicit constexpr Exception(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline Exception(const Exception& from) : Exception(nullptr, from) {}
  inline Exception(Exception&& from) noexcept : Exception(nullptr, ::std::move(from)) {}
  inline Exception& operator=(const Exception& from) {
    CopyFrom(from);
    return *this;
  }
  inline Exception& operator=(Exception&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const Exception& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<Exception>(&Exception_globals_);
  }
  static constexpr int kIndexInFileMessages = 9;
  friend void swap(Exception& a, Exception& b) { a.Swap(&b); }
  inline void Swap(Exception* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Exception* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] Exception* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<Exception>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const Exception& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const Exception& from) { Exception::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(Exception* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "clickhouse.grpc.Exception"; }

  explicit Exception(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  Exception(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Exception& from);
  Exception(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, Exception&& from) noexcept
      : Exception(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kNameFieldNumber = 2,
    kDisplayTextFieldNumber = 3,
    kStackTraceFieldNumber = 4,
    kCodeFieldNumber = 1,
  };
  // string name = 2;
  void clear_name() ;
  [[nodiscard]] const ::std::string& name() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_name();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_name();
  void set_allocated_name(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_name() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_name(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_name();

  public:
  // string display_text = 3;
  void clear_display_text() ;
  [[nodiscard]] const ::std::string& display_text() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_display_text(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_display_text();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_display_text();
  void set_allocated_display_text(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_display_text() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_display_text(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_display_text();

  public:
  // string stack_trace = 4;
  void clear_stack_trace() ;
  [[nodiscard]] const ::std::string& stack_trace() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_stack_trace(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_stack_trace();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_stack_trace();
  void set_allocated_stack_trace(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_stack_trace() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_stack_trace(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_stack_trace();

  public:
  // int32 code = 1;
  void clear_code() ;
  [[nodiscard]] ::int32_t code() const;
  void set_code(::int32_t value);

  private:
  ::int32_t _internal_code() const;
  void _internal_set_code(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:clickhouse.grpc.Exception)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<2, 4,
                          0, 61,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const Exception& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr name_;
    ::google::protobuf::internal::ArenaStringPtr display_text_;
    ::google::protobuf::internal::ArenaStringPtr stack_trace_;
    ::int32_t code_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_clickhouse_5fgrpc_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED Result final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:clickhouse.grpc.Result) */ {
 public:
  inline Result() : Result(nullptr) {}
  ~Result() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(Result* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(Result));
  }
#endif

  template <typename = void>
  explicit constexpr Result(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline Result(const Result& from) : Result(nullptr, from) {}
  inline Result(Result&& from) noexcept : Result(nullptr, ::std::move(from)) {}
  inline Result& operator=(const Result& from) {
    CopyFrom(from);
    return *this;
  }
  inline Result& operator=(Result&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const Result& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<Result>(&Result_globals_);
  }
  static constexpr int kIndexInFileMessages = 10;
  friend void swap(Result& a, Result& b) { a.Swap(&b); }
  inline void Swap(Result* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Result* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] Result* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<Result>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const Result& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const Result& from) { Result::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(Result* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "clickhouse.grpc.Result"; }

  explicit Result(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  Result(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Result& from);
  Result(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, Result&& from) noexcept
      : Result(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kLogsFieldNumber = 4,
    kOutputColumnsFieldNumber = 12,
    kOutputFieldNumber = 1,
    kTotalsFieldNumber = 2,
    kExtremesFieldNumber = 3,
    kQueryIdFieldNumber = 9,
    kTimeZoneFieldNumber = 10,
    kOutputFormatFieldNumber = 11,
    kProgressFieldNumber = 5,
    kStatsFieldNumber = 6,
    kExceptionFieldNumber = 7,
    kCancelledFieldNumber = 8,
  };
  // repeated .clickhouse.grpc.LogEntry logs = 4;
  [[nodiscard]] int logs_size()
      const;
  private:
  int _internal_logs_size() const;

  public:
  void clear_logs() ;
  [[nodiscard]] const ::clickhouse::grpc::LogEntry& logs(int index) const;
  [[nodiscard]] ::clickhouse::grpc::LogEntry* PROTOBUF_NONNULL mutable_logs(int index);
  ::clickhouse::grpc::LogEntry* PROTOBUF_NONNULL add_logs();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::clickhouse::grpc::LogEntry>&
  logs() const;
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::clickhouse::grpc::LogEntry>* PROTOBUF_NONNULL
  mutable_logs();

  private:
  const ::google::protobuf::RepeatedPtrField<::clickhouse::grpc::LogEntry>& _internal_logs() const;
  ::google::protobuf::RepeatedPtrField<::clickhouse::grpc::LogEntry>* PROTOBUF_NONNULL _internal_mutable_logs();

  public:
  // repeated .clickhouse.grpc.NameAndType output_columns = 12;
  [[nodiscard]] int output_columns_size()
      const;
  private:
  int _internal_output_columns_size() const;

  public:
  void clear_output_columns() ;
  [[nodiscard]] const ::clickhouse::grpc::NameAndType& output_columns(int index) const;
  [[nodiscard]] ::clickhouse::grpc::NameAndType* PROTOBUF_NONNULL mutable_output_columns(int index);
  ::clickhouse::grpc::NameAndType* PROTOBUF_NONNULL add_output_columns();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::clickhouse::grpc::NameAndType>&
  output_columns() const;
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::clickhouse::grpc::NameAndType>* PROTOBUF_NONNULL
  mutable_output_columns();

  private:
  const ::google::protobuf::RepeatedPtrField<::clickhouse::grpc::NameAndType>& _internal_output_columns() const;
  ::google::protobuf::RepeatedPtrField<::clickhouse::grpc::NameAndType>* PROTOBUF_NONNULL _internal_mutable_output_columns();

  public:
  // bytes output = 1;
  void clear_output() ;
  [[nodiscard]] const ::std::string& output() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_output(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_output();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_output();
  void set_allocated_output(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_output() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_output(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_output();

  public:
  // bytes totals = 2;
  void clear_totals() ;
  [[nodiscard]] const ::std::string& totals() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_totals(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_totals();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_totals();
  void set_allocated_totals(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_totals() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_totals(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_totals();

  public:
  // bytes extremes = 3;
  void clear_extremes() ;
  [[nodiscard]] const ::std::string& extremes() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_extremes(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_extremes();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_extremes();
  void set_allocated_extremes(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_extremes() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_extremes(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_extremes();

  public:
  // string query_id = 9;
  void clear_query_id() ;
  [[nodiscard]] const ::std::string& query_id() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_query_id(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_query_id();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_query_id();
  void set_allocated_query_id(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_query_id() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_query_id(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_query_id();

  public:
  // string time_zone = 10;
  void clear_time_zone() ;
  [[nodiscard]] const ::std::string& time_zone() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_time_zone(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_time_zone();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_time_zone();
  void set_allocated_time_zone(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_time_zone() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_time_zone(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_time_zone();

  public:
  // string output_format = 11;
  void clear_output_format() ;
  [[nodiscard]] const ::std::string& output_format() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_output_format(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_output_format();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_output_format();
  void set_allocated_output_format(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_output_format() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_output_format(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_output_format();

  public:
  // .clickhouse.grpc.Progress progress = 5;
  [[nodiscard]] bool has_progress()
      const;
  void clear_progress() ;
  [[nodiscard]] const ::clickhouse::grpc::Progress& progress() const;
  [[nodiscard]] ::clickhouse::grpc::Progress* PROTOBUF_NULLABLE release_progress();
  ::clickhouse::grpc::Progress* PROTOBUF_NONNULL mutable_progress();
  void set_allocated_progress(::clickhouse::grpc::Progress* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_progress(::clickhouse::grpc::Progress* PROTOBUF_NULLABLE value);
  ::clickhouse::grpc::Progress* PROTOBUF_NULLABLE unsafe_arena_release_progress();

  private:
  const ::clickhouse::grpc::Progress& _internal_progress() const;
  ::clickhouse::grpc::Progress* PROTOBUF_NONNULL _internal_mutable_progress();

  public:
  // .clickhouse.grpc.Stats stats = 6;
  [[nodiscard]] bool has_stats()
      const;
  void clear_stats() ;
  [[nodiscard]] const ::clickhouse::grpc::Stats& stats() const;
  [[nodiscard]] ::clickhouse::grpc::Stats* PROTOBUF_NULLABLE release_stats();
  ::clickhouse::grpc::Stats* PROTOBUF_NONNULL mutable_stats();
  void set_allocated_stats(::clickhouse::grpc::Stats* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_stats(::clickhouse::grpc::Stats* PROTOBUF_NULLABLE value);
  ::clickhouse::grpc::Stats* PROTOBUF_NULLABLE unsafe_arena_release_stats();

  private:
  const ::clickhouse::grpc::Stats& _internal_stats() const;
  ::clickhouse::grpc::Stats* PROTOBUF_NONNULL _internal_mutable_stats();

  public:
  // .clickhouse.grpc.Exception exception = 7;
  [[nodiscard]] bool has_exception()
      const;
  void clear_exception() ;
  [[nodiscard]] const ::clickhouse::grpc::Exception& exception() const;
  [[nodiscard]] ::clickhouse::grpc::Exception* PROTOBUF_NULLABLE release_exception();
  ::clickhouse::grpc::Exception* PROTOBUF_NONNULL mutable_exception();
  void set_allocated_exception(::clickhouse::grpc::Exception* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_exception(::clickhouse::grpc::Exception* PROTOBUF_NULLABLE value);
  ::clickhouse::grpc::Exception* PROTOBUF_NULLABLE unsafe_arena_release_exception();

  private:
  const ::clickhouse::grpc::Exception& _internal_exception() const;
  ::clickhouse::grpc::Exception* PROTOBUF_NONNULL _internal_mutable_exception();

  public:
  // bool cancelled = 8;
  void clear_cancelled() ;
  [[nodiscard]] bool cancelled() const;
  void set_cancelled(bool value);

  private:
  bool _internal_cancelled() const;
  void _internal_set_cancelled(bool value);

  public:
  // @@protoc_insertion_point(class_scope:clickhouse.grpc.Result)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<4, 12,
                          5, 69,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const Result& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::clickhouse::grpc::LogEntry > logs_;
    ::google::protobuf::RepeatedPtrField< ::clickhouse::grpc::NameAndType > output_columns_;
    ::google::protobuf::internal::ArenaStringPtr output_;
    ::google::protobuf::internal::ArenaStringPtr totals_;
    ::google::protobuf::internal::ArenaStringPtr extremes_;
    ::google::protobuf::internal::ArenaStringPtr query_id_;
    ::google::protobuf::internal::ArenaStringPtr time_zone_;
    ::google::protobuf::internal::ArenaStringPtr output_format_;
    ::clickhouse::grpc::Progress* PROTOBUF_NULLABLE progress_;
    ::clickhouse::grpc::Stats* PROTOBUF_NULLABLE stats_;
    ::clickhouse::grpc::Exception* PROTOBUF_NULLABLE exception_;
    bool cancelled_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_clickhouse_5fgrpc_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED ExternalTable final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:clickhouse.grpc.ExternalTable) */ {
 public:
  inline ExternalTable() : ExternalTable(nullptr) {}
  ~ExternalTable() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(ExternalTable* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(ExternalTable));
  }
#endif

  template <typename = void>
  explicit constexpr ExternalTable(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline ExternalTable(const ExternalTable& from) : ExternalTable(nullptr, from) {}
  inline ExternalTable(ExternalTable&& from) noexcept : ExternalTable(nullptr, ::std::move(from)) {}
  inline ExternalTable& operator=(const ExternalTable& from) {
    CopyFrom(from);
    return *this;
  }
  inline ExternalTable& operator=(ExternalTable&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const ExternalTable& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<ExternalTable>(&ExternalTable_globals_);
  }
  static constexpr int kIndexInFileMessages = 2;
  friend void swap(ExternalTable& a, ExternalTable& b) { a.Swap(&b); }
  inline void Swap(ExternalTable* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ExternalTable* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] ExternalTable* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<ExternalTable>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const ExternalTable& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const ExternalTable& from) { ExternalTable::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(ExternalTable* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "clickhouse.grpc.ExternalTable"; }

  explicit ExternalTable(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  ExternalTable(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ExternalTable& from);
  ExternalTable(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ExternalTable&& from) noexcept
      : ExternalTable(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kColumnsFieldNumber = 2,
    kNameFieldNumber = 1,
    kDataFieldNumber = 3,
    kFormatFieldNumber = 4,
    kCompressionTypeFieldNumber = 6,
    kSettingsFieldNumber = 5,
  };
  // repeated .clickhouse.grpc.NameAndType columns = 2;
  [[nodiscard]] int columns_size()
      const;
  private:
  int _internal_columns_size() const;

  public:
  void clear_columns() ;
  [[nodiscard]] const ::clickhouse::grpc::NameAndType& columns(int index) const;
  [[nodiscard]] ::clickhouse::grpc::NameAndType* PROTOBUF_NONNULL mutable_columns(int index);
  ::clickhouse::grpc::NameAndType* PROTOBUF_NONNULL add_columns();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::clickhouse::grpc::NameAndType>&
  columns() const;
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::clickhouse::grpc::NameAndType>* PROTOBUF_NONNULL
  mutable_columns();

  private:
  const ::google::protobuf::RepeatedPtrField<::clickhouse::grpc::NameAndType>& _internal_columns() const;
  ::google::protobuf::RepeatedPtrField<::clickhouse::grpc::NameAndType>* PROTOBUF_NONNULL _internal_mutable_columns();

  public:
  // string name = 1;
  void clear_name() ;
  [[nodiscard]] const ::std::string& name() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_name();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_name();
  void set_allocated_name(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_name() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_name(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_name();

  public:
  // bytes data = 3;
  void clear_data() ;
  [[nodiscard]] const ::std::string& data() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_data(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_data();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_data();
  void set_allocated_data(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_data() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_data(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_data();

  public:
  // string format = 4;
  void clear_format() ;
  [[nodiscard]] const ::std::string& format() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_format(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_format();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_format();
  void set_allocated_format(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_format() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_format(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_format();

  public:
  // string compression_type = 6;
  void clear_compression_type() ;
  [[nodiscard]] const ::std::string& compression_type() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_compression_type(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_compression_type();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_compression_type();
  void set_allocated_compression_type(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_compression_type() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_compression_type(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_compression_type();

  public:
  // map<string, string> settings = 5;
  [[nodiscard]] int settings_size()
      const;
  private:
  int _internal_settings_size() const;

  public:
  void clear_settings() ;
  [[nodiscard]] const ::google::protobuf::Map<::std::string, ::std::string>& settings() const;
  [[nodiscard]] ::google::protobuf::Map<::std::string, ::std::string>* PROTOBUF_NONNULL mutable_settings();

  private:
  const ::google::protobuf::Map<::std::string, ::std::string>& _internal_settings() const;
  ::google::protobuf::Map<::std::string, ::std::string>* PROTOBUF_NONNULL _internal_mutable_settings();

  public:
  // @@protoc_insertion_point(class_scope:clickhouse.grpc.ExternalTable)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<3, 6,
                          2, 72,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const ExternalTable& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::clickhouse::grpc::NameAndType > columns_;
    ::google::protobuf::internal::ArenaStringPtr name_;
    ::google::protobuf::internal::ArenaStringPtr data_;
    ::google::protobuf::internal::ArenaStringPtr format_;
    ::google::protobuf::internal::ArenaStringPtr compression_type_;
    ::google::protobuf::internal::MapField<ExternalTable_SettingsEntry_DoNotUse, ::std::string, ::std::string> settings_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_clickhouse_5fgrpc_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED QueryInfo final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:clickhouse.grpc.QueryInfo) */ {
 public:
  inline QueryInfo() : QueryInfo(nullptr) {}
  ~QueryInfo() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(QueryInfo* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(QueryInfo));
  }
#endif

  template <typename = void>
  explicit constexpr QueryInfo(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline QueryInfo(const QueryInfo& from) : QueryInfo(nullptr, from) {}
  inline QueryInfo(QueryInfo&& from) noexcept : QueryInfo(nullptr, ::std::move(from)) {}
  inline QueryInfo& operator=(const QueryInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline QueryInfo& operator=(QueryInfo&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const QueryInfo& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<QueryInfo>(&QueryInfo_globals_);
  }
  static constexpr int kIndexInFileMessages = 5;
  friend void swap(QueryInfo& a, QueryInfo& b) { a.Swap(&b); }
  inline void Swap(QueryInfo* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(QueryInfo* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] QueryInfo* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<QueryInfo>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const QueryInfo& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const QueryInfo& from) { QueryInfo::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(QueryInfo* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "clickhouse.grpc.QueryInfo"; }

  explicit QueryInfo(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  QueryInfo(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const QueryInfo& from);
  QueryInfo(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, QueryInfo&& from) noexcept
      : QueryInfo(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kExternalTablesFieldNumber = 8,
    kQueryFieldNumber = 1,
    kQueryIdFieldNumber = 2,
    kDatabaseFieldNumber = 4,
    kInputDataFieldNumber = 5,
    kInputDataDelimiterFieldNumber = 6,
    kOutputFormatFieldNumber = 7,
    kUserNameFieldNumber = 9,
    kPasswordFieldNumber = 10,
    kQuotaFieldNumber = 11,
    kSessionIdFieldNumber = 12,
    kObsoleteCompressionTypeFieldNumber = 18,
    kInputCompressionTypeFieldNumber = 20,
    kOutputCompressionTypeFieldNumber = 21,
    kTransportCompressionTypeFieldNumber = 22,
    kJwtFieldNumber = 25,
    kObsoleteResultCompressionFieldNumber = 17,
    kSessionTimeoutFieldNumber = 14,
    kSessionCheckFieldNumber = 13,
    kCancelFieldNumber = 15,
    kNextQueryInfoFieldNumber = 16,
    kSendOutputColumnsFieldNumber = 24,
    kOutputCompressionLevelFieldNumber = 19,
    kTransportCompressionLevelFieldNumber = 23,
    kSettingsFieldNumber = 3,
  };
  // repeated .clickhouse.grpc.ExternalTable external_tables = 8;
  [[nodiscard]] int external_tables_size()
      const;
  private:
  int _internal_external_tables_size() const;

  public:
  void clear_external_tables() ;
  [[nodiscard]] const ::clickhouse::grpc::ExternalTable& external_tables(int index) const;
  [[nodiscard]] ::clickhouse::grpc::ExternalTable* PROTOBUF_NONNULL mutable_external_tables(int index);
  ::clickhouse::grpc::ExternalTable* PROTOBUF_NONNULL add_external_tables();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::clickhouse::grpc::ExternalTable>&
  external_tables() const;
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::clickhouse::grpc::ExternalTable>* PROTOBUF_NONNULL
  mutable_external_tables();

  private:
  const ::google::protobuf::RepeatedPtrField<::clickhouse::grpc::ExternalTable>& _internal_external_tables() const;
  ::google::protobuf::RepeatedPtrField<::clickhouse::grpc::ExternalTable>* PROTOBUF_NONNULL _internal_mutable_external_tables();

  public:
  // string query = 1;
  void clear_query() ;
  [[nodiscard]] const ::std::string& query() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_query(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_query();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_query();
  void set_allocated_query(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_query() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_query(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_query();

  public:
  // string query_id = 2;
  void clear_query_id() ;
  [[nodiscard]] const ::std::string& query_id() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_query_id(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_query_id();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_query_id();
  void set_allocated_query_id(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_query_id() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_query_id(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_query_id();

  public:
  // string database = 4;
  void clear_database() ;
  [[nodiscard]] const ::std::string& database() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_database(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_database();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_database();
  void set_allocated_database(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_database() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_database(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_database();

  public:
  // bytes input_data = 5;
  void clear_input_data() ;
  [[nodiscard]] const ::std::string& input_data() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_input_data(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_input_data();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_input_data();
  void set_allocated_input_data(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_input_data() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_input_data(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_input_data();

  public:
  // bytes input_data_delimiter = 6;
  void clear_input_data_delimiter() ;
  [[nodiscard]] const ::std::string& input_data_delimiter() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_input_data_delimiter(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_input_data_delimiter();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_input_data_delimiter();
  void set_allocated_input_data_delimiter(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_input_data_delimiter() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_input_data_delimiter(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_input_data_delimiter();

  public:
  // string output_format = 7;
  void clear_output_format() ;
  [[nodiscard]] const ::std::string& output_format() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_output_format(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_output_format();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_output_format();
  void set_allocated_output_format(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_output_format() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_output_format(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_output_format();

  public:
  // string user_name = 9;
  void clear_user_name() ;
  [[nodiscard]] const ::std::string& user_name() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_user_name(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_user_name();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_user_name();
  void set_allocated_user_name(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_user_name() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_user_name(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_user_name();

  public:
  // string password = 10;
  void clear_password() ;
  [[nodiscard]] const ::std::string& password() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_password(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_password();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_password();
  void set_allocated_password(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_password() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_password(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_password();

  public:
  // string quota = 11;
  void clear_quota() ;
  [[nodiscard]] const ::std::string& quota() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_quota(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_quota();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_quota();
  void set_allocated_quota(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_quota() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_quota(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_quota();

  public:
  // string session_id = 12;
  void clear_session_id() ;
  [[nodiscard]] const ::std::string& session_id() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_session_id(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_session_id();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_session_id();
  void set_allocated_session_id(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_session_id() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_session_id(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_session_id();

  public:
  // string obsolete_compression_type = 18;
  void clear_obsolete_compression_type() ;
  [[nodiscard]] const ::std::string& obsolete_compression_type() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_obsolete_compression_type(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_obsolete_compression_type();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_obsolete_compression_type();
  void set_allocated_obsolete_compression_type(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_obsolete_compression_type() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_obsolete_compression_type(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_obsolete_compression_type();

  public:
  // string input_compression_type = 20;
  void clear_input_compression_type() ;
  [[nodiscard]] const ::std::string& input_compression_type() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_input_compression_type(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_input_compression_type();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_input_compression_type();
  void set_allocated_input_compression_type(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_input_compression_type() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_input_compression_type(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_input_compression_type();

  public:
  // string output_compression_type = 21;
  void clear_output_compression_type() ;
  [[nodiscard]] const ::std::string& output_compression_type() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_output_compression_type(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_output_compression_type();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_output_compression_type();
  void set_allocated_output_compression_type(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_output_compression_type() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_output_compression_type(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_output_compression_type();

  public:
  // string transport_compression_type = 22;
  void clear_transport_compression_type() ;
  [[nodiscard]] const ::std::string& transport_compression_type() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_transport_compression_type(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_transport_compression_type();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_transport_compression_type();
  void set_allocated_transport_compression_type(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_transport_compression_type() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_transport_compression_type(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_transport_compression_type();

  public:
  // string jwt = 25;
  void clear_jwt() ;
  [[nodiscard]] const ::std::string& jwt() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_jwt(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_jwt();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_jwt();
  void set_allocated_jwt(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_jwt() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_jwt(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_jwt();

  public:
  // .clickhouse.grpc.ObsoleteTransportCompression obsolete_result_compression = 17;
  [[nodiscard]] bool has_obsolete_result_compression()
      const;
  void clear_obsolete_result_compression() ;
  [[nodiscard]] const ::clickhouse::grpc::ObsoleteTransportCompression& obsolete_result_compression() const;
  [[nodiscard]] ::clickhouse::grpc::ObsoleteTransportCompression* PROTOBUF_NULLABLE release_obsolete_result_compression();
  ::clickhouse::grpc::ObsoleteTransportCompression* PROTOBUF_NONNULL mutable_obsolete_result_compression();
  void set_allocated_obsolete_result_compression(::clickhouse::grpc::ObsoleteTransportCompression* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_obsolete_result_compression(::clickhouse::grpc::ObsoleteTransportCompression* PROTOBUF_NULLABLE value);
  ::clickhouse::grpc::ObsoleteTransportCompression* PROTOBUF_NULLABLE unsafe_arena_release_obsolete_result_compression();

  private:
  const ::clickhouse::grpc::ObsoleteTransportCompression& _internal_obsolete_result_compression() const;
  ::clickhouse::grpc::ObsoleteTransportCompression* PROTOBUF_NONNULL _internal_mutable_obsolete_result_compression();

  public:
  // uint32 session_timeout = 14;
  void clear_session_timeout() ;
  [[nodiscard]] ::uint32_t session_timeout() const;
  void set_session_timeout(::uint32_t value);

  private:
  ::uint32_t _internal_session_timeout() const;
  void _internal_set_session_timeout(::uint32_t value);

  public:
  // bool session_check = 13;
  void clear_session_check() ;
  [[nodiscard]] bool session_check() const;
  void set_session_check(bool value);

  private:
  bool _internal_session_check() const;
  void _internal_set_session_check(bool value);

  public:
  // bool cancel = 15;
  void clear_cancel() ;
  [[nodiscard]] bool cancel() const;
  void set_cancel(bool value);

  private:
  bool _internal_cancel() const;
  void _internal_set_cancel(bool value);

  public:
  // bool next_query_info = 16;
  void clear_next_query_info() ;
  [[nodiscard]] bool next_query_info() const;
  void set_next_query_info(bool value);

  private:
  bool _internal_next_query_info() const;
  void _internal_set_next_query_info(bool value);

  public:
  // bool send_output_columns = 24;
  void clear_send_output_columns() ;
  [[nodiscard]] bool send_output_columns() const;
  void set_send_output_columns(bool value);

  private:
  bool _internal_send_output_columns() const;
  void _internal_set_send_output_columns(bool value);

  public:
  // int32 output_compression_level = 19;
  void clear_output_compression_level() ;
  [[nodiscard]] ::int32_t output_compression_level() const;
  void set_output_compression_level(::int32_t value);

  private:
  ::int32_t _internal_output_compression_level() const;
  void _internal_set_output_compression_level(::int32_t value);

  public:
  // int32 transport_compression_level = 23;
  void clear_transport_compression_level() ;
  [[nodiscard]] ::int32_t transport_compression_level() const;
  void set_transport_compression_level(::int32_t value);

  private:
  ::int32_t _internal_transport_compression_level() const;
  void _internal_set_transport_compression_level(::int32_t value);

  public:
  // map<string, string> settings = 3;
  [[nodiscard]] int settings_size()
      const;
  private:
  int _internal_settings_size() const;

  public:
  void clear_settings() ;
  [[nodiscard]] const ::google::protobuf::Map<::std::string, ::std::string>& settings() const;
  [[nodiscard]] ::google::protobuf::Map<::std::string, ::std::string>* PROTOBUF_NONNULL mutable_settings();

  private:
  const ::google::protobuf::Map<::std::string, ::std::string>& _internal_settings() const;
  ::google::protobuf::Map<::std::string, ::std::string>* PROTOBUF_NONNULL _internal_mutable_settings();

  public:
  // @@protoc_insertion_point(class_scope:clickhouse.grpc.QueryInfo)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<5, 25,
                          3, 231,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const QueryInfo& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::clickhouse::grpc::ExternalTable > external_tables_;
    ::google::protobuf::internal::ArenaStringPtr query_;
    ::google::protobuf::internal::ArenaStringPtr query_id_;
    ::google::protobuf::internal::ArenaStringPtr database_;
    ::google::protobuf::internal::ArenaStringPtr input_data_;
    ::google::protobuf::internal::ArenaStringPtr input_data_delimiter_;
    ::google::protobuf::internal::ArenaStringPtr output_format_;
    ::google::protobuf::internal::ArenaStringPtr user_name_;
    ::google::protobuf::internal::ArenaStringPtr password_;
    ::google::protobuf::internal::ArenaStringPtr quota_;
    ::google::protobuf::internal::ArenaStringPtr session_id_;
    ::google::protobuf::internal::ArenaStringPtr obsolete_compression_type_;
    ::google::protobuf::internal::ArenaStringPtr input_compression_type_;
    ::google::protobuf::internal::ArenaStringPtr output_compression_type_;
    ::google::protobuf::internal::ArenaStringPtr transport_compression_type_;
    ::google::protobuf::internal::ArenaStringPtr jwt_;
    ::clickhouse::grpc::ObsoleteTransportCompression* PROTOBUF_NULLABLE obsolete_result_compression_;
    ::uint32_t session_timeout_;
    bool session_check_;
    bool cancel_;
    bool next_query_info_;
    bool send_output_columns_;
    ::int32_t output_compression_level_;
    ::int32_t transport_compression_level_;
    ::google::protobuf::internal::MapField<QueryInfo_SettingsEntry_DoNotUse, ::std::string, ::std::string> settings_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_clickhouse_5fgrpc_2eproto;
};

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




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


#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// -------------------------------------------------------------------

// NameAndType

// string name = 1;
inline void NameAndType::clear_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::std::string& NameAndType::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.NameAndType.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void NameAndType::set_name(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:clickhouse.grpc.NameAndType.name)
}
inline ::std::string* PROTOBUF_NONNULL NameAndType::mutable_name()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:clickhouse.grpc.NameAndType.name)
  return _s;
}
inline const ::std::string& NameAndType::_internal_name() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.name_.Get();
}
inline void NameAndType::_internal_set_name(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL NameAndType::_internal_mutable_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.name_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE NameAndType::release_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:clickhouse.grpc.NameAndType.name)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  auto* released = _impl_.name_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.name_.Set("", GetArena());
  }
  return released;
}
inline void NameAndType::set_allocated_name(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  _impl_.name_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:clickhouse.grpc.NameAndType.name)
}

// string type = 2;
inline void NameAndType::clear_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.type_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline const ::std::string& NameAndType::type() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.NameAndType.type)
  return _internal_type();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void NameAndType::set_type(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  _impl_.type_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:clickhouse.grpc.NameAndType.type)
}
inline ::std::string* PROTOBUF_NONNULL NameAndType::mutable_type()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::std::string* _s = _internal_mutable_type();
  // @@protoc_insertion_point(field_mutable:clickhouse.grpc.NameAndType.type)
  return _s;
}
inline const ::std::string& NameAndType::_internal_type() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.type_.Get();
}
inline void NameAndType::_internal_set_type(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.type_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL NameAndType::_internal_mutable_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.type_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE NameAndType::release_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:clickhouse.grpc.NameAndType.type)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  auto* released = _impl_.type_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.type_.Set("", GetArena());
  }
  return released;
}
inline void NameAndType::set_allocated_type(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
  _impl_.type_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.type_.IsDefault()) {
    _impl_.type_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:clickhouse.grpc.NameAndType.type)
}

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

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

// ExternalTable

// string name = 1;
inline void ExternalTable::clear_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline const ::std::string& ExternalTable::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.ExternalTable.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void ExternalTable::set_name(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:clickhouse.grpc.ExternalTable.name)
}
inline ::std::string* PROTOBUF_NONNULL ExternalTable::mutable_name()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:clickhouse.grpc.ExternalTable.name)
  return _s;
}
inline const ::std::string& ExternalTable::_internal_name() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.name_.Get();
}
inline void ExternalTable::_internal_set_name(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL ExternalTable::_internal_mutable_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.name_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE ExternalTable::release_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:clickhouse.grpc.ExternalTable.name)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  auto* released = _impl_.name_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.name_.Set("", GetArena());
  }
  return released;
}
inline void ExternalTable::set_allocated_name(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
  _impl_.name_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:clickhouse.grpc.ExternalTable.name)
}

// repeated .clickhouse.grpc.NameAndType columns = 2;
inline int ExternalTable::_internal_columns_size() const {
  return _internal_columns().size();
}
inline int ExternalTable::columns_size() const {
  return _internal_columns_size();
}
inline void ExternalTable::clear_columns() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.columns_.Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::clickhouse::grpc::NameAndType& ExternalTable::columns(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.ExternalTable.columns)
  return _internal_columns().Get(index);
}
inline ::clickhouse::grpc::NameAndType* PROTOBUF_NONNULL ExternalTable::mutable_columns(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:clickhouse.grpc.ExternalTable.columns)
  return _internal_mutable_columns()->Mutable(index);
}
inline ::clickhouse::grpc::NameAndType* PROTOBUF_NONNULL ExternalTable::add_columns()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::clickhouse::grpc::NameAndType* _add =
      _internal_mutable_columns()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add:clickhouse.grpc.ExternalTable.columns)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::clickhouse::grpc::NameAndType>& ExternalTable::columns() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:clickhouse.grpc.ExternalTable.columns)
  return _internal_columns();
}
inline ::google::protobuf::RepeatedPtrField<::clickhouse::grpc::NameAndType>* PROTOBUF_NONNULL
ExternalTable::mutable_columns() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_mutable_list:clickhouse.grpc.ExternalTable.columns)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_columns();
}
inline const ::google::protobuf::RepeatedPtrField<::clickhouse::grpc::NameAndType>&
ExternalTable::_internal_columns() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.columns_;
}
inline ::google::protobuf::RepeatedPtrField<::clickhouse::grpc::NameAndType>* PROTOBUF_NONNULL
ExternalTable::_internal_mutable_columns() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.columns_;
}

// bytes data = 3;
inline void ExternalTable::clear_data() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.data_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline const ::std::string& ExternalTable::data() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.ExternalTable.data)
  return _internal_data();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void ExternalTable::set_data(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  _impl_.data_.SetBytes(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:clickhouse.grpc.ExternalTable.data)
}
inline ::std::string* PROTOBUF_NONNULL ExternalTable::mutable_data()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::std::string* _s = _internal_mutable_data();
  // @@protoc_insertion_point(field_mutable:clickhouse.grpc.ExternalTable.data)
  return _s;
}
inline const ::std::string& ExternalTable::_internal_data() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.data_.Get();
}
inline void ExternalTable::_internal_set_data(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.data_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL ExternalTable::_internal_mutable_data() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.data_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE ExternalTable::release_data() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:clickhouse.grpc.ExternalTable.data)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000004U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  auto* released = _impl_.data_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.data_.Set("", GetArena());
  }
  return released;
}
inline void ExternalTable::set_allocated_data(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  }
  _impl_.data_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.data_.IsDefault()) {
    _impl_.data_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:clickhouse.grpc.ExternalTable.data)
}

// string format = 4;
inline void ExternalTable::clear_format() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.format_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline const ::std::string& ExternalTable::format() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.ExternalTable.format)
  return _internal_format();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void ExternalTable::set_format(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  _impl_.format_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:clickhouse.grpc.ExternalTable.format)
}
inline ::std::string* PROTOBUF_NONNULL ExternalTable::mutable_format()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::std::string* _s = _internal_mutable_format();
  // @@protoc_insertion_point(field_mutable:clickhouse.grpc.ExternalTable.format)
  return _s;
}
inline const ::std::string& ExternalTable::_internal_format() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.format_.Get();
}
inline void ExternalTable::_internal_set_format(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.format_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL ExternalTable::_internal_mutable_format() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.format_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE ExternalTable::release_format() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:clickhouse.grpc.ExternalTable.format)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000008U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  auto* released = _impl_.format_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.format_.Set("", GetArena());
  }
  return released;
}
inline void ExternalTable::set_allocated_format(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  }
  _impl_.format_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.format_.IsDefault()) {
    _impl_.format_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:clickhouse.grpc.ExternalTable.format)
}

// string compression_type = 6;
inline void ExternalTable::clear_compression_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.compression_type_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
}
inline const ::std::string& ExternalTable::compression_type() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.ExternalTable.compression_type)
  return _internal_compression_type();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void ExternalTable::set_compression_type(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  _impl_.compression_type_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:clickhouse.grpc.ExternalTable.compression_type)
}
inline ::std::string* PROTOBUF_NONNULL ExternalTable::mutable_compression_type()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::std::string* _s = _internal_mutable_compression_type();
  // @@protoc_insertion_point(field_mutable:clickhouse.grpc.ExternalTable.compression_type)
  return _s;
}
inline const ::std::string& ExternalTable::_internal_compression_type() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.compression_type_.Get();
}
inline void ExternalTable::_internal_set_compression_type(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.compression_type_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL ExternalTable::_internal_mutable_compression_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.compression_type_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE ExternalTable::release_compression_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:clickhouse.grpc.ExternalTable.compression_type)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000010U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  auto* released = _impl_.compression_type_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.compression_type_.Set("", GetArena());
  }
  return released;
}
inline void ExternalTable::set_allocated_compression_type(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  }
  _impl_.compression_type_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.compression_type_.IsDefault()) {
    _impl_.compression_type_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:clickhouse.grpc.ExternalTable.compression_type)
}

// map<string, string> settings = 5;
inline int ExternalTable::_internal_settings_size() const {
  return _internal_settings().size();
}
inline int ExternalTable::settings_size() const {
  return _internal_settings_size();
}
inline void ExternalTable::clear_settings() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.settings_.Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
}
inline const ::google::protobuf::Map<::std::string, ::std::string>& ExternalTable::_internal_settings() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.settings_.GetMap();
}
inline const ::google::protobuf::Map<::std::string, ::std::string>& ExternalTable::settings() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_map:clickhouse.grpc.ExternalTable.settings)
  return _internal_settings();
}
inline ::google::protobuf::Map<::std::string, ::std::string>* PROTOBUF_NONNULL ExternalTable::_internal_mutable_settings() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.settings_.MutableMap();
}
inline ::google::protobuf::Map<::std::string, ::std::string>* PROTOBUF_NONNULL ExternalTable::mutable_settings()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  // @@protoc_insertion_point(field_mutable_map:clickhouse.grpc.ExternalTable.settings)
  return _internal_mutable_settings();
}

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

// ObsoleteTransportCompression

// .clickhouse.grpc.ObsoleteTransportCompression.CompressionAlgorithm algorithm = 1;
inline void ObsoleteTransportCompression::clear_algorithm() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.algorithm_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline ::clickhouse::grpc::ObsoleteTransportCompression_CompressionAlgorithm ObsoleteTransportCompression::algorithm() const {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.ObsoleteTransportCompression.algorithm)
  return _internal_algorithm();
}
inline void ObsoleteTransportCompression::set_algorithm(::clickhouse::grpc::ObsoleteTransportCompression_CompressionAlgorithm value) {
  _internal_set_algorithm(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_set:clickhouse.grpc.ObsoleteTransportCompression.algorithm)
}
inline ::clickhouse::grpc::ObsoleteTransportCompression_CompressionAlgorithm ObsoleteTransportCompression::_internal_algorithm() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::clickhouse::grpc::ObsoleteTransportCompression_CompressionAlgorithm>(_impl_.algorithm_);
}
inline void ObsoleteTransportCompression::_internal_set_algorithm(::clickhouse::grpc::ObsoleteTransportCompression_CompressionAlgorithm value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.algorithm_ = value;
}

// .clickhouse.grpc.ObsoleteTransportCompression.CompressionLevel level = 2;
inline void ObsoleteTransportCompression::clear_level() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.level_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline ::clickhouse::grpc::ObsoleteTransportCompression_CompressionLevel ObsoleteTransportCompression::level() const {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.ObsoleteTransportCompression.level)
  return _internal_level();
}
inline void ObsoleteTransportCompression::set_level(::clickhouse::grpc::ObsoleteTransportCompression_CompressionLevel value) {
  _internal_set_level(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:clickhouse.grpc.ObsoleteTransportCompression.level)
}
inline ::clickhouse::grpc::ObsoleteTransportCompression_CompressionLevel ObsoleteTransportCompression::_internal_level() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::clickhouse::grpc::ObsoleteTransportCompression_CompressionLevel>(_impl_.level_);
}
inline void ObsoleteTransportCompression::_internal_set_level(::clickhouse::grpc::ObsoleteTransportCompression_CompressionLevel value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.level_ = value;
}

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

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

// QueryInfo

// string query = 1;
inline void QueryInfo::clear_query() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.query_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline const ::std::string& QueryInfo::query() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.QueryInfo.query)
  return _internal_query();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void QueryInfo::set_query(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  _impl_.query_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:clickhouse.grpc.QueryInfo.query)
}
inline ::std::string* PROTOBUF_NONNULL QueryInfo::mutable_query()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::std::string* _s = _internal_mutable_query();
  // @@protoc_insertion_point(field_mutable:clickhouse.grpc.QueryInfo.query)
  return _s;
}
inline const ::std::string& QueryInfo::_internal_query() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.query_.Get();
}
inline void QueryInfo::_internal_set_query(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.query_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL QueryInfo::_internal_mutable_query() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.query_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE QueryInfo::release_query() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:clickhouse.grpc.QueryInfo.query)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  auto* released = _impl_.query_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.query_.Set("", GetArena());
  }
  return released;
}
inline void QueryInfo::set_allocated_query(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
  _impl_.query_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.query_.IsDefault()) {
    _impl_.query_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:clickhouse.grpc.QueryInfo.query)
}

// string query_id = 2;
inline void QueryInfo::clear_query_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.query_id_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline const ::std::string& QueryInfo::query_id() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.QueryInfo.query_id)
  return _internal_query_id();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void QueryInfo::set_query_id(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  _impl_.query_id_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:clickhouse.grpc.QueryInfo.query_id)
}
inline ::std::string* PROTOBUF_NONNULL QueryInfo::mutable_query_id()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::std::string* _s = _internal_mutable_query_id();
  // @@protoc_insertion_point(field_mutable:clickhouse.grpc.QueryInfo.query_id)
  return _s;
}
inline const ::std::string& QueryInfo::_internal_query_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.query_id_.Get();
}
inline void QueryInfo::_internal_set_query_id(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.query_id_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL QueryInfo::_internal_mutable_query_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.query_id_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE QueryInfo::release_query_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:clickhouse.grpc.QueryInfo.query_id)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000004U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  auto* released = _impl_.query_id_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.query_id_.Set("", GetArena());
  }
  return released;
}
inline void QueryInfo::set_allocated_query_id(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  }
  _impl_.query_id_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.query_id_.IsDefault()) {
    _impl_.query_id_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:clickhouse.grpc.QueryInfo.query_id)
}

// map<string, string> settings = 3;
inline int QueryInfo::_internal_settings_size() const {
  return _internal_settings().size();
}
inline int QueryInfo::settings_size() const {
  return _internal_settings_size();
}
inline void QueryInfo::clear_settings() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.settings_.Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x01000000U);
}
inline const ::google::protobuf::Map<::std::string, ::std::string>& QueryInfo::_internal_settings() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.settings_.GetMap();
}
inline const ::google::protobuf::Map<::std::string, ::std::string>& QueryInfo::settings() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_map:clickhouse.grpc.QueryInfo.settings)
  return _internal_settings();
}
inline ::google::protobuf::Map<::std::string, ::std::string>* PROTOBUF_NONNULL QueryInfo::_internal_mutable_settings() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.settings_.MutableMap();
}
inline ::google::protobuf::Map<::std::string, ::std::string>* PROTOBUF_NONNULL QueryInfo::mutable_settings()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x01000000U);
  // @@protoc_insertion_point(field_mutable_map:clickhouse.grpc.QueryInfo.settings)
  return _internal_mutable_settings();
}

// string database = 4;
inline void QueryInfo::clear_database() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.database_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline const ::std::string& QueryInfo::database() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.QueryInfo.database)
  return _internal_database();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void QueryInfo::set_database(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  _impl_.database_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:clickhouse.grpc.QueryInfo.database)
}
inline ::std::string* PROTOBUF_NONNULL QueryInfo::mutable_database()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::std::string* _s = _internal_mutable_database();
  // @@protoc_insertion_point(field_mutable:clickhouse.grpc.QueryInfo.database)
  return _s;
}
inline const ::std::string& QueryInfo::_internal_database() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.database_.Get();
}
inline void QueryInfo::_internal_set_database(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.database_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL QueryInfo::_internal_mutable_database() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.database_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE QueryInfo::release_database() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:clickhouse.grpc.QueryInfo.database)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000008U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  auto* released = _impl_.database_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.database_.Set("", GetArena());
  }
  return released;
}
inline void QueryInfo::set_allocated_database(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  }
  _impl_.database_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.database_.IsDefault()) {
    _impl_.database_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:clickhouse.grpc.QueryInfo.database)
}

// bytes input_data = 5;
inline void QueryInfo::clear_input_data() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.input_data_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
}
inline const ::std::string& QueryInfo::input_data() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.QueryInfo.input_data)
  return _internal_input_data();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void QueryInfo::set_input_data(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  _impl_.input_data_.SetBytes(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:clickhouse.grpc.QueryInfo.input_data)
}
inline ::std::string* PROTOBUF_NONNULL QueryInfo::mutable_input_data()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::std::string* _s = _internal_mutable_input_data();
  // @@protoc_insertion_point(field_mutable:clickhouse.grpc.QueryInfo.input_data)
  return _s;
}
inline const ::std::string& QueryInfo::_internal_input_data() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.input_data_.Get();
}
inline void QueryInfo::_internal_set_input_data(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.input_data_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL QueryInfo::_internal_mutable_input_data() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.input_data_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE QueryInfo::release_input_data() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:clickhouse.grpc.QueryInfo.input_data)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000010U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  auto* released = _impl_.input_data_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.input_data_.Set("", GetArena());
  }
  return released;
}
inline void QueryInfo::set_allocated_input_data(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  }
  _impl_.input_data_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.input_data_.IsDefault()) {
    _impl_.input_data_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:clickhouse.grpc.QueryInfo.input_data)
}

// bytes input_data_delimiter = 6;
inline void QueryInfo::clear_input_data_delimiter() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.input_data_delimiter_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
}
inline const ::std::string& QueryInfo::input_data_delimiter() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.QueryInfo.input_data_delimiter)
  return _internal_input_data_delimiter();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void QueryInfo::set_input_data_delimiter(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  _impl_.input_data_delimiter_.SetBytes(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:clickhouse.grpc.QueryInfo.input_data_delimiter)
}
inline ::std::string* PROTOBUF_NONNULL QueryInfo::mutable_input_data_delimiter()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  ::std::string* _s = _internal_mutable_input_data_delimiter();
  // @@protoc_insertion_point(field_mutable:clickhouse.grpc.QueryInfo.input_data_delimiter)
  return _s;
}
inline const ::std::string& QueryInfo::_internal_input_data_delimiter() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.input_data_delimiter_.Get();
}
inline void QueryInfo::_internal_set_input_data_delimiter(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.input_data_delimiter_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL QueryInfo::_internal_mutable_input_data_delimiter() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.input_data_delimiter_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE QueryInfo::release_input_data_delimiter() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:clickhouse.grpc.QueryInfo.input_data_delimiter)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000020U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  auto* released = _impl_.input_data_delimiter_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.input_data_delimiter_.Set("", GetArena());
  }
  return released;
}
inline void QueryInfo::set_allocated_input_data_delimiter(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  }
  _impl_.input_data_delimiter_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.input_data_delimiter_.IsDefault()) {
    _impl_.input_data_delimiter_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:clickhouse.grpc.QueryInfo.input_data_delimiter)
}

// string output_format = 7;
inline void QueryInfo::clear_output_format() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.output_format_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
}
inline const ::std::string& QueryInfo::output_format() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.QueryInfo.output_format)
  return _internal_output_format();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void QueryInfo::set_output_format(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  _impl_.output_format_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:clickhouse.grpc.QueryInfo.output_format)
}
inline ::std::string* PROTOBUF_NONNULL QueryInfo::mutable_output_format()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  ::std::string* _s = _internal_mutable_output_format();
  // @@protoc_insertion_point(field_mutable:clickhouse.grpc.QueryInfo.output_format)
  return _s;
}
inline const ::std::string& QueryInfo::_internal_output_format() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.output_format_.Get();
}
inline void QueryInfo::_internal_set_output_format(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.output_format_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL QueryInfo::_internal_mutable_output_format() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.output_format_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE QueryInfo::release_output_format() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:clickhouse.grpc.QueryInfo.output_format)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000040U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  auto* released = _impl_.output_format_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.output_format_.Set("", GetArena());
  }
  return released;
}
inline void QueryInfo::set_allocated_output_format(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  }
  _impl_.output_format_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.output_format_.IsDefault()) {
    _impl_.output_format_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:clickhouse.grpc.QueryInfo.output_format)
}

// bool send_output_columns = 24;
inline void QueryInfo::clear_send_output_columns() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.send_output_columns_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00200000U);
}
inline bool QueryInfo::send_output_columns() const {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.QueryInfo.send_output_columns)
  return _internal_send_output_columns();
}
inline void QueryInfo::set_send_output_columns(bool value) {
  _internal_set_send_output_columns(value);
  SetHasBit(_impl_._has_bits_[0], 0x00200000U);
  // @@protoc_insertion_point(field_set:clickhouse.grpc.QueryInfo.send_output_columns)
}
inline bool QueryInfo::_internal_send_output_columns() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.send_output_columns_;
}
inline void QueryInfo::_internal_set_send_output_columns(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.send_output_columns_ = value;
}

// repeated .clickhouse.grpc.ExternalTable external_tables = 8;
inline int QueryInfo::_internal_external_tables_size() const {
  return _internal_external_tables().size();
}
inline int QueryInfo::external_tables_size() const {
  return _internal_external_tables_size();
}
inline void QueryInfo::clear_external_tables() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.external_tables_.Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::clickhouse::grpc::ExternalTable& QueryInfo::external_tables(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.QueryInfo.external_tables)
  return _internal_external_tables().Get(index);
}
inline ::clickhouse::grpc::ExternalTable* PROTOBUF_NONNULL QueryInfo::mutable_external_tables(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:clickhouse.grpc.QueryInfo.external_tables)
  return _internal_mutable_external_tables()->Mutable(index);
}
inline ::clickhouse::grpc::ExternalTable* PROTOBUF_NONNULL QueryInfo::add_external_tables()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::clickhouse::grpc::ExternalTable* _add =
      _internal_mutable_external_tables()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add:clickhouse.grpc.QueryInfo.external_tables)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::clickhouse::grpc::ExternalTable>& QueryInfo::external_tables() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:clickhouse.grpc.QueryInfo.external_tables)
  return _internal_external_tables();
}
inline ::google::protobuf::RepeatedPtrField<::clickhouse::grpc::ExternalTable>* PROTOBUF_NONNULL
QueryInfo::mutable_external_tables() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_mutable_list:clickhouse.grpc.QueryInfo.external_tables)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_external_tables();
}
inline const ::google::protobuf::RepeatedPtrField<::clickhouse::grpc::ExternalTable>&
QueryInfo::_internal_external_tables() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.external_tables_;
}
inline ::google::protobuf::RepeatedPtrField<::clickhouse::grpc::ExternalTable>* PROTOBUF_NONNULL
QueryInfo::_internal_mutable_external_tables() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.external_tables_;
}

// string user_name = 9;
inline void QueryInfo::clear_user_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.user_name_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
}
inline const ::std::string& QueryInfo::user_name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.QueryInfo.user_name)
  return _internal_user_name();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void QueryInfo::set_user_name(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  _impl_.user_name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:clickhouse.grpc.QueryInfo.user_name)
}
inline ::std::string* PROTOBUF_NONNULL QueryInfo::mutable_user_name()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  ::std::string* _s = _internal_mutable_user_name();
  // @@protoc_insertion_point(field_mutable:clickhouse.grpc.QueryInfo.user_name)
  return _s;
}
inline const ::std::string& QueryInfo::_internal_user_name() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.user_name_.Get();
}
inline void QueryInfo::_internal_set_user_name(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.user_name_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL QueryInfo::_internal_mutable_user_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.user_name_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE QueryInfo::release_user_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:clickhouse.grpc.QueryInfo.user_name)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000080U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  auto* released = _impl_.user_name_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.user_name_.Set("", GetArena());
  }
  return released;
}
inline void QueryInfo::set_allocated_user_name(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  }
  _impl_.user_name_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.user_name_.IsDefault()) {
    _impl_.user_name_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:clickhouse.grpc.QueryInfo.user_name)
}

// string password = 10;
inline void QueryInfo::clear_password() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.password_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
}
inline const ::std::string& QueryInfo::password() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.QueryInfo.password)
  return _internal_password();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void QueryInfo::set_password(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  _impl_.password_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:clickhouse.grpc.QueryInfo.password)
}
inline ::std::string* PROTOBUF_NONNULL QueryInfo::mutable_password()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  ::std::string* _s = _internal_mutable_password();
  // @@protoc_insertion_point(field_mutable:clickhouse.grpc.QueryInfo.password)
  return _s;
}
inline const ::std::string& QueryInfo::_internal_password() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.password_.Get();
}
inline void QueryInfo::_internal_set_password(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.password_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL QueryInfo::_internal_mutable_password() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.password_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE QueryInfo::release_password() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:clickhouse.grpc.QueryInfo.password)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000100U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  auto* released = _impl_.password_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.password_.Set("", GetArena());
  }
  return released;
}
inline void QueryInfo::set_allocated_password(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  }
  _impl_.password_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.password_.IsDefault()) {
    _impl_.password_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:clickhouse.grpc.QueryInfo.password)
}

// string quota = 11;
inline void QueryInfo::clear_quota() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.quota_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
}
inline const ::std::string& QueryInfo::quota() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.QueryInfo.quota)
  return _internal_quota();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void QueryInfo::set_quota(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  _impl_.quota_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:clickhouse.grpc.QueryInfo.quota)
}
inline ::std::string* PROTOBUF_NONNULL QueryInfo::mutable_quota()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  ::std::string* _s = _internal_mutable_quota();
  // @@protoc_insertion_point(field_mutable:clickhouse.grpc.QueryInfo.quota)
  return _s;
}
inline const ::std::string& QueryInfo::_internal_quota() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.quota_.Get();
}
inline void QueryInfo::_internal_set_quota(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.quota_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL QueryInfo::_internal_mutable_quota() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.quota_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE QueryInfo::release_quota() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:clickhouse.grpc.QueryInfo.quota)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000200U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  auto* released = _impl_.quota_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.quota_.Set("", GetArena());
  }
  return released;
}
inline void QueryInfo::set_allocated_quota(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  }
  _impl_.quota_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.quota_.IsDefault()) {
    _impl_.quota_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:clickhouse.grpc.QueryInfo.quota)
}

// string jwt = 25;
inline void QueryInfo::clear_jwt() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.jwt_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00008000U);
}
inline const ::std::string& QueryInfo::jwt() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.QueryInfo.jwt)
  return _internal_jwt();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void QueryInfo::set_jwt(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00008000U);
  _impl_.jwt_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:clickhouse.grpc.QueryInfo.jwt)
}
inline ::std::string* PROTOBUF_NONNULL QueryInfo::mutable_jwt()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00008000U);
  ::std::string* _s = _internal_mutable_jwt();
  // @@protoc_insertion_point(field_mutable:clickhouse.grpc.QueryInfo.jwt)
  return _s;
}
inline const ::std::string& QueryInfo::_internal_jwt() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.jwt_.Get();
}
inline void QueryInfo::_internal_set_jwt(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.jwt_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL QueryInfo::_internal_mutable_jwt() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.jwt_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE QueryInfo::release_jwt() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:clickhouse.grpc.QueryInfo.jwt)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00008000U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00008000U);
  auto* released = _impl_.jwt_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.jwt_.Set("", GetArena());
  }
  return released;
}
inline void QueryInfo::set_allocated_jwt(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00008000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00008000U);
  }
  _impl_.jwt_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.jwt_.IsDefault()) {
    _impl_.jwt_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:clickhouse.grpc.QueryInfo.jwt)
}

// string session_id = 12;
inline void QueryInfo::clear_session_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.session_id_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
}
inline const ::std::string& QueryInfo::session_id() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.QueryInfo.session_id)
  return _internal_session_id();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void QueryInfo::set_session_id(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  _impl_.session_id_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:clickhouse.grpc.QueryInfo.session_id)
}
inline ::std::string* PROTOBUF_NONNULL QueryInfo::mutable_session_id()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  ::std::string* _s = _internal_mutable_session_id();
  // @@protoc_insertion_point(field_mutable:clickhouse.grpc.QueryInfo.session_id)
  return _s;
}
inline const ::std::string& QueryInfo::_internal_session_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.session_id_.Get();
}
inline void QueryInfo::_internal_set_session_id(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.session_id_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL QueryInfo::_internal_mutable_session_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.session_id_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE QueryInfo::release_session_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:clickhouse.grpc.QueryInfo.session_id)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000400U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
  auto* released = _impl_.session_id_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.session_id_.Set("", GetArena());
  }
  return released;
}
inline void QueryInfo::set_allocated_session_id(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
  }
  _impl_.session_id_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.session_id_.IsDefault()) {
    _impl_.session_id_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:clickhouse.grpc.QueryInfo.session_id)
}

// bool session_check = 13;
inline void QueryInfo::clear_session_check() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.session_check_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00040000U);
}
inline bool QueryInfo::session_check() const {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.QueryInfo.session_check)
  return _internal_session_check();
}
inline void QueryInfo::set_session_check(bool value) {
  _internal_set_session_check(value);
  SetHasBit(_impl_._has_bits_[0], 0x00040000U);
  // @@protoc_insertion_point(field_set:clickhouse.grpc.QueryInfo.session_check)
}
inline bool QueryInfo::_internal_session_check() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.session_check_;
}
inline void QueryInfo::_internal_set_session_check(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.session_check_ = value;
}

// uint32 session_timeout = 14;
inline void QueryInfo::clear_session_timeout() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.session_timeout_ = 0u;
  ClearHasBit(_impl_._has_bits_[0], 0x00020000U);
}
inline ::uint32_t QueryInfo::session_timeout() const {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.QueryInfo.session_timeout)
  return _internal_session_timeout();
}
inline void QueryInfo::set_session_timeout(::uint32_t value) {
  _internal_set_session_timeout(value);
  SetHasBit(_impl_._has_bits_[0], 0x00020000U);
  // @@protoc_insertion_point(field_set:clickhouse.grpc.QueryInfo.session_timeout)
}
inline ::uint32_t QueryInfo::_internal_session_timeout() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.session_timeout_;
}
inline void QueryInfo::_internal_set_session_timeout(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.session_timeout_ = value;
}

// bool cancel = 15;
inline void QueryInfo::clear_cancel() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cancel_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00080000U);
}
inline bool QueryInfo::cancel() const {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.QueryInfo.cancel)
  return _internal_cancel();
}
inline void QueryInfo::set_cancel(bool value) {
  _internal_set_cancel(value);
  SetHasBit(_impl_._has_bits_[0], 0x00080000U);
  // @@protoc_insertion_point(field_set:clickhouse.grpc.QueryInfo.cancel)
}
inline bool QueryInfo::_internal_cancel() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.cancel_;
}
inline void QueryInfo::_internal_set_cancel(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cancel_ = value;
}

// bool next_query_info = 16;
inline void QueryInfo::clear_next_query_info() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.next_query_info_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00100000U);
}
inline bool QueryInfo::next_query_info() const {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.QueryInfo.next_query_info)
  return _internal_next_query_info();
}
inline void QueryInfo::set_next_query_info(bool value) {
  _internal_set_next_query_info(value);
  SetHasBit(_impl_._has_bits_[0], 0x00100000U);
  // @@protoc_insertion_point(field_set:clickhouse.grpc.QueryInfo.next_query_info)
}
inline bool QueryInfo::_internal_next_query_info() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.next_query_info_;
}
inline void QueryInfo::_internal_set_next_query_info(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.next_query_info_ = value;
}

// string input_compression_type = 20;
inline void QueryInfo::clear_input_compression_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.input_compression_type_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00001000U);
}
inline const ::std::string& QueryInfo::input_compression_type() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.QueryInfo.input_compression_type)
  return _internal_input_compression_type();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void QueryInfo::set_input_compression_type(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00001000U);
  _impl_.input_compression_type_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:clickhouse.grpc.QueryInfo.input_compression_type)
}
inline ::std::string* PROTOBUF_NONNULL QueryInfo::mutable_input_compression_type()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00001000U);
  ::std::string* _s = _internal_mutable_input_compression_type();
  // @@protoc_insertion_point(field_mutable:clickhouse.grpc.QueryInfo.input_compression_type)
  return _s;
}
inline const ::std::string& QueryInfo::_internal_input_compression_type() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.input_compression_type_.Get();
}
inline void QueryInfo::_internal_set_input_compression_type(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.input_compression_type_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL QueryInfo::_internal_mutable_input_compression_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.input_compression_type_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE QueryInfo::release_input_compression_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:clickhouse.grpc.QueryInfo.input_compression_type)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00001000U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00001000U);
  auto* released = _impl_.input_compression_type_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.input_compression_type_.Set("", GetArena());
  }
  return released;
}
inline void QueryInfo::set_allocated_input_compression_type(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00001000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00001000U);
  }
  _impl_.input_compression_type_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.input_compression_type_.IsDefault()) {
    _impl_.input_compression_type_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:clickhouse.grpc.QueryInfo.input_compression_type)
}

// string output_compression_type = 21;
inline void QueryInfo::clear_output_compression_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.output_compression_type_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00002000U);
}
inline const ::std::string& QueryInfo::output_compression_type() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.QueryInfo.output_compression_type)
  return _internal_output_compression_type();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void QueryInfo::set_output_compression_type(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00002000U);
  _impl_.output_compression_type_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:clickhouse.grpc.QueryInfo.output_compression_type)
}
inline ::std::string* PROTOBUF_NONNULL QueryInfo::mutable_output_compression_type()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00002000U);
  ::std::string* _s = _internal_mutable_output_compression_type();
  // @@protoc_insertion_point(field_mutable:clickhouse.grpc.QueryInfo.output_compression_type)
  return _s;
}
inline const ::std::string& QueryInfo::_internal_output_compression_type() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.output_compression_type_.Get();
}
inline void QueryInfo::_internal_set_output_compression_type(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.output_compression_type_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL QueryInfo::_internal_mutable_output_compression_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.output_compression_type_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE QueryInfo::release_output_compression_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:clickhouse.grpc.QueryInfo.output_compression_type)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00002000U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00002000U);
  auto* released = _impl_.output_compression_type_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.output_compression_type_.Set("", GetArena());
  }
  return released;
}
inline void QueryInfo::set_allocated_output_compression_type(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00002000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00002000U);
  }
  _impl_.output_compression_type_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.output_compression_type_.IsDefault()) {
    _impl_.output_compression_type_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:clickhouse.grpc.QueryInfo.output_compression_type)
}

// int32 output_compression_level = 19;
inline void QueryInfo::clear_output_compression_level() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.output_compression_level_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00400000U);
}
inline ::int32_t QueryInfo::output_compression_level() const {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.QueryInfo.output_compression_level)
  return _internal_output_compression_level();
}
inline void QueryInfo::set_output_compression_level(::int32_t value) {
  _internal_set_output_compression_level(value);
  SetHasBit(_impl_._has_bits_[0], 0x00400000U);
  // @@protoc_insertion_point(field_set:clickhouse.grpc.QueryInfo.output_compression_level)
}
inline ::int32_t QueryInfo::_internal_output_compression_level() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.output_compression_level_;
}
inline void QueryInfo::_internal_set_output_compression_level(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.output_compression_level_ = value;
}

// string transport_compression_type = 22;
inline void QueryInfo::clear_transport_compression_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.transport_compression_type_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00004000U);
}
inline const ::std::string& QueryInfo::transport_compression_type() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.QueryInfo.transport_compression_type)
  return _internal_transport_compression_type();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void QueryInfo::set_transport_compression_type(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00004000U);
  _impl_.transport_compression_type_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:clickhouse.grpc.QueryInfo.transport_compression_type)
}
inline ::std::string* PROTOBUF_NONNULL QueryInfo::mutable_transport_compression_type()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00004000U);
  ::std::string* _s = _internal_mutable_transport_compression_type();
  // @@protoc_insertion_point(field_mutable:clickhouse.grpc.QueryInfo.transport_compression_type)
  return _s;
}
inline const ::std::string& QueryInfo::_internal_transport_compression_type() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.transport_compression_type_.Get();
}
inline void QueryInfo::_internal_set_transport_compression_type(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.transport_compression_type_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL QueryInfo::_internal_mutable_transport_compression_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.transport_compression_type_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE QueryInfo::release_transport_compression_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:clickhouse.grpc.QueryInfo.transport_compression_type)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00004000U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00004000U);
  auto* released = _impl_.transport_compression_type_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.transport_compression_type_.Set("", GetArena());
  }
  return released;
}
inline void QueryInfo::set_allocated_transport_compression_type(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00004000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00004000U);
  }
  _impl_.transport_compression_type_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.transport_compression_type_.IsDefault()) {
    _impl_.transport_compression_type_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:clickhouse.grpc.QueryInfo.transport_compression_type)
}

// int32 transport_compression_level = 23;
inline void QueryInfo::clear_transport_compression_level() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.transport_compression_level_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00800000U);
}
inline ::int32_t QueryInfo::transport_compression_level() const {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.QueryInfo.transport_compression_level)
  return _internal_transport_compression_level();
}
inline void QueryInfo::set_transport_compression_level(::int32_t value) {
  _internal_set_transport_compression_level(value);
  SetHasBit(_impl_._has_bits_[0], 0x00800000U);
  // @@protoc_insertion_point(field_set:clickhouse.grpc.QueryInfo.transport_compression_level)
}
inline ::int32_t QueryInfo::_internal_transport_compression_level() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.transport_compression_level_;
}
inline void QueryInfo::_internal_set_transport_compression_level(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.transport_compression_level_ = value;
}

// .clickhouse.grpc.ObsoleteTransportCompression obsolete_result_compression = 17;
inline bool QueryInfo::has_obsolete_result_compression() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00010000U);
  PROTOBUF_ASSUME(!value || _impl_.obsolete_result_compression_ != nullptr);
  return value;
}
inline void QueryInfo::clear_obsolete_result_compression() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.obsolete_result_compression_ != nullptr) _impl_.obsolete_result_compression_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00010000U);
}
inline const ::clickhouse::grpc::ObsoleteTransportCompression& QueryInfo::_internal_obsolete_result_compression() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::clickhouse::grpc::ObsoleteTransportCompression* p = _impl_.obsolete_result_compression_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::clickhouse::grpc::ObsoleteTransportCompression>(&::clickhouse::grpc::ObsoleteTransportCompression_globals_);
}
inline const ::clickhouse::grpc::ObsoleteTransportCompression& QueryInfo::obsolete_result_compression() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.QueryInfo.obsolete_result_compression)
  return _internal_obsolete_result_compression();
}
inline void QueryInfo::unsafe_arena_set_allocated_obsolete_result_compression(
    ::clickhouse::grpc::ObsoleteTransportCompression* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.obsolete_result_compression_);
  }
  _impl_.obsolete_result_compression_ = reinterpret_cast<::clickhouse::grpc::ObsoleteTransportCompression*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00010000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00010000U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:clickhouse.grpc.QueryInfo.obsolete_result_compression)
}
inline ::clickhouse::grpc::ObsoleteTransportCompression* PROTOBUF_NULLABLE QueryInfo::release_obsolete_result_compression() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00010000U);
  ::clickhouse::grpc::ObsoleteTransportCompression* released = _impl_.obsolete_result_compression_;
  _impl_.obsolete_result_compression_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::clickhouse::grpc::ObsoleteTransportCompression* PROTOBUF_NULLABLE QueryInfo::unsafe_arena_release_obsolete_result_compression() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:clickhouse.grpc.QueryInfo.obsolete_result_compression)

  ClearHasBit(_impl_._has_bits_[0], 0x00010000U);
  ::clickhouse::grpc::ObsoleteTransportCompression* temp = _impl_.obsolete_result_compression_;
  _impl_.obsolete_result_compression_ = nullptr;
  return temp;
}
inline ::clickhouse::grpc::ObsoleteTransportCompression* PROTOBUF_NONNULL QueryInfo::_internal_mutable_obsolete_result_compression() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.obsolete_result_compression_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::clickhouse::grpc::ObsoleteTransportCompression>(GetArena());
    _impl_.obsolete_result_compression_ = reinterpret_cast<::clickhouse::grpc::ObsoleteTransportCompression*>(p);
  }
  return _impl_.obsolete_result_compression_;
}
inline ::clickhouse::grpc::ObsoleteTransportCompression* PROTOBUF_NONNULL QueryInfo::mutable_obsolete_result_compression()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00010000U);
  ::clickhouse::grpc::ObsoleteTransportCompression* _msg = _internal_mutable_obsolete_result_compression();
  // @@protoc_insertion_point(field_mutable:clickhouse.grpc.QueryInfo.obsolete_result_compression)
  return _msg;
}
inline void QueryInfo::set_allocated_obsolete_result_compression(::clickhouse::grpc::ObsoleteTransportCompression* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.obsolete_result_compression_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = value->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00010000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00010000U);
  }

  _impl_.obsolete_result_compression_ = reinterpret_cast<::clickhouse::grpc::ObsoleteTransportCompression*>(value);
  // @@protoc_insertion_point(field_set_allocated:clickhouse.grpc.QueryInfo.obsolete_result_compression)
}

// string obsolete_compression_type = 18;
inline void QueryInfo::clear_obsolete_compression_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.obsolete_compression_type_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000800U);
}
inline const ::std::string& QueryInfo::obsolete_compression_type() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.QueryInfo.obsolete_compression_type)
  return _internal_obsolete_compression_type();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void QueryInfo::set_obsolete_compression_type(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000800U);
  _impl_.obsolete_compression_type_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:clickhouse.grpc.QueryInfo.obsolete_compression_type)
}
inline ::std::string* PROTOBUF_NONNULL QueryInfo::mutable_obsolete_compression_type()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000800U);
  ::std::string* _s = _internal_mutable_obsolete_compression_type();
  // @@protoc_insertion_point(field_mutable:clickhouse.grpc.QueryInfo.obsolete_compression_type)
  return _s;
}
inline const ::std::string& QueryInfo::_internal_obsolete_compression_type() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.obsolete_compression_type_.Get();
}
inline void QueryInfo::_internal_set_obsolete_compression_type(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.obsolete_compression_type_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL QueryInfo::_internal_mutable_obsolete_compression_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.obsolete_compression_type_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE QueryInfo::release_obsolete_compression_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:clickhouse.grpc.QueryInfo.obsolete_compression_type)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000800U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000800U);
  auto* released = _impl_.obsolete_compression_type_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.obsolete_compression_type_.Set("", GetArena());
  }
  return released;
}
inline void QueryInfo::set_allocated_obsolete_compression_type(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000800U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000800U);
  }
  _impl_.obsolete_compression_type_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.obsolete_compression_type_.IsDefault()) {
    _impl_.obsolete_compression_type_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:clickhouse.grpc.QueryInfo.obsolete_compression_type)
}

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

// LogEntry

// uint32 time = 1;
inline void LogEntry::clear_time() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.time_ = 0u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline ::uint32_t LogEntry::time() const {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.LogEntry.time)
  return _internal_time();
}
inline void LogEntry::set_time(::uint32_t value) {
  _internal_set_time(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_set:clickhouse.grpc.LogEntry.time)
}
inline ::uint32_t LogEntry::_internal_time() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.time_;
}
inline void LogEntry::_internal_set_time(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.time_ = value;
}

// uint32 time_microseconds = 2;
inline void LogEntry::clear_time_microseconds() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.time_microseconds_ = 0u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
}
inline ::uint32_t LogEntry::time_microseconds() const {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.LogEntry.time_microseconds)
  return _internal_time_microseconds();
}
inline void LogEntry::set_time_microseconds(::uint32_t value) {
  _internal_set_time_microseconds(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  // @@protoc_insertion_point(field_set:clickhouse.grpc.LogEntry.time_microseconds)
}
inline ::uint32_t LogEntry::_internal_time_microseconds() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.time_microseconds_;
}
inline void LogEntry::_internal_set_time_microseconds(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.time_microseconds_ = value;
}

// uint64 thread_id = 3;
inline void LogEntry::clear_thread_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.thread_id_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
}
inline ::uint64_t LogEntry::thread_id() const {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.LogEntry.thread_id)
  return _internal_thread_id();
}
inline void LogEntry::set_thread_id(::uint64_t value) {
  _internal_set_thread_id(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  // @@protoc_insertion_point(field_set:clickhouse.grpc.LogEntry.thread_id)
}
inline ::uint64_t LogEntry::_internal_thread_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.thread_id_;
}
inline void LogEntry::_internal_set_thread_id(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.thread_id_ = value;
}

// string query_id = 4;
inline void LogEntry::clear_query_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.query_id_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::std::string& LogEntry::query_id() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.LogEntry.query_id)
  return _internal_query_id();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void LogEntry::set_query_id(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.query_id_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:clickhouse.grpc.LogEntry.query_id)
}
inline ::std::string* PROTOBUF_NONNULL LogEntry::mutable_query_id()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_query_id();
  // @@protoc_insertion_point(field_mutable:clickhouse.grpc.LogEntry.query_id)
  return _s;
}
inline const ::std::string& LogEntry::_internal_query_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.query_id_.Get();
}
inline void LogEntry::_internal_set_query_id(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.query_id_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL LogEntry::_internal_mutable_query_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.query_id_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE LogEntry::release_query_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:clickhouse.grpc.LogEntry.query_id)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  auto* released = _impl_.query_id_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.query_id_.Set("", GetArena());
  }
  return released;
}
inline void LogEntry::set_allocated_query_id(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  _impl_.query_id_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.query_id_.IsDefault()) {
    _impl_.query_id_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:clickhouse.grpc.LogEntry.query_id)
}

// .clickhouse.grpc.LogsLevel level = 5;
inline void LogEntry::clear_level() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.level_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
}
inline ::clickhouse::grpc::LogsLevel LogEntry::level() const {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.LogEntry.level)
  return _internal_level();
}
inline void LogEntry::set_level(::clickhouse::grpc::LogsLevel value) {
  _internal_set_level(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  // @@protoc_insertion_point(field_set:clickhouse.grpc.LogEntry.level)
}
inline ::clickhouse::grpc::LogsLevel LogEntry::_internal_level() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::clickhouse::grpc::LogsLevel>(_impl_.level_);
}
inline void LogEntry::_internal_set_level(::clickhouse::grpc::LogsLevel value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.level_ = value;
}

// string source = 6;
inline void LogEntry::clear_source() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.source_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline const ::std::string& LogEntry::source() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.LogEntry.source)
  return _internal_source();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void LogEntry::set_source(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  _impl_.source_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:clickhouse.grpc.LogEntry.source)
}
inline ::std::string* PROTOBUF_NONNULL LogEntry::mutable_source()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::std::string* _s = _internal_mutable_source();
  // @@protoc_insertion_point(field_mutable:clickhouse.grpc.LogEntry.source)
  return _s;
}
inline const ::std::string& LogEntry::_internal_source() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.source_.Get();
}
inline void LogEntry::_internal_set_source(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.source_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL LogEntry::_internal_mutable_source() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.source_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE LogEntry::release_source() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:clickhouse.grpc.LogEntry.source)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  auto* released = _impl_.source_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.source_.Set("", GetArena());
  }
  return released;
}
inline void LogEntry::set_allocated_source(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
  _impl_.source_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.source_.IsDefault()) {
    _impl_.source_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:clickhouse.grpc.LogEntry.source)
}

// string text = 7;
inline void LogEntry::clear_text() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.text_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline const ::std::string& LogEntry::text() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.LogEntry.text)
  return _internal_text();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void LogEntry::set_text(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  _impl_.text_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:clickhouse.grpc.LogEntry.text)
}
inline ::std::string* PROTOBUF_NONNULL LogEntry::mutable_text()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::std::string* _s = _internal_mutable_text();
  // @@protoc_insertion_point(field_mutable:clickhouse.grpc.LogEntry.text)
  return _s;
}
inline const ::std::string& LogEntry::_internal_text() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.text_.Get();
}
inline void LogEntry::_internal_set_text(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.text_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL LogEntry::_internal_mutable_text() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.text_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE LogEntry::release_text() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:clickhouse.grpc.LogEntry.text)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000004U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  auto* released = _impl_.text_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.text_.Set("", GetArena());
  }
  return released;
}
inline void LogEntry::set_allocated_text(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  }
  _impl_.text_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.text_.IsDefault()) {
    _impl_.text_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:clickhouse.grpc.LogEntry.text)
}

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

// Progress

// uint64 read_rows = 1;
inline void Progress::clear_read_rows() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.read_rows_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline ::uint64_t Progress::read_rows() const {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.Progress.read_rows)
  return _internal_read_rows();
}
inline void Progress::set_read_rows(::uint64_t value) {
  _internal_set_read_rows(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_set:clickhouse.grpc.Progress.read_rows)
}
inline ::uint64_t Progress::_internal_read_rows() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.read_rows_;
}
inline void Progress::_internal_set_read_rows(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.read_rows_ = value;
}

// uint64 read_bytes = 2;
inline void Progress::clear_read_bytes() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.read_bytes_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline ::uint64_t Progress::read_bytes() const {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.Progress.read_bytes)
  return _internal_read_bytes();
}
inline void Progress::set_read_bytes(::uint64_t value) {
  _internal_set_read_bytes(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:clickhouse.grpc.Progress.read_bytes)
}
inline ::uint64_t Progress::_internal_read_bytes() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.read_bytes_;
}
inline void Progress::_internal_set_read_bytes(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.read_bytes_ = value;
}

// uint64 total_rows_to_read = 3;
inline void Progress::clear_total_rows_to_read() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.total_rows_to_read_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline ::uint64_t Progress::total_rows_to_read() const {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.Progress.total_rows_to_read)
  return _internal_total_rows_to_read();
}
inline void Progress::set_total_rows_to_read(::uint64_t value) {
  _internal_set_total_rows_to_read(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_set:clickhouse.grpc.Progress.total_rows_to_read)
}
inline ::uint64_t Progress::_internal_total_rows_to_read() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.total_rows_to_read_;
}
inline void Progress::_internal_set_total_rows_to_read(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.total_rows_to_read_ = value;
}

// uint64 written_rows = 4;
inline void Progress::clear_written_rows() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.written_rows_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline ::uint64_t Progress::written_rows() const {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.Progress.written_rows)
  return _internal_written_rows();
}
inline void Progress::set_written_rows(::uint64_t value) {
  _internal_set_written_rows(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_set:clickhouse.grpc.Progress.written_rows)
}
inline ::uint64_t Progress::_internal_written_rows() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.written_rows_;
}
inline void Progress::_internal_set_written_rows(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.written_rows_ = value;
}

// uint64 written_bytes = 5;
inline void Progress::clear_written_bytes() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.written_bytes_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
}
inline ::uint64_t Progress::written_bytes() const {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.Progress.written_bytes)
  return _internal_written_bytes();
}
inline void Progress::set_written_bytes(::uint64_t value) {
  _internal_set_written_bytes(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  // @@protoc_insertion_point(field_set:clickhouse.grpc.Progress.written_bytes)
}
inline ::uint64_t Progress::_internal_written_bytes() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.written_bytes_;
}
inline void Progress::_internal_set_written_bytes(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.written_bytes_ = value;
}

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

// Stats

// uint64 rows = 1;
inline void Stats::clear_rows() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rows_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline ::uint64_t Stats::rows() const {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.Stats.rows)
  return _internal_rows();
}
inline void Stats::set_rows(::uint64_t value) {
  _internal_set_rows(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_set:clickhouse.grpc.Stats.rows)
}
inline ::uint64_t Stats::_internal_rows() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.rows_;
}
inline void Stats::_internal_set_rows(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rows_ = value;
}

// uint64 blocks = 2;
inline void Stats::clear_blocks() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.blocks_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline ::uint64_t Stats::blocks() const {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.Stats.blocks)
  return _internal_blocks();
}
inline void Stats::set_blocks(::uint64_t value) {
  _internal_set_blocks(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:clickhouse.grpc.Stats.blocks)
}
inline ::uint64_t Stats::_internal_blocks() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.blocks_;
}
inline void Stats::_internal_set_blocks(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.blocks_ = value;
}

// uint64 allocated_bytes = 3;
inline void Stats::clear_allocated_bytes() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.allocated_bytes_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline ::uint64_t Stats::allocated_bytes() const {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.Stats.allocated_bytes)
  return _internal_allocated_bytes();
}
inline void Stats::set_allocated_bytes(::uint64_t value) {
  _internal_set_allocated_bytes(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_set:clickhouse.grpc.Stats.allocated_bytes)
}
inline ::uint64_t Stats::_internal_allocated_bytes() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.allocated_bytes_;
}
inline void Stats::_internal_set_allocated_bytes(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.allocated_bytes_ = value;
}

// bool applied_limit = 4;
inline void Stats::clear_applied_limit() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.applied_limit_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
}
inline bool Stats::applied_limit() const {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.Stats.applied_limit)
  return _internal_applied_limit();
}
inline void Stats::set_applied_limit(bool value) {
  _internal_set_applied_limit(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  // @@protoc_insertion_point(field_set:clickhouse.grpc.Stats.applied_limit)
}
inline bool Stats::_internal_applied_limit() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.applied_limit_;
}
inline void Stats::_internal_set_applied_limit(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.applied_limit_ = value;
}

// uint64 rows_before_limit = 5;
inline void Stats::clear_rows_before_limit() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rows_before_limit_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline ::uint64_t Stats::rows_before_limit() const {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.Stats.rows_before_limit)
  return _internal_rows_before_limit();
}
inline void Stats::set_rows_before_limit(::uint64_t value) {
  _internal_set_rows_before_limit(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_set:clickhouse.grpc.Stats.rows_before_limit)
}
inline ::uint64_t Stats::_internal_rows_before_limit() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.rows_before_limit_;
}
inline void Stats::_internal_set_rows_before_limit(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rows_before_limit_ = value;
}

// bool applied_aggregation = 6;
inline void Stats::clear_applied_aggregation() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.applied_aggregation_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
}
inline bool Stats::applied_aggregation() const {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.Stats.applied_aggregation)
  return _internal_applied_aggregation();
}
inline void Stats::set_applied_aggregation(bool value) {
  _internal_set_applied_aggregation(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  // @@protoc_insertion_point(field_set:clickhouse.grpc.Stats.applied_aggregation)
}
inline bool Stats::_internal_applied_aggregation() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.applied_aggregation_;
}
inline void Stats::_internal_set_applied_aggregation(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.applied_aggregation_ = value;
}

// uint64 rows_before_aggregation = 7;
inline void Stats::clear_rows_before_aggregation() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rows_before_aggregation_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
}
inline ::uint64_t Stats::rows_before_aggregation() const {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.Stats.rows_before_aggregation)
  return _internal_rows_before_aggregation();
}
inline void Stats::set_rows_before_aggregation(::uint64_t value) {
  _internal_set_rows_before_aggregation(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  // @@protoc_insertion_point(field_set:clickhouse.grpc.Stats.rows_before_aggregation)
}
inline ::uint64_t Stats::_internal_rows_before_aggregation() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.rows_before_aggregation_;
}
inline void Stats::_internal_set_rows_before_aggregation(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rows_before_aggregation_ = value;
}

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

// Exception

// int32 code = 1;
inline void Exception::clear_code() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.code_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline ::int32_t Exception::code() const {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.Exception.code)
  return _internal_code();
}
inline void Exception::set_code(::int32_t value) {
  _internal_set_code(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_set:clickhouse.grpc.Exception.code)
}
inline ::int32_t Exception::_internal_code() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.code_;
}
inline void Exception::_internal_set_code(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.code_ = value;
}

// string name = 2;
inline void Exception::clear_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::std::string& Exception::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.Exception.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void Exception::set_name(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:clickhouse.grpc.Exception.name)
}
inline ::std::string* PROTOBUF_NONNULL Exception::mutable_name()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:clickhouse.grpc.Exception.name)
  return _s;
}
inline const ::std::string& Exception::_internal_name() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.name_.Get();
}
inline void Exception::_internal_set_name(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL Exception::_internal_mutable_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.name_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE Exception::release_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:clickhouse.grpc.Exception.name)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  auto* released = _impl_.name_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.name_.Set("", GetArena());
  }
  return released;
}
inline void Exception::set_allocated_name(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  _impl_.name_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:clickhouse.grpc.Exception.name)
}

// string display_text = 3;
inline void Exception::clear_display_text() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.display_text_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline const ::std::string& Exception::display_text() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.Exception.display_text)
  return _internal_display_text();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void Exception::set_display_text(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  _impl_.display_text_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:clickhouse.grpc.Exception.display_text)
}
inline ::std::string* PROTOBUF_NONNULL Exception::mutable_display_text()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::std::string* _s = _internal_mutable_display_text();
  // @@protoc_insertion_point(field_mutable:clickhouse.grpc.Exception.display_text)
  return _s;
}
inline const ::std::string& Exception::_internal_display_text() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.display_text_.Get();
}
inline void Exception::_internal_set_display_text(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.display_text_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL Exception::_internal_mutable_display_text() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.display_text_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE Exception::release_display_text() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:clickhouse.grpc.Exception.display_text)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  auto* released = _impl_.display_text_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.display_text_.Set("", GetArena());
  }
  return released;
}
inline void Exception::set_allocated_display_text(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
  _impl_.display_text_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.display_text_.IsDefault()) {
    _impl_.display_text_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:clickhouse.grpc.Exception.display_text)
}

// string stack_trace = 4;
inline void Exception::clear_stack_trace() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.stack_trace_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline const ::std::string& Exception::stack_trace() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.Exception.stack_trace)
  return _internal_stack_trace();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void Exception::set_stack_trace(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  _impl_.stack_trace_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:clickhouse.grpc.Exception.stack_trace)
}
inline ::std::string* PROTOBUF_NONNULL Exception::mutable_stack_trace()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::std::string* _s = _internal_mutable_stack_trace();
  // @@protoc_insertion_point(field_mutable:clickhouse.grpc.Exception.stack_trace)
  return _s;
}
inline const ::std::string& Exception::_internal_stack_trace() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.stack_trace_.Get();
}
inline void Exception::_internal_set_stack_trace(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.stack_trace_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL Exception::_internal_mutable_stack_trace() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.stack_trace_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE Exception::release_stack_trace() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:clickhouse.grpc.Exception.stack_trace)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000004U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  auto* released = _impl_.stack_trace_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.stack_trace_.Set("", GetArena());
  }
  return released;
}
inline void Exception::set_allocated_stack_trace(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  }
  _impl_.stack_trace_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.stack_trace_.IsDefault()) {
    _impl_.stack_trace_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:clickhouse.grpc.Exception.stack_trace)
}

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

// Result

// string query_id = 9;
inline void Result::clear_query_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.query_id_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
}
inline const ::std::string& Result::query_id() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.Result.query_id)
  return _internal_query_id();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void Result::set_query_id(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  _impl_.query_id_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:clickhouse.grpc.Result.query_id)
}
inline ::std::string* PROTOBUF_NONNULL Result::mutable_query_id()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  ::std::string* _s = _internal_mutable_query_id();
  // @@protoc_insertion_point(field_mutable:clickhouse.grpc.Result.query_id)
  return _s;
}
inline const ::std::string& Result::_internal_query_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.query_id_.Get();
}
inline void Result::_internal_set_query_id(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.query_id_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL Result::_internal_mutable_query_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.query_id_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE Result::release_query_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:clickhouse.grpc.Result.query_id)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000020U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  auto* released = _impl_.query_id_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.query_id_.Set("", GetArena());
  }
  return released;
}
inline void Result::set_allocated_query_id(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  }
  _impl_.query_id_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.query_id_.IsDefault()) {
    _impl_.query_id_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:clickhouse.grpc.Result.query_id)
}

// string time_zone = 10;
inline void Result::clear_time_zone() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.time_zone_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
}
inline const ::std::string& Result::time_zone() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.Result.time_zone)
  return _internal_time_zone();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void Result::set_time_zone(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  _impl_.time_zone_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:clickhouse.grpc.Result.time_zone)
}
inline ::std::string* PROTOBUF_NONNULL Result::mutable_time_zone()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  ::std::string* _s = _internal_mutable_time_zone();
  // @@protoc_insertion_point(field_mutable:clickhouse.grpc.Result.time_zone)
  return _s;
}
inline const ::std::string& Result::_internal_time_zone() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.time_zone_.Get();
}
inline void Result::_internal_set_time_zone(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.time_zone_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL Result::_internal_mutable_time_zone() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.time_zone_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE Result::release_time_zone() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:clickhouse.grpc.Result.time_zone)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000040U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  auto* released = _impl_.time_zone_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.time_zone_.Set("", GetArena());
  }
  return released;
}
inline void Result::set_allocated_time_zone(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  }
  _impl_.time_zone_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.time_zone_.IsDefault()) {
    _impl_.time_zone_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:clickhouse.grpc.Result.time_zone)
}

// string output_format = 11;
inline void Result::clear_output_format() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.output_format_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
}
inline const ::std::string& Result::output_format() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.Result.output_format)
  return _internal_output_format();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void Result::set_output_format(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  _impl_.output_format_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:clickhouse.grpc.Result.output_format)
}
inline ::std::string* PROTOBUF_NONNULL Result::mutable_output_format()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  ::std::string* _s = _internal_mutable_output_format();
  // @@protoc_insertion_point(field_mutable:clickhouse.grpc.Result.output_format)
  return _s;
}
inline const ::std::string& Result::_internal_output_format() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.output_format_.Get();
}
inline void Result::_internal_set_output_format(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.output_format_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL Result::_internal_mutable_output_format() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.output_format_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE Result::release_output_format() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:clickhouse.grpc.Result.output_format)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000080U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  auto* released = _impl_.output_format_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.output_format_.Set("", GetArena());
  }
  return released;
}
inline void Result::set_allocated_output_format(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  }
  _impl_.output_format_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.output_format_.IsDefault()) {
    _impl_.output_format_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:clickhouse.grpc.Result.output_format)
}

// repeated .clickhouse.grpc.NameAndType output_columns = 12;
inline int Result::_internal_output_columns_size() const {
  return _internal_output_columns().size();
}
inline int Result::output_columns_size() const {
  return _internal_output_columns_size();
}
inline void Result::clear_output_columns() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.output_columns_.Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline const ::clickhouse::grpc::NameAndType& Result::output_columns(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.Result.output_columns)
  return _internal_output_columns().Get(index);
}
inline ::clickhouse::grpc::NameAndType* PROTOBUF_NONNULL Result::mutable_output_columns(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:clickhouse.grpc.Result.output_columns)
  return _internal_mutable_output_columns()->Mutable(index);
}
inline ::clickhouse::grpc::NameAndType* PROTOBUF_NONNULL Result::add_output_columns()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::clickhouse::grpc::NameAndType* _add =
      _internal_mutable_output_columns()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_add:clickhouse.grpc.Result.output_columns)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::clickhouse::grpc::NameAndType>& Result::output_columns() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:clickhouse.grpc.Result.output_columns)
  return _internal_output_columns();
}
inline ::google::protobuf::RepeatedPtrField<::clickhouse::grpc::NameAndType>* PROTOBUF_NONNULL
Result::mutable_output_columns() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_mutable_list:clickhouse.grpc.Result.output_columns)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_output_columns();
}
inline const ::google::protobuf::RepeatedPtrField<::clickhouse::grpc::NameAndType>&
Result::_internal_output_columns() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.output_columns_;
}
inline ::google::protobuf::RepeatedPtrField<::clickhouse::grpc::NameAndType>* PROTOBUF_NONNULL
Result::_internal_mutable_output_columns() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.output_columns_;
}

// bytes output = 1;
inline void Result::clear_output() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.output_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline const ::std::string& Result::output() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.Result.output)
  return _internal_output();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void Result::set_output(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  _impl_.output_.SetBytes(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:clickhouse.grpc.Result.output)
}
inline ::std::string* PROTOBUF_NONNULL Result::mutable_output()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::std::string* _s = _internal_mutable_output();
  // @@protoc_insertion_point(field_mutable:clickhouse.grpc.Result.output)
  return _s;
}
inline const ::std::string& Result::_internal_output() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.output_.Get();
}
inline void Result::_internal_set_output(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.output_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL Result::_internal_mutable_output() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.output_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE Result::release_output() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:clickhouse.grpc.Result.output)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000004U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  auto* released = _impl_.output_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.output_.Set("", GetArena());
  }
  return released;
}
inline void Result::set_allocated_output(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  }
  _impl_.output_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.output_.IsDefault()) {
    _impl_.output_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:clickhouse.grpc.Result.output)
}

// bytes totals = 2;
inline void Result::clear_totals() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.totals_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline const ::std::string& Result::totals() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.Result.totals)
  return _internal_totals();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void Result::set_totals(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  _impl_.totals_.SetBytes(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:clickhouse.grpc.Result.totals)
}
inline ::std::string* PROTOBUF_NONNULL Result::mutable_totals()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::std::string* _s = _internal_mutable_totals();
  // @@protoc_insertion_point(field_mutable:clickhouse.grpc.Result.totals)
  return _s;
}
inline const ::std::string& Result::_internal_totals() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.totals_.Get();
}
inline void Result::_internal_set_totals(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.totals_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL Result::_internal_mutable_totals() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.totals_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE Result::release_totals() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:clickhouse.grpc.Result.totals)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000008U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  auto* released = _impl_.totals_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.totals_.Set("", GetArena());
  }
  return released;
}
inline void Result::set_allocated_totals(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  }
  _impl_.totals_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.totals_.IsDefault()) {
    _impl_.totals_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:clickhouse.grpc.Result.totals)
}

// bytes extremes = 3;
inline void Result::clear_extremes() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.extremes_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
}
inline const ::std::string& Result::extremes() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.Result.extremes)
  return _internal_extremes();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void Result::set_extremes(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  _impl_.extremes_.SetBytes(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:clickhouse.grpc.Result.extremes)
}
inline ::std::string* PROTOBUF_NONNULL Result::mutable_extremes()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::std::string* _s = _internal_mutable_extremes();
  // @@protoc_insertion_point(field_mutable:clickhouse.grpc.Result.extremes)
  return _s;
}
inline const ::std::string& Result::_internal_extremes() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.extremes_.Get();
}
inline void Result::_internal_set_extremes(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.extremes_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL Result::_internal_mutable_extremes() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.extremes_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE Result::release_extremes() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:clickhouse.grpc.Result.extremes)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000010U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  auto* released = _impl_.extremes_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.extremes_.Set("", GetArena());
  }
  return released;
}
inline void Result::set_allocated_extremes(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  }
  _impl_.extremes_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.extremes_.IsDefault()) {
    _impl_.extremes_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:clickhouse.grpc.Result.extremes)
}

// repeated .clickhouse.grpc.LogEntry logs = 4;
inline int Result::_internal_logs_size() const {
  return _internal_logs().size();
}
inline int Result::logs_size() const {
  return _internal_logs_size();
}
inline void Result::clear_logs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.logs_.Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::clickhouse::grpc::LogEntry& Result::logs(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.Result.logs)
  return _internal_logs().Get(index);
}
inline ::clickhouse::grpc::LogEntry* PROTOBUF_NONNULL Result::mutable_logs(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:clickhouse.grpc.Result.logs)
  return _internal_mutable_logs()->Mutable(index);
}
inline ::clickhouse::grpc::LogEntry* PROTOBUF_NONNULL Result::add_logs()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::clickhouse::grpc::LogEntry* _add =
      _internal_mutable_logs()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add:clickhouse.grpc.Result.logs)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::clickhouse::grpc::LogEntry>& Result::logs() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:clickhouse.grpc.Result.logs)
  return _internal_logs();
}
inline ::google::protobuf::RepeatedPtrField<::clickhouse::grpc::LogEntry>* PROTOBUF_NONNULL
Result::mutable_logs() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_mutable_list:clickhouse.grpc.Result.logs)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_logs();
}
inline const ::google::protobuf::RepeatedPtrField<::clickhouse::grpc::LogEntry>&
Result::_internal_logs() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.logs_;
}
inline ::google::protobuf::RepeatedPtrField<::clickhouse::grpc::LogEntry>* PROTOBUF_NONNULL
Result::_internal_mutable_logs() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.logs_;
}

// .clickhouse.grpc.Progress progress = 5;
inline bool Result::has_progress() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000100U);
  PROTOBUF_ASSUME(!value || _impl_.progress_ != nullptr);
  return value;
}
inline void Result::clear_progress() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.progress_ != nullptr) _impl_.progress_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
}
inline const ::clickhouse::grpc::Progress& Result::_internal_progress() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::clickhouse::grpc::Progress* p = _impl_.progress_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::clickhouse::grpc::Progress>(&::clickhouse::grpc::Progress_globals_);
}
inline const ::clickhouse::grpc::Progress& Result::progress() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.Result.progress)
  return _internal_progress();
}
inline void Result::unsafe_arena_set_allocated_progress(
    ::clickhouse::grpc::Progress* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.progress_);
  }
  _impl_.progress_ = reinterpret_cast<::clickhouse::grpc::Progress*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:clickhouse.grpc.Result.progress)
}
inline ::clickhouse::grpc::Progress* PROTOBUF_NULLABLE Result::release_progress() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  ::clickhouse::grpc::Progress* released = _impl_.progress_;
  _impl_.progress_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::clickhouse::grpc::Progress* PROTOBUF_NULLABLE Result::unsafe_arena_release_progress() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:clickhouse.grpc.Result.progress)

  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  ::clickhouse::grpc::Progress* temp = _impl_.progress_;
  _impl_.progress_ = nullptr;
  return temp;
}
inline ::clickhouse::grpc::Progress* PROTOBUF_NONNULL Result::_internal_mutable_progress() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.progress_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::clickhouse::grpc::Progress>(GetArena());
    _impl_.progress_ = reinterpret_cast<::clickhouse::grpc::Progress*>(p);
  }
  return _impl_.progress_;
}
inline ::clickhouse::grpc::Progress* PROTOBUF_NONNULL Result::mutable_progress()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  ::clickhouse::grpc::Progress* _msg = _internal_mutable_progress();
  // @@protoc_insertion_point(field_mutable:clickhouse.grpc.Result.progress)
  return _msg;
}
inline void Result::set_allocated_progress(::clickhouse::grpc::Progress* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.progress_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = value->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  }

  _impl_.progress_ = reinterpret_cast<::clickhouse::grpc::Progress*>(value);
  // @@protoc_insertion_point(field_set_allocated:clickhouse.grpc.Result.progress)
}

// .clickhouse.grpc.Stats stats = 6;
inline bool Result::has_stats() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000200U);
  PROTOBUF_ASSUME(!value || _impl_.stats_ != nullptr);
  return value;
}
inline void Result::clear_stats() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.stats_ != nullptr) _impl_.stats_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
}
inline const ::clickhouse::grpc::Stats& Result::_internal_stats() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::clickhouse::grpc::Stats* p = _impl_.stats_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::clickhouse::grpc::Stats>(&::clickhouse::grpc::Stats_globals_);
}
inline const ::clickhouse::grpc::Stats& Result::stats() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.Result.stats)
  return _internal_stats();
}
inline void Result::unsafe_arena_set_allocated_stats(
    ::clickhouse::grpc::Stats* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.stats_);
  }
  _impl_.stats_ = reinterpret_cast<::clickhouse::grpc::Stats*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:clickhouse.grpc.Result.stats)
}
inline ::clickhouse::grpc::Stats* PROTOBUF_NULLABLE Result::release_stats() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  ::clickhouse::grpc::Stats* released = _impl_.stats_;
  _impl_.stats_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::clickhouse::grpc::Stats* PROTOBUF_NULLABLE Result::unsafe_arena_release_stats() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:clickhouse.grpc.Result.stats)

  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  ::clickhouse::grpc::Stats* temp = _impl_.stats_;
  _impl_.stats_ = nullptr;
  return temp;
}
inline ::clickhouse::grpc::Stats* PROTOBUF_NONNULL Result::_internal_mutable_stats() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.stats_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::clickhouse::grpc::Stats>(GetArena());
    _impl_.stats_ = reinterpret_cast<::clickhouse::grpc::Stats*>(p);
  }
  return _impl_.stats_;
}
inline ::clickhouse::grpc::Stats* PROTOBUF_NONNULL Result::mutable_stats()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  ::clickhouse::grpc::Stats* _msg = _internal_mutable_stats();
  // @@protoc_insertion_point(field_mutable:clickhouse.grpc.Result.stats)
  return _msg;
}
inline void Result::set_allocated_stats(::clickhouse::grpc::Stats* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.stats_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = value->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  }

  _impl_.stats_ = reinterpret_cast<::clickhouse::grpc::Stats*>(value);
  // @@protoc_insertion_point(field_set_allocated:clickhouse.grpc.Result.stats)
}

// .clickhouse.grpc.Exception exception = 7;
inline bool Result::has_exception() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000400U);
  PROTOBUF_ASSUME(!value || _impl_.exception_ != nullptr);
  return value;
}
inline void Result::clear_exception() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.exception_ != nullptr) _impl_.exception_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
}
inline const ::clickhouse::grpc::Exception& Result::_internal_exception() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::clickhouse::grpc::Exception* p = _impl_.exception_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::clickhouse::grpc::Exception>(&::clickhouse::grpc::Exception_globals_);
}
inline const ::clickhouse::grpc::Exception& Result::exception() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.Result.exception)
  return _internal_exception();
}
inline void Result::unsafe_arena_set_allocated_exception(
    ::clickhouse::grpc::Exception* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.exception_);
  }
  _impl_.exception_ = reinterpret_cast<::clickhouse::grpc::Exception*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:clickhouse.grpc.Result.exception)
}
inline ::clickhouse::grpc::Exception* PROTOBUF_NULLABLE Result::release_exception() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
  ::clickhouse::grpc::Exception* released = _impl_.exception_;
  _impl_.exception_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::clickhouse::grpc::Exception* PROTOBUF_NULLABLE Result::unsafe_arena_release_exception() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:clickhouse.grpc.Result.exception)

  ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
  ::clickhouse::grpc::Exception* temp = _impl_.exception_;
  _impl_.exception_ = nullptr;
  return temp;
}
inline ::clickhouse::grpc::Exception* PROTOBUF_NONNULL Result::_internal_mutable_exception() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.exception_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::clickhouse::grpc::Exception>(GetArena());
    _impl_.exception_ = reinterpret_cast<::clickhouse::grpc::Exception*>(p);
  }
  return _impl_.exception_;
}
inline ::clickhouse::grpc::Exception* PROTOBUF_NONNULL Result::mutable_exception()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  ::clickhouse::grpc::Exception* _msg = _internal_mutable_exception();
  // @@protoc_insertion_point(field_mutable:clickhouse.grpc.Result.exception)
  return _msg;
}
inline void Result::set_allocated_exception(::clickhouse::grpc::Exception* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.exception_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = value->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
  }

  _impl_.exception_ = reinterpret_cast<::clickhouse::grpc::Exception*>(value);
  // @@protoc_insertion_point(field_set_allocated:clickhouse.grpc.Result.exception)
}

// bool cancelled = 8;
inline void Result::clear_cancelled() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cancelled_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00000800U);
}
inline bool Result::cancelled() const {
  // @@protoc_insertion_point(field_get:clickhouse.grpc.Result.cancelled)
  return _internal_cancelled();
}
inline void Result::set_cancelled(bool value) {
  _internal_set_cancelled(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000800U);
  // @@protoc_insertion_point(field_set:clickhouse.grpc.Result.cancelled)
}
inline bool Result::_internal_cancelled() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.cancelled_;
}
inline void Result::_internal_set_cancelled(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cancelled_ = value;
}

#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif  // __GNUC__

// @@protoc_insertion_point(namespace_scope)
}  // namespace grpc
}  // namespace clickhouse


namespace google {
namespace protobuf {

template <>
struct is_proto_enum<::clickhouse::grpc::ObsoleteTransportCompression_CompressionAlgorithm> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::clickhouse::grpc::ObsoleteTransportCompression_CompressionAlgorithm>() {
  return ::clickhouse::grpc::ObsoleteTransportCompression_CompressionAlgorithm_descriptor();
}
template <>
struct is_proto_enum<::clickhouse::grpc::ObsoleteTransportCompression_CompressionLevel> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::clickhouse::grpc::ObsoleteTransportCompression_CompressionLevel>() {
  return ::clickhouse::grpc::ObsoleteTransportCompression_CompressionLevel_descriptor();
}
template <>
struct is_proto_enum<::clickhouse::grpc::LogsLevel> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::clickhouse::grpc::LogsLevel>() {
  return ::clickhouse::grpc::LogsLevel_descriptor();
}

}  // namespace protobuf
}  // namespace google

// @@protoc_insertion_point(global_scope)

#include "google/protobuf/port_undef.inc"
// clang-format on

#endif  // clickhouse_5fgrpc_2eproto_2epb_2eh
