Dima/orion_greptime_proto
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
d9167cab47d816b923399833e8945cd60ca95990
orion_greptime_proto/c++/greptime/v1/database.pb.h
T
JeremyHi d9167cab47 feat: row-based insert (#72) 
* feat: row-based insert

* feat: null value

* roback: null value

* feat: delete by row

* feat: rename Value to Field
2023-08-14 12:15:44 +08:00

3520 lines
126 KiB
C++
Raw Blame History

// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: greptime/v1/database.proto
#ifndef GOOGLE_PROTOBUF_INCLUDED_greptime_2fv1_2fdatabase_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_greptime_2fv1_2fdatabase_2eproto
#include <limits>
#include <string>
#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3021000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3021006 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif
#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.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/repeated_field.h> // IWYU pragma: export
#include <google/protobuf/extension_set.h> // IWYU pragma: export
#include <google/protobuf/unknown_field_set.h>
#include "greptime/v1/ddl.pb.h"
#include "greptime/v1/column.pb.h"
#include "greptime/v1/row.pb.h"
#include "greptime/v1/prom.pb.h"
#include "greptime/v1/common.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_greptime_2fv1_2fdatabase_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
} // namespace internal
PROTOBUF_NAMESPACE_CLOSE
// Internal implementation detail -- do not use these members.
struct TableStruct_greptime_2fv1_2fdatabase_2eproto {
static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_greptime_2fv1_2fdatabase_2eproto;
namespace greptime {
namespace v1 {
class DeleteRequest;
struct DeleteRequestDefaultTypeInternal;
extern DeleteRequestDefaultTypeInternal _DeleteRequest_default_instance_;
class GreptimeRequest;
struct GreptimeRequestDefaultTypeInternal;
extern GreptimeRequestDefaultTypeInternal _GreptimeRequest_default_instance_;
class GreptimeResponse;
struct GreptimeResponseDefaultTypeInternal;
extern GreptimeResponseDefaultTypeInternal _GreptimeResponse_default_instance_;
class InsertRequest;
struct InsertRequestDefaultTypeInternal;
extern InsertRequestDefaultTypeInternal _InsertRequest_default_instance_;
class InsertRequests;
struct InsertRequestsDefaultTypeInternal;
extern InsertRequestsDefaultTypeInternal _InsertRequests_default_instance_;
class QueryRequest;
struct QueryRequestDefaultTypeInternal;
extern QueryRequestDefaultTypeInternal _QueryRequest_default_instance_;
class RowDeleteRequest;
struct RowDeleteRequestDefaultTypeInternal;
extern RowDeleteRequestDefaultTypeInternal _RowDeleteRequest_default_instance_;
class RowInsertRequest;
struct RowInsertRequestDefaultTypeInternal;
extern RowInsertRequestDefaultTypeInternal _RowInsertRequest_default_instance_;
class RowInsertRequests;
struct RowInsertRequestsDefaultTypeInternal;
extern RowInsertRequestsDefaultTypeInternal _RowInsertRequests_default_instance_;
} // namespace v1
} // namespace greptime
PROTOBUF_NAMESPACE_OPEN
template<> ::greptime::v1::DeleteRequest* Arena::CreateMaybeMessage<::greptime::v1::DeleteRequest>(Arena*);
template<> ::greptime::v1::GreptimeRequest* Arena::CreateMaybeMessage<::greptime::v1::GreptimeRequest>(Arena*);
template<> ::greptime::v1::GreptimeResponse* Arena::CreateMaybeMessage<::greptime::v1::GreptimeResponse>(Arena*);
template<> ::greptime::v1::InsertRequest* Arena::CreateMaybeMessage<::greptime::v1::InsertRequest>(Arena*);
template<> ::greptime::v1::InsertRequests* Arena::CreateMaybeMessage<::greptime::v1::InsertRequests>(Arena*);
template<> ::greptime::v1::QueryRequest* Arena::CreateMaybeMessage<::greptime::v1::QueryRequest>(Arena*);
template<> ::greptime::v1::RowDeleteRequest* Arena::CreateMaybeMessage<::greptime::v1::RowDeleteRequest>(Arena*);
template<> ::greptime::v1::RowInsertRequest* Arena::CreateMaybeMessage<::greptime::v1::RowInsertRequest>(Arena*);
template<> ::greptime::v1::RowInsertRequests* Arena::CreateMaybeMessage<::greptime::v1::RowInsertRequests>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace greptime {
namespace v1 {
// ===================================================================
class GreptimeRequest final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:greptime.v1.GreptimeRequest) */ {
public:
inline GreptimeRequest() : GreptimeRequest(nullptr) {}
~GreptimeRequest() override;
explicit PROTOBUF_CONSTEXPR GreptimeRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
GreptimeRequest(const GreptimeRequest& from);
GreptimeRequest(GreptimeRequest&& from) noexcept
: GreptimeRequest() {
*this = ::std::move(from);
}
inline GreptimeRequest& operator=(const GreptimeRequest& from) {
CopyFrom(from);
return *this;
}
inline GreptimeRequest& operator=(GreptimeRequest&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const GreptimeRequest& default_instance() {
return *internal_default_instance();
}
enum RequestCase {
kInserts = 2,
kQuery = 3,
kDdl = 4,
kDelete = 5,
kRowInserts = 6,
kRowDelete = 7,
REQUEST_NOT_SET = 0,
};
static inline const GreptimeRequest* internal_default_instance() {
return reinterpret_cast<const GreptimeRequest*>(
&_GreptimeRequest_default_instance_);
}
static constexpr int kIndexInFileMessages =
0;
friend void swap(GreptimeRequest& a, GreptimeRequest& b) {
a.Swap(&b);
}
inline void Swap(GreptimeRequest* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(GreptimeRequest* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
GreptimeRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<GreptimeRequest>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const GreptimeRequest& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom( const GreptimeRequest& from) {
GreptimeRequest::MergeImpl(*this, from);
}
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(GreptimeRequest* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "greptime.v1.GreptimeRequest";
}
protected:
explicit GreptimeRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kHeaderFieldNumber = 1,
kInsertsFieldNumber = 2,
kQueryFieldNumber = 3,
kDdlFieldNumber = 4,
kDeleteFieldNumber = 5,
kRowInsertsFieldNumber = 6,
kRowDeleteFieldNumber = 7,
};
// .greptime.v1.RequestHeader header = 1;
bool has_header() const;
private:
bool _internal_has_header() const;
public:
void clear_header();
const ::greptime::v1::RequestHeader& header() const;
PROTOBUF_NODISCARD ::greptime::v1::RequestHeader* release_header();
::greptime::v1::RequestHeader* mutable_header();
void set_allocated_header(::greptime::v1::RequestHeader* header);
private:
const ::greptime::v1::RequestHeader& _internal_header() const;
::greptime::v1::RequestHeader* _internal_mutable_header();
public:
void unsafe_arena_set_allocated_header(
::greptime::v1::RequestHeader* header);
::greptime::v1::RequestHeader* unsafe_arena_release_header();
// .greptime.v1.InsertRequests inserts = 2;
bool has_inserts() const;
private:
bool _internal_has_inserts() const;
public:
void clear_inserts();
const ::greptime::v1::InsertRequests& inserts() const;
PROTOBUF_NODISCARD ::greptime::v1::InsertRequests* release_inserts();
::greptime::v1::InsertRequests* mutable_inserts();
void set_allocated_inserts(::greptime::v1::InsertRequests* inserts);
private:
const ::greptime::v1::InsertRequests& _internal_inserts() const;
::greptime::v1::InsertRequests* _internal_mutable_inserts();
public:
void unsafe_arena_set_allocated_inserts(
::greptime::v1::InsertRequests* inserts);
::greptime::v1::InsertRequests* unsafe_arena_release_inserts();
// .greptime.v1.QueryRequest query = 3;
bool has_query() const;
private:
bool _internal_has_query() const;
public:
void clear_query();
const ::greptime::v1::QueryRequest& query() const;
PROTOBUF_NODISCARD ::greptime::v1::QueryRequest* release_query();
::greptime::v1::QueryRequest* mutable_query();
void set_allocated_query(::greptime::v1::QueryRequest* query);
private:
const ::greptime::v1::QueryRequest& _internal_query() const;
::greptime::v1::QueryRequest* _internal_mutable_query();
public:
void unsafe_arena_set_allocated_query(
::greptime::v1::QueryRequest* query);
::greptime::v1::QueryRequest* unsafe_arena_release_query();
// .greptime.v1.DdlRequest ddl = 4;
bool has_ddl() const;
private:
bool _internal_has_ddl() const;
public:
void clear_ddl();
const ::greptime::v1::DdlRequest& ddl() const;
PROTOBUF_NODISCARD ::greptime::v1::DdlRequest* release_ddl();
::greptime::v1::DdlRequest* mutable_ddl();
void set_allocated_ddl(::greptime::v1::DdlRequest* ddl);
private:
const ::greptime::v1::DdlRequest& _internal_ddl() const;
::greptime::v1::DdlRequest* _internal_mutable_ddl();
public:
void unsafe_arena_set_allocated_ddl(
::greptime::v1::DdlRequest* ddl);
::greptime::v1::DdlRequest* unsafe_arena_release_ddl();
// .greptime.v1.DeleteRequest delete = 5;
bool has_delete_() const;
private:
bool _internal_has_delete_() const;
public:
void clear_delete_();
const ::greptime::v1::DeleteRequest& delete_() const;
PROTOBUF_NODISCARD ::greptime::v1::DeleteRequest* release_delete_();
::greptime::v1::DeleteRequest* mutable_delete_();
void set_allocated_delete_(::greptime::v1::DeleteRequest* delete_);
private:
const ::greptime::v1::DeleteRequest& _internal_delete_() const;
::greptime::v1::DeleteRequest* _internal_mutable_delete_();
public:
void unsafe_arena_set_allocated_delete_(
::greptime::v1::DeleteRequest* delete_);
::greptime::v1::DeleteRequest* unsafe_arena_release_delete_();
// .greptime.v1.RowInsertRequests row_inserts = 6;
bool has_row_inserts() const;
private:
bool _internal_has_row_inserts() const;
public:
void clear_row_inserts();
const ::greptime::v1::RowInsertRequests& row_inserts() const;
PROTOBUF_NODISCARD ::greptime::v1::RowInsertRequests* release_row_inserts();
::greptime::v1::RowInsertRequests* mutable_row_inserts();
void set_allocated_row_inserts(::greptime::v1::RowInsertRequests* row_inserts);
private:
const ::greptime::v1::RowInsertRequests& _internal_row_inserts() const;
::greptime::v1::RowInsertRequests* _internal_mutable_row_inserts();
public:
void unsafe_arena_set_allocated_row_inserts(
::greptime::v1::RowInsertRequests* row_inserts);
::greptime::v1::RowInsertRequests* unsafe_arena_release_row_inserts();
// .greptime.v1.RowDeleteRequest row_delete = 7;
bool has_row_delete() const;
private:
bool _internal_has_row_delete() const;
public:
void clear_row_delete();
const ::greptime::v1::RowDeleteRequest& row_delete() const;
PROTOBUF_NODISCARD ::greptime::v1::RowDeleteRequest* release_row_delete();
::greptime::v1::RowDeleteRequest* mutable_row_delete();
void set_allocated_row_delete(::greptime::v1::RowDeleteRequest* row_delete);
private:
const ::greptime::v1::RowDeleteRequest& _internal_row_delete() const;
::greptime::v1::RowDeleteRequest* _internal_mutable_row_delete();
public:
void unsafe_arena_set_allocated_row_delete(
::greptime::v1::RowDeleteRequest* row_delete);
::greptime::v1::RowDeleteRequest* unsafe_arena_release_row_delete();
void clear_request();
RequestCase request_case() const;
// @@protoc_insertion_point(class_scope:greptime.v1.GreptimeRequest)
private:
class _Internal;
void set_has_inserts();
void set_has_query();
void set_has_ddl();
void set_has_delete_();
void set_has_row_inserts();
void set_has_row_delete();
inline bool has_request() const;
inline void clear_has_request();
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
::greptime::v1::RequestHeader* header_;
union RequestUnion {
constexpr RequestUnion() : _constinit_{} {}
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
::greptime::v1::InsertRequests* inserts_;
::greptime::v1::QueryRequest* query_;
::greptime::v1::DdlRequest* ddl_;
::greptime::v1::DeleteRequest* delete__;
::greptime::v1::RowInsertRequests* row_inserts_;
::greptime::v1::RowDeleteRequest* row_delete_;
} request_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
uint32_t _oneof_case_[1];
};
union { Impl_ _impl_; };
friend struct ::TableStruct_greptime_2fv1_2fdatabase_2eproto;
};
// -------------------------------------------------------------------
class GreptimeResponse final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:greptime.v1.GreptimeResponse) */ {
public:
inline GreptimeResponse() : GreptimeResponse(nullptr) {}
~GreptimeResponse() override;
explicit PROTOBUF_CONSTEXPR GreptimeResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
GreptimeResponse(const GreptimeResponse& from);
GreptimeResponse(GreptimeResponse&& from) noexcept
: GreptimeResponse() {
*this = ::std::move(from);
}
inline GreptimeResponse& operator=(const GreptimeResponse& from) {
CopyFrom(from);
return *this;
}
inline GreptimeResponse& operator=(GreptimeResponse&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const GreptimeResponse& default_instance() {
return *internal_default_instance();
}
enum ResponseCase {
kAffectedRows = 2,
RESPONSE_NOT_SET = 0,
};
static inline const GreptimeResponse* internal_default_instance() {
return reinterpret_cast<const GreptimeResponse*>(
&_GreptimeResponse_default_instance_);
}
static constexpr int kIndexInFileMessages =
1;
friend void swap(GreptimeResponse& a, GreptimeResponse& b) {
a.Swap(&b);
}
inline void Swap(GreptimeResponse* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(GreptimeResponse* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
GreptimeResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<GreptimeResponse>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const GreptimeResponse& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom( const GreptimeResponse& from) {
GreptimeResponse::MergeImpl(*this, from);
}
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(GreptimeResponse* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "greptime.v1.GreptimeResponse";
}
protected:
explicit GreptimeResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kHeaderFieldNumber = 1,
kAffectedRowsFieldNumber = 2,
};
// .greptime.v1.ResponseHeader header = 1;
bool has_header() const;
private:
bool _internal_has_header() const;
public:
void clear_header();
const ::greptime::v1::ResponseHeader& header() const;
PROTOBUF_NODISCARD ::greptime::v1::ResponseHeader* release_header();
::greptime::v1::ResponseHeader* mutable_header();
void set_allocated_header(::greptime::v1::ResponseHeader* header);
private:
const ::greptime::v1::ResponseHeader& _internal_header() const;
::greptime::v1::ResponseHeader* _internal_mutable_header();
public:
void unsafe_arena_set_allocated_header(
::greptime::v1::ResponseHeader* header);
::greptime::v1::ResponseHeader* unsafe_arena_release_header();
// .greptime.v1.AffectedRows affected_rows = 2;
bool has_affected_rows() const;
private:
bool _internal_has_affected_rows() const;
public:
void clear_affected_rows();
const ::greptime::v1::AffectedRows& affected_rows() const;
PROTOBUF_NODISCARD ::greptime::v1::AffectedRows* release_affected_rows();
::greptime::v1::AffectedRows* mutable_affected_rows();
void set_allocated_affected_rows(::greptime::v1::AffectedRows* affected_rows);
private:
const ::greptime::v1::AffectedRows& _internal_affected_rows() const;
::greptime::v1::AffectedRows* _internal_mutable_affected_rows();
public:
void unsafe_arena_set_allocated_affected_rows(
::greptime::v1::AffectedRows* affected_rows);
::greptime::v1::AffectedRows* unsafe_arena_release_affected_rows();
void clear_response();
ResponseCase response_case() const;
// @@protoc_insertion_point(class_scope:greptime.v1.GreptimeResponse)
private:
class _Internal;
void set_has_affected_rows();
inline bool has_response() const;
inline void clear_has_response();
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
::greptime::v1::ResponseHeader* header_;
union ResponseUnion {
constexpr ResponseUnion() : _constinit_{} {}
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
::greptime::v1::AffectedRows* affected_rows_;
} response_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
uint32_t _oneof_case_[1];
};
union { Impl_ _impl_; };
friend struct ::TableStruct_greptime_2fv1_2fdatabase_2eproto;
};
// -------------------------------------------------------------------
class QueryRequest final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:greptime.v1.QueryRequest) */ {
public:
inline QueryRequest() : QueryRequest(nullptr) {}
~QueryRequest() override;
explicit PROTOBUF_CONSTEXPR QueryRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
QueryRequest(const QueryRequest& from);
QueryRequest(QueryRequest&& from) noexcept
: QueryRequest() {
*this = ::std::move(from);
}
inline QueryRequest& operator=(const QueryRequest& from) {
CopyFrom(from);
return *this;
}
inline QueryRequest& operator=(QueryRequest&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const QueryRequest& default_instance() {
return *internal_default_instance();
}
enum QueryCase {
kSql = 1,
kLogicalPlan = 2,
kPromRangeQuery = 3,
QUERY_NOT_SET = 0,
};
static inline const QueryRequest* internal_default_instance() {
return reinterpret_cast<const QueryRequest*>(
&_QueryRequest_default_instance_);
}
static constexpr int kIndexInFileMessages =
2;
friend void swap(QueryRequest& a, QueryRequest& b) {
a.Swap(&b);
}
inline void Swap(QueryRequest* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(QueryRequest* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
QueryRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<QueryRequest>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const QueryRequest& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom( const QueryRequest& from) {
QueryRequest::MergeImpl(*this, from);
}
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(QueryRequest* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "greptime.v1.QueryRequest";
}
protected:
explicit QueryRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kSqlFieldNumber = 1,
kLogicalPlanFieldNumber = 2,
kPromRangeQueryFieldNumber = 3,
};
// string sql = 1;
bool has_sql() const;
private:
bool _internal_has_sql() const;
public:
void clear_sql();
const std::string& sql() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_sql(ArgT0&& arg0, ArgT... args);
std::string* mutable_sql();
PROTOBUF_NODISCARD std::string* release_sql();
void set_allocated_sql(std::string* sql);
private:
const std::string& _internal_sql() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_sql(const std::string& value);
std::string* _internal_mutable_sql();
public:
// bytes logical_plan = 2;
bool has_logical_plan() const;
private:
bool _internal_has_logical_plan() const;
public:
void clear_logical_plan();
const std::string& logical_plan() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_logical_plan(ArgT0&& arg0, ArgT... args);
std::string* mutable_logical_plan();
PROTOBUF_NODISCARD std::string* release_logical_plan();
void set_allocated_logical_plan(std::string* logical_plan);
private:
const std::string& _internal_logical_plan() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_logical_plan(const std::string& value);
std::string* _internal_mutable_logical_plan();
public:
// .greptime.v1.PromRangeQuery prom_range_query = 3;
bool has_prom_range_query() const;
private:
bool _internal_has_prom_range_query() const;
public:
void clear_prom_range_query();
const ::greptime::v1::PromRangeQuery& prom_range_query() const;
PROTOBUF_NODISCARD ::greptime::v1::PromRangeQuery* release_prom_range_query();
::greptime::v1::PromRangeQuery* mutable_prom_range_query();
void set_allocated_prom_range_query(::greptime::v1::PromRangeQuery* prom_range_query);
private:
const ::greptime::v1::PromRangeQuery& _internal_prom_range_query() const;
::greptime::v1::PromRangeQuery* _internal_mutable_prom_range_query();
public:
void unsafe_arena_set_allocated_prom_range_query(
::greptime::v1::PromRangeQuery* prom_range_query);
::greptime::v1::PromRangeQuery* unsafe_arena_release_prom_range_query();
void clear_query();
QueryCase query_case() const;
// @@protoc_insertion_point(class_scope:greptime.v1.QueryRequest)
private:
class _Internal;
void set_has_sql();
void set_has_logical_plan();
void set_has_prom_range_query();
inline bool has_query() const;
inline void clear_has_query();
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
union QueryUnion {
constexpr QueryUnion() : _constinit_{} {}
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sql_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr logical_plan_;
::greptime::v1::PromRangeQuery* prom_range_query_;
} query_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
uint32_t _oneof_case_[1];
};
union { Impl_ _impl_; };
friend struct ::TableStruct_greptime_2fv1_2fdatabase_2eproto;
};
// -------------------------------------------------------------------
class InsertRequests final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:greptime.v1.InsertRequests) */ {
public:
inline InsertRequests() : InsertRequests(nullptr) {}
~InsertRequests() override;
explicit PROTOBUF_CONSTEXPR InsertRequests(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
InsertRequests(const InsertRequests& from);
InsertRequests(InsertRequests&& from) noexcept
: InsertRequests() {
*this = ::std::move(from);
}
inline InsertRequests& operator=(const InsertRequests& from) {
CopyFrom(from);
return *this;
}
inline InsertRequests& operator=(InsertRequests&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const InsertRequests& default_instance() {
return *internal_default_instance();
}
static inline const InsertRequests* internal_default_instance() {
return reinterpret_cast<const InsertRequests*>(
&_InsertRequests_default_instance_);
}
static constexpr int kIndexInFileMessages =
3;
friend void swap(InsertRequests& a, InsertRequests& b) {
a.Swap(&b);
}
inline void Swap(InsertRequests* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(InsertRequests* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
InsertRequests* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<InsertRequests>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const InsertRequests& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom( const InsertRequests& from) {
InsertRequests::MergeImpl(*this, from);
}
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(InsertRequests* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "greptime.v1.InsertRequests";
}
protected:
explicit InsertRequests(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kInsertsFieldNumber = 1,
};
// repeated .greptime.v1.InsertRequest inserts = 1;
int inserts_size() const;
private:
int _internal_inserts_size() const;
public:
void clear_inserts();
::greptime::v1::InsertRequest* mutable_inserts(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::InsertRequest >*
mutable_inserts();
private:
const ::greptime::v1::InsertRequest& _internal_inserts(int index) const;
::greptime::v1::InsertRequest* _internal_add_inserts();
public:
const ::greptime::v1::InsertRequest& inserts(int index) const;
::greptime::v1::InsertRequest* add_inserts();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::InsertRequest >&
inserts() const;
// @@protoc_insertion_point(class_scope:greptime.v1.InsertRequests)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::InsertRequest > inserts_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_greptime_2fv1_2fdatabase_2eproto;
};
// -------------------------------------------------------------------
class InsertRequest final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:greptime.v1.InsertRequest) */ {
public:
inline InsertRequest() : InsertRequest(nullptr) {}
~InsertRequest() override;
explicit PROTOBUF_CONSTEXPR InsertRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
InsertRequest(const InsertRequest& from);
InsertRequest(InsertRequest&& from) noexcept
: InsertRequest() {
*this = ::std::move(from);
}
inline InsertRequest& operator=(const InsertRequest& from) {
CopyFrom(from);
return *this;
}
inline InsertRequest& operator=(InsertRequest&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const InsertRequest& default_instance() {
return *internal_default_instance();
}
static inline const InsertRequest* internal_default_instance() {
return reinterpret_cast<const InsertRequest*>(
&_InsertRequest_default_instance_);
}
static constexpr int kIndexInFileMessages =
4;
friend void swap(InsertRequest& a, InsertRequest& b) {
a.Swap(&b);
}
inline void Swap(InsertRequest* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(InsertRequest* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
InsertRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<InsertRequest>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const InsertRequest& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom( const InsertRequest& from) {
InsertRequest::MergeImpl(*this, from);
}
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(InsertRequest* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "greptime.v1.InsertRequest";
}
protected:
explicit InsertRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kColumnsFieldNumber = 3,
kTableNameFieldNumber = 1,
kRowCountFieldNumber = 4,
kRegionNumberFieldNumber = 5,
};
// repeated .greptime.v1.Column columns = 3;
int columns_size() const;
private:
int _internal_columns_size() const;
public:
void clear_columns();
::greptime::v1::Column* mutable_columns(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Column >*
mutable_columns();
private:
const ::greptime::v1::Column& _internal_columns(int index) const;
::greptime::v1::Column* _internal_add_columns();
public:
const ::greptime::v1::Column& columns(int index) const;
::greptime::v1::Column* add_columns();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Column >&
columns() const;
// string table_name = 1;
void clear_table_name();
const std::string& table_name() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_table_name(ArgT0&& arg0, ArgT... args);
std::string* mutable_table_name();
PROTOBUF_NODISCARD std::string* release_table_name();
void set_allocated_table_name(std::string* table_name);
private:
const std::string& _internal_table_name() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_table_name(const std::string& value);
std::string* _internal_mutable_table_name();
public:
// uint32 row_count = 4;
void clear_row_count();
uint32_t row_count() const;
void set_row_count(uint32_t value);
private:
uint32_t _internal_row_count() const;
void _internal_set_row_count(uint32_t value);
public:
// uint32 region_number = 5;
void clear_region_number();
uint32_t region_number() const;
void set_region_number(uint32_t value);
private:
uint32_t _internal_region_number() const;
void _internal_set_region_number(uint32_t value);
public:
// @@protoc_insertion_point(class_scope:greptime.v1.InsertRequest)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Column > columns_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_name_;
uint32_t row_count_;
uint32_t region_number_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_greptime_2fv1_2fdatabase_2eproto;
};
// -------------------------------------------------------------------
class DeleteRequest final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:greptime.v1.DeleteRequest) */ {
public:
inline DeleteRequest() : DeleteRequest(nullptr) {}
~DeleteRequest() override;
explicit PROTOBUF_CONSTEXPR DeleteRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
DeleteRequest(const DeleteRequest& from);
DeleteRequest(DeleteRequest&& from) noexcept
: DeleteRequest() {
*this = ::std::move(from);
}
inline DeleteRequest& operator=(const DeleteRequest& from) {
CopyFrom(from);
return *this;
}
inline DeleteRequest& operator=(DeleteRequest&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const DeleteRequest& default_instance() {
return *internal_default_instance();
}
static inline const DeleteRequest* internal_default_instance() {
return reinterpret_cast<const DeleteRequest*>(
&_DeleteRequest_default_instance_);
}
static constexpr int kIndexInFileMessages =
5;
friend void swap(DeleteRequest& a, DeleteRequest& b) {
a.Swap(&b);
}
inline void Swap(DeleteRequest* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(DeleteRequest* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
DeleteRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<DeleteRequest>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const DeleteRequest& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom( const DeleteRequest& from) {
DeleteRequest::MergeImpl(*this, from);
}
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(DeleteRequest* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "greptime.v1.DeleteRequest";
}
protected:
explicit DeleteRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kKeyColumnsFieldNumber = 3,
kTableNameFieldNumber = 1,
kRegionNumberFieldNumber = 2,
kRowCountFieldNumber = 4,
};
// repeated .greptime.v1.Column key_columns = 3;
int key_columns_size() const;
private:
int _internal_key_columns_size() const;
public:
void clear_key_columns();
::greptime::v1::Column* mutable_key_columns(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Column >*
mutable_key_columns();
private:
const ::greptime::v1::Column& _internal_key_columns(int index) const;
::greptime::v1::Column* _internal_add_key_columns();
public:
const ::greptime::v1::Column& key_columns(int index) const;
::greptime::v1::Column* add_key_columns();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Column >&
key_columns() const;
// string table_name = 1;
void clear_table_name();
const std::string& table_name() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_table_name(ArgT0&& arg0, ArgT... args);
std::string* mutable_table_name();
PROTOBUF_NODISCARD std::string* release_table_name();
void set_allocated_table_name(std::string* table_name);
private:
const std::string& _internal_table_name() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_table_name(const std::string& value);
std::string* _internal_mutable_table_name();
public:
// uint32 region_number = 2;
void clear_region_number();
uint32_t region_number() const;
void set_region_number(uint32_t value);
private:
uint32_t _internal_region_number() const;
void _internal_set_region_number(uint32_t value);
public:
// uint32 row_count = 4;
void clear_row_count();
uint32_t row_count() const;
void set_row_count(uint32_t value);
private:
uint32_t _internal_row_count() const;
void _internal_set_row_count(uint32_t value);
public:
// @@protoc_insertion_point(class_scope:greptime.v1.DeleteRequest)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Column > key_columns_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_name_;
uint32_t region_number_;
uint32_t row_count_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_greptime_2fv1_2fdatabase_2eproto;
};
// -------------------------------------------------------------------
class RowInsertRequests final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:greptime.v1.RowInsertRequests) */ {
public:
inline RowInsertRequests() : RowInsertRequests(nullptr) {}
~RowInsertRequests() override;
explicit PROTOBUF_CONSTEXPR RowInsertRequests(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
RowInsertRequests(const RowInsertRequests& from);
RowInsertRequests(RowInsertRequests&& from) noexcept
: RowInsertRequests() {
*this = ::std::move(from);
}
inline RowInsertRequests& operator=(const RowInsertRequests& from) {
CopyFrom(from);
return *this;
}
inline RowInsertRequests& operator=(RowInsertRequests&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const RowInsertRequests& default_instance() {
return *internal_default_instance();
}
static inline const RowInsertRequests* internal_default_instance() {
return reinterpret_cast<const RowInsertRequests*>(
&_RowInsertRequests_default_instance_);
}
static constexpr int kIndexInFileMessages =
6;
friend void swap(RowInsertRequests& a, RowInsertRequests& b) {
a.Swap(&b);
}
inline void Swap(RowInsertRequests* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(RowInsertRequests* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
RowInsertRequests* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<RowInsertRequests>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const RowInsertRequests& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom( const RowInsertRequests& from) {
RowInsertRequests::MergeImpl(*this, from);
}
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(RowInsertRequests* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "greptime.v1.RowInsertRequests";
}
protected:
explicit RowInsertRequests(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kInsertsFieldNumber = 1,
};
// repeated .greptime.v1.RowInsertRequest inserts = 1;
int inserts_size() const;
private:
int _internal_inserts_size() const;
public:
void clear_inserts();
::greptime::v1::RowInsertRequest* mutable_inserts(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::RowInsertRequest >*
mutable_inserts();
private:
const ::greptime::v1::RowInsertRequest& _internal_inserts(int index) const;
::greptime::v1::RowInsertRequest* _internal_add_inserts();
public:
const ::greptime::v1::RowInsertRequest& inserts(int index) const;
::greptime::v1::RowInsertRequest* add_inserts();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::RowInsertRequest >&
inserts() const;
// @@protoc_insertion_point(class_scope:greptime.v1.RowInsertRequests)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::RowInsertRequest > inserts_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_greptime_2fv1_2fdatabase_2eproto;
};
// -------------------------------------------------------------------
class RowInsertRequest final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:greptime.v1.RowInsertRequest) */ {
public:
inline RowInsertRequest() : RowInsertRequest(nullptr) {}
~RowInsertRequest() override;
explicit PROTOBUF_CONSTEXPR RowInsertRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
RowInsertRequest(const RowInsertRequest& from);
RowInsertRequest(RowInsertRequest&& from) noexcept
: RowInsertRequest() {
*this = ::std::move(from);
}
inline RowInsertRequest& operator=(const RowInsertRequest& from) {
CopyFrom(from);
return *this;
}
inline RowInsertRequest& operator=(RowInsertRequest&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const RowInsertRequest& default_instance() {
return *internal_default_instance();
}
static inline const RowInsertRequest* internal_default_instance() {
return reinterpret_cast<const RowInsertRequest*>(
&_RowInsertRequest_default_instance_);
}
static constexpr int kIndexInFileMessages =
7;
friend void swap(RowInsertRequest& a, RowInsertRequest& b) {
a.Swap(&b);
}
inline void Swap(RowInsertRequest* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(RowInsertRequest* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
RowInsertRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<RowInsertRequest>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const RowInsertRequest& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom( const RowInsertRequest& from) {
RowInsertRequest::MergeImpl(*this, from);
}
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(RowInsertRequest* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "greptime.v1.RowInsertRequest";
}
protected:
explicit RowInsertRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kTableNameFieldNumber = 1,
kRowsFieldNumber = 2,
kRegionNumberFieldNumber = 3,
};
// string table_name = 1;
void clear_table_name();
const std::string& table_name() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_table_name(ArgT0&& arg0, ArgT... args);
std::string* mutable_table_name();
PROTOBUF_NODISCARD std::string* release_table_name();
void set_allocated_table_name(std::string* table_name);
private:
const std::string& _internal_table_name() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_table_name(const std::string& value);
std::string* _internal_mutable_table_name();
public:
// .greptime.v1.Rows rows = 2;
bool has_rows() const;
private:
bool _internal_has_rows() const;
public:
void clear_rows();
const ::greptime::v1::Rows& rows() const;
PROTOBUF_NODISCARD ::greptime::v1::Rows* release_rows();
::greptime::v1::Rows* mutable_rows();
void set_allocated_rows(::greptime::v1::Rows* rows);
private:
const ::greptime::v1::Rows& _internal_rows() const;
::greptime::v1::Rows* _internal_mutable_rows();
public:
void unsafe_arena_set_allocated_rows(
::greptime::v1::Rows* rows);
::greptime::v1::Rows* unsafe_arena_release_rows();
// uint32 region_number = 3;
void clear_region_number();
uint32_t region_number() const;
void set_region_number(uint32_t value);
private:
uint32_t _internal_region_number() const;
void _internal_set_region_number(uint32_t value);
public:
// @@protoc_insertion_point(class_scope:greptime.v1.RowInsertRequest)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_name_;
::greptime::v1::Rows* rows_;
uint32_t region_number_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_greptime_2fv1_2fdatabase_2eproto;
};
// -------------------------------------------------------------------
class RowDeleteRequest final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:greptime.v1.RowDeleteRequest) */ {
public:
inline RowDeleteRequest() : RowDeleteRequest(nullptr) {}
~RowDeleteRequest() override;
explicit PROTOBUF_CONSTEXPR RowDeleteRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
RowDeleteRequest(const RowDeleteRequest& from);
RowDeleteRequest(RowDeleteRequest&& from) noexcept
: RowDeleteRequest() {
*this = ::std::move(from);
}
inline RowDeleteRequest& operator=(const RowDeleteRequest& from) {
CopyFrom(from);
return *this;
}
inline RowDeleteRequest& operator=(RowDeleteRequest&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const RowDeleteRequest& default_instance() {
return *internal_default_instance();
}
static inline const RowDeleteRequest* internal_default_instance() {
return reinterpret_cast<const RowDeleteRequest*>(
&_RowDeleteRequest_default_instance_);
}
static constexpr int kIndexInFileMessages =
8;
friend void swap(RowDeleteRequest& a, RowDeleteRequest& b) {
a.Swap(&b);
}
inline void Swap(RowDeleteRequest* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(RowDeleteRequest* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
RowDeleteRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<RowDeleteRequest>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const RowDeleteRequest& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom( const RowDeleteRequest& from) {
RowDeleteRequest::MergeImpl(*this, from);
}
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(RowDeleteRequest* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "greptime.v1.RowDeleteRequest";
}
protected:
explicit RowDeleteRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kTableNameFieldNumber = 1,
kRowsFieldNumber = 2,
kRegionNumberFieldNumber = 3,
};
// string table_name = 1;
void clear_table_name();
const std::string& table_name() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_table_name(ArgT0&& arg0, ArgT... args);
std::string* mutable_table_name();
PROTOBUF_NODISCARD std::string* release_table_name();
void set_allocated_table_name(std::string* table_name);
private:
const std::string& _internal_table_name() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_table_name(const std::string& value);
std::string* _internal_mutable_table_name();
public:
// .greptime.v1.Rows rows = 2;
bool has_rows() const;
private:
bool _internal_has_rows() const;
public:
void clear_rows();
const ::greptime::v1::Rows& rows() const;
PROTOBUF_NODISCARD ::greptime::v1::Rows* release_rows();
::greptime::v1::Rows* mutable_rows();
void set_allocated_rows(::greptime::v1::Rows* rows);
private:
const ::greptime::v1::Rows& _internal_rows() const;
::greptime::v1::Rows* _internal_mutable_rows();
public:
void unsafe_arena_set_allocated_rows(
::greptime::v1::Rows* rows);
::greptime::v1::Rows* unsafe_arena_release_rows();
// uint32 region_number = 3;
void clear_region_number();
uint32_t region_number() const;
void set_region_number(uint32_t value);
private:
uint32_t _internal_region_number() const;
void _internal_set_region_number(uint32_t value);
public:
// @@protoc_insertion_point(class_scope:greptime.v1.RowDeleteRequest)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_name_;
::greptime::v1::Rows* rows_;
uint32_t region_number_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_greptime_2fv1_2fdatabase_2eproto;
};
// ===================================================================
// ===================================================================
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif // __GNUC__
// GreptimeRequest
// .greptime.v1.RequestHeader header = 1;
inline bool GreptimeRequest::_internal_has_header() const {
return this != internal_default_instance() && _impl_.header_ != nullptr;
}
inline bool GreptimeRequest::has_header() const {
return _internal_has_header();
}
inline const ::greptime::v1::RequestHeader& GreptimeRequest::_internal_header() const {
const ::greptime::v1::RequestHeader* p = _impl_.header_;
return p != nullptr ? *p : reinterpret_cast<const ::greptime::v1::RequestHeader&>(
::greptime::v1::_RequestHeader_default_instance_);
}
inline const ::greptime::v1::RequestHeader& GreptimeRequest::header() const {
// @@protoc_insertion_point(field_get:greptime.v1.GreptimeRequest.header)
return _internal_header();
}
inline void GreptimeRequest::unsafe_arena_set_allocated_header(
::greptime::v1::RequestHeader* header) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.header_);
}
_impl_.header_ = header;
if (header) {
} else {
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.GreptimeRequest.header)
}
inline ::greptime::v1::RequestHeader* GreptimeRequest::release_header() {
::greptime::v1::RequestHeader* temp = _impl_.header_;
_impl_.header_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::greptime::v1::RequestHeader* GreptimeRequest::unsafe_arena_release_header() {
// @@protoc_insertion_point(field_release:greptime.v1.GreptimeRequest.header)
::greptime::v1::RequestHeader* temp = _impl_.header_;
_impl_.header_ = nullptr;
return temp;
}
inline ::greptime::v1::RequestHeader* GreptimeRequest::_internal_mutable_header() {
if (_impl_.header_ == nullptr) {
auto* p = CreateMaybeMessage<::greptime::v1::RequestHeader>(GetArenaForAllocation());
_impl_.header_ = p;
}
return _impl_.header_;
}
inline ::greptime::v1::RequestHeader* GreptimeRequest::mutable_header() {
::greptime::v1::RequestHeader* _msg = _internal_mutable_header();
// @@protoc_insertion_point(field_mutable:greptime.v1.GreptimeRequest.header)
return _msg;
}
inline void GreptimeRequest::set_allocated_header(::greptime::v1::RequestHeader* header) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.header_);
}
if (header) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(header));
if (message_arena != submessage_arena) {
header = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, header, submessage_arena);
}
} else {
}
_impl_.header_ = header;
// @@protoc_insertion_point(field_set_allocated:greptime.v1.GreptimeRequest.header)
}
// .greptime.v1.InsertRequests inserts = 2;
inline bool GreptimeRequest::_internal_has_inserts() const {
return request_case() == kInserts;
}
inline bool GreptimeRequest::has_inserts() const {
return _internal_has_inserts();
}
inline void GreptimeRequest::set_has_inserts() {
_impl_._oneof_case_[0] = kInserts;
}
inline void GreptimeRequest::clear_inserts() {
if (_internal_has_inserts()) {
if (GetArenaForAllocation() == nullptr) {
delete _impl_.request_.inserts_;
}
clear_has_request();
}
}
inline ::greptime::v1::InsertRequests* GreptimeRequest::release_inserts() {
// @@protoc_insertion_point(field_release:greptime.v1.GreptimeRequest.inserts)
if (_internal_has_inserts()) {
clear_has_request();
::greptime::v1::InsertRequests* temp = _impl_.request_.inserts_;
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
_impl_.request_.inserts_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline const ::greptime::v1::InsertRequests& GreptimeRequest::_internal_inserts() const {
return _internal_has_inserts()
? *_impl_.request_.inserts_
: reinterpret_cast< ::greptime::v1::InsertRequests&>(::greptime::v1::_InsertRequests_default_instance_);
}
inline const ::greptime::v1::InsertRequests& GreptimeRequest::inserts() const {
// @@protoc_insertion_point(field_get:greptime.v1.GreptimeRequest.inserts)
return _internal_inserts();
}
inline ::greptime::v1::InsertRequests* GreptimeRequest::unsafe_arena_release_inserts() {
// @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.GreptimeRequest.inserts)
if (_internal_has_inserts()) {
clear_has_request();
::greptime::v1::InsertRequests* temp = _impl_.request_.inserts_;
_impl_.request_.inserts_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline void GreptimeRequest::unsafe_arena_set_allocated_inserts(::greptime::v1::InsertRequests* inserts) {
clear_request();
if (inserts) {
set_has_inserts();
_impl_.request_.inserts_ = inserts;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.GreptimeRequest.inserts)
}
inline ::greptime::v1::InsertRequests* GreptimeRequest::_internal_mutable_inserts() {
if (!_internal_has_inserts()) {
clear_request();
set_has_inserts();
_impl_.request_.inserts_ = CreateMaybeMessage< ::greptime::v1::InsertRequests >(GetArenaForAllocation());
}
return _impl_.request_.inserts_;
}
inline ::greptime::v1::InsertRequests* GreptimeRequest::mutable_inserts() {
::greptime::v1::InsertRequests* _msg = _internal_mutable_inserts();
// @@protoc_insertion_point(field_mutable:greptime.v1.GreptimeRequest.inserts)
return _msg;
}
// .greptime.v1.QueryRequest query = 3;
inline bool GreptimeRequest::_internal_has_query() const {
return request_case() == kQuery;
}
inline bool GreptimeRequest::has_query() const {
return _internal_has_query();
}
inline void GreptimeRequest::set_has_query() {
_impl_._oneof_case_[0] = kQuery;
}
inline void GreptimeRequest::clear_query() {
if (_internal_has_query()) {
if (GetArenaForAllocation() == nullptr) {
delete _impl_.request_.query_;
}
clear_has_request();
}
}
inline ::greptime::v1::QueryRequest* GreptimeRequest::release_query() {
// @@protoc_insertion_point(field_release:greptime.v1.GreptimeRequest.query)
if (_internal_has_query()) {
clear_has_request();
::greptime::v1::QueryRequest* temp = _impl_.request_.query_;
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
_impl_.request_.query_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline const ::greptime::v1::QueryRequest& GreptimeRequest::_internal_query() const {
return _internal_has_query()
? *_impl_.request_.query_
: reinterpret_cast< ::greptime::v1::QueryRequest&>(::greptime::v1::_QueryRequest_default_instance_);
}
inline const ::greptime::v1::QueryRequest& GreptimeRequest::query() const {
// @@protoc_insertion_point(field_get:greptime.v1.GreptimeRequest.query)
return _internal_query();
}
inline ::greptime::v1::QueryRequest* GreptimeRequest::unsafe_arena_release_query() {
// @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.GreptimeRequest.query)
if (_internal_has_query()) {
clear_has_request();
::greptime::v1::QueryRequest* temp = _impl_.request_.query_;
_impl_.request_.query_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline void GreptimeRequest::unsafe_arena_set_allocated_query(::greptime::v1::QueryRequest* query) {
clear_request();
if (query) {
set_has_query();
_impl_.request_.query_ = query;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.GreptimeRequest.query)
}
inline ::greptime::v1::QueryRequest* GreptimeRequest::_internal_mutable_query() {
if (!_internal_has_query()) {
clear_request();
set_has_query();
_impl_.request_.query_ = CreateMaybeMessage< ::greptime::v1::QueryRequest >(GetArenaForAllocation());
}
return _impl_.request_.query_;
}
inline ::greptime::v1::QueryRequest* GreptimeRequest::mutable_query() {
::greptime::v1::QueryRequest* _msg = _internal_mutable_query();
// @@protoc_insertion_point(field_mutable:greptime.v1.GreptimeRequest.query)
return _msg;
}
// .greptime.v1.DdlRequest ddl = 4;
inline bool GreptimeRequest::_internal_has_ddl() const {
return request_case() == kDdl;
}
inline bool GreptimeRequest::has_ddl() const {
return _internal_has_ddl();
}
inline void GreptimeRequest::set_has_ddl() {
_impl_._oneof_case_[0] = kDdl;
}
inline ::greptime::v1::DdlRequest* GreptimeRequest::release_ddl() {
// @@protoc_insertion_point(field_release:greptime.v1.GreptimeRequest.ddl)
if (_internal_has_ddl()) {
clear_has_request();
::greptime::v1::DdlRequest* temp = _impl_.request_.ddl_;
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
_impl_.request_.ddl_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline const ::greptime::v1::DdlRequest& GreptimeRequest::_internal_ddl() const {
return _internal_has_ddl()
? *_impl_.request_.ddl_
: reinterpret_cast< ::greptime::v1::DdlRequest&>(::greptime::v1::_DdlRequest_default_instance_);
}
inline const ::greptime::v1::DdlRequest& GreptimeRequest::ddl() const {
// @@protoc_insertion_point(field_get:greptime.v1.GreptimeRequest.ddl)
return _internal_ddl();
}
inline ::greptime::v1::DdlRequest* GreptimeRequest::unsafe_arena_release_ddl() {
// @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.GreptimeRequest.ddl)
if (_internal_has_ddl()) {
clear_has_request();
::greptime::v1::DdlRequest* temp = _impl_.request_.ddl_;
_impl_.request_.ddl_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline void GreptimeRequest::unsafe_arena_set_allocated_ddl(::greptime::v1::DdlRequest* ddl) {
clear_request();
if (ddl) {
set_has_ddl();
_impl_.request_.ddl_ = ddl;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.GreptimeRequest.ddl)
}
inline ::greptime::v1::DdlRequest* GreptimeRequest::_internal_mutable_ddl() {
if (!_internal_has_ddl()) {
clear_request();
set_has_ddl();
_impl_.request_.ddl_ = CreateMaybeMessage< ::greptime::v1::DdlRequest >(GetArenaForAllocation());
}
return _impl_.request_.ddl_;
}
inline ::greptime::v1::DdlRequest* GreptimeRequest::mutable_ddl() {
::greptime::v1::DdlRequest* _msg = _internal_mutable_ddl();
// @@protoc_insertion_point(field_mutable:greptime.v1.GreptimeRequest.ddl)
return _msg;
}
// .greptime.v1.DeleteRequest delete = 5;
inline bool GreptimeRequest::_internal_has_delete_() const {
return request_case() == kDelete;
}
inline bool GreptimeRequest::has_delete_() const {
return _internal_has_delete_();
}
inline void GreptimeRequest::set_has_delete_() {
_impl_._oneof_case_[0] = kDelete;
}
inline void GreptimeRequest::clear_delete_() {
if (_internal_has_delete_()) {
if (GetArenaForAllocation() == nullptr) {
delete _impl_.request_.delete__;
}
clear_has_request();
}
}
inline ::greptime::v1::DeleteRequest* GreptimeRequest::release_delete_() {
// @@protoc_insertion_point(field_release:greptime.v1.GreptimeRequest.delete)
if (_internal_has_delete_()) {
clear_has_request();
::greptime::v1::DeleteRequest* temp = _impl_.request_.delete__;
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
_impl_.request_.delete__ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline const ::greptime::v1::DeleteRequest& GreptimeRequest::_internal_delete_() const {
return _internal_has_delete_()
? *_impl_.request_.delete__
: reinterpret_cast< ::greptime::v1::DeleteRequest&>(::greptime::v1::_DeleteRequest_default_instance_);
}
inline const ::greptime::v1::DeleteRequest& GreptimeRequest::delete_() const {
// @@protoc_insertion_point(field_get:greptime.v1.GreptimeRequest.delete)
return _internal_delete_();
}
inline ::greptime::v1::DeleteRequest* GreptimeRequest::unsafe_arena_release_delete_() {
// @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.GreptimeRequest.delete)
if (_internal_has_delete_()) {
clear_has_request();
::greptime::v1::DeleteRequest* temp = _impl_.request_.delete__;
_impl_.request_.delete__ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline void GreptimeRequest::unsafe_arena_set_allocated_delete_(::greptime::v1::DeleteRequest* delete_) {
clear_request();
if (delete_) {
set_has_delete_();
_impl_.request_.delete__ = delete_;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.GreptimeRequest.delete)
}
inline ::greptime::v1::DeleteRequest* GreptimeRequest::_internal_mutable_delete_() {
if (!_internal_has_delete_()) {
clear_request();
set_has_delete_();
_impl_.request_.delete__ = CreateMaybeMessage< ::greptime::v1::DeleteRequest >(GetArenaForAllocation());
}
return _impl_.request_.delete__;
}
inline ::greptime::v1::DeleteRequest* GreptimeRequest::mutable_delete_() {
::greptime::v1::DeleteRequest* _msg = _internal_mutable_delete_();
// @@protoc_insertion_point(field_mutable:greptime.v1.GreptimeRequest.delete)
return _msg;
}
// .greptime.v1.RowInsertRequests row_inserts = 6;
inline bool GreptimeRequest::_internal_has_row_inserts() const {
return request_case() == kRowInserts;
}
inline bool GreptimeRequest::has_row_inserts() const {
return _internal_has_row_inserts();
}
inline void GreptimeRequest::set_has_row_inserts() {
_impl_._oneof_case_[0] = kRowInserts;
}
inline void GreptimeRequest::clear_row_inserts() {
if (_internal_has_row_inserts()) {
if (GetArenaForAllocation() == nullptr) {
delete _impl_.request_.row_inserts_;
}
clear_has_request();
}
}
inline ::greptime::v1::RowInsertRequests* GreptimeRequest::release_row_inserts() {
// @@protoc_insertion_point(field_release:greptime.v1.GreptimeRequest.row_inserts)
if (_internal_has_row_inserts()) {
clear_has_request();
::greptime::v1::RowInsertRequests* temp = _impl_.request_.row_inserts_;
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
_impl_.request_.row_inserts_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline const ::greptime::v1::RowInsertRequests& GreptimeRequest::_internal_row_inserts() const {
return _internal_has_row_inserts()
? *_impl_.request_.row_inserts_
: reinterpret_cast< ::greptime::v1::RowInsertRequests&>(::greptime::v1::_RowInsertRequests_default_instance_);
}
inline const ::greptime::v1::RowInsertRequests& GreptimeRequest::row_inserts() const {
// @@protoc_insertion_point(field_get:greptime.v1.GreptimeRequest.row_inserts)
return _internal_row_inserts();
}
inline ::greptime::v1::RowInsertRequests* GreptimeRequest::unsafe_arena_release_row_inserts() {
// @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.GreptimeRequest.row_inserts)
if (_internal_has_row_inserts()) {
clear_has_request();
::greptime::v1::RowInsertRequests* temp = _impl_.request_.row_inserts_;
_impl_.request_.row_inserts_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline void GreptimeRequest::unsafe_arena_set_allocated_row_inserts(::greptime::v1::RowInsertRequests* row_inserts) {
clear_request();
if (row_inserts) {
set_has_row_inserts();
_impl_.request_.row_inserts_ = row_inserts;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.GreptimeRequest.row_inserts)
}
inline ::greptime::v1::RowInsertRequests* GreptimeRequest::_internal_mutable_row_inserts() {
if (!_internal_has_row_inserts()) {
clear_request();
set_has_row_inserts();
_impl_.request_.row_inserts_ = CreateMaybeMessage< ::greptime::v1::RowInsertRequests >(GetArenaForAllocation());
}
return _impl_.request_.row_inserts_;
}
inline ::greptime::v1::RowInsertRequests* GreptimeRequest::mutable_row_inserts() {
::greptime::v1::RowInsertRequests* _msg = _internal_mutable_row_inserts();
// @@protoc_insertion_point(field_mutable:greptime.v1.GreptimeRequest.row_inserts)
return _msg;
}
// .greptime.v1.RowDeleteRequest row_delete = 7;
inline bool GreptimeRequest::_internal_has_row_delete() const {
return request_case() == kRowDelete;
}
inline bool GreptimeRequest::has_row_delete() const {
return _internal_has_row_delete();
}
inline void GreptimeRequest::set_has_row_delete() {
_impl_._oneof_case_[0] = kRowDelete;
}
inline void GreptimeRequest::clear_row_delete() {
if (_internal_has_row_delete()) {
if (GetArenaForAllocation() == nullptr) {
delete _impl_.request_.row_delete_;
}
clear_has_request();
}
}
inline ::greptime::v1::RowDeleteRequest* GreptimeRequest::release_row_delete() {
// @@protoc_insertion_point(field_release:greptime.v1.GreptimeRequest.row_delete)
if (_internal_has_row_delete()) {
clear_has_request();
::greptime::v1::RowDeleteRequest* temp = _impl_.request_.row_delete_;
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
_impl_.request_.row_delete_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline const ::greptime::v1::RowDeleteRequest& GreptimeRequest::_internal_row_delete() const {
return _internal_has_row_delete()
? *_impl_.request_.row_delete_
: reinterpret_cast< ::greptime::v1::RowDeleteRequest&>(::greptime::v1::_RowDeleteRequest_default_instance_);
}
inline const ::greptime::v1::RowDeleteRequest& GreptimeRequest::row_delete() const {
// @@protoc_insertion_point(field_get:greptime.v1.GreptimeRequest.row_delete)
return _internal_row_delete();
}
inline ::greptime::v1::RowDeleteRequest* GreptimeRequest::unsafe_arena_release_row_delete() {
// @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.GreptimeRequest.row_delete)
if (_internal_has_row_delete()) {
clear_has_request();
::greptime::v1::RowDeleteRequest* temp = _impl_.request_.row_delete_;
_impl_.request_.row_delete_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline void GreptimeRequest::unsafe_arena_set_allocated_row_delete(::greptime::v1::RowDeleteRequest* row_delete) {
clear_request();
if (row_delete) {
set_has_row_delete();
_impl_.request_.row_delete_ = row_delete;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.GreptimeRequest.row_delete)
}
inline ::greptime::v1::RowDeleteRequest* GreptimeRequest::_internal_mutable_row_delete() {
if (!_internal_has_row_delete()) {
clear_request();
set_has_row_delete();
_impl_.request_.row_delete_ = CreateMaybeMessage< ::greptime::v1::RowDeleteRequest >(GetArenaForAllocation());
}
return _impl_.request_.row_delete_;
}
inline ::greptime::v1::RowDeleteRequest* GreptimeRequest::mutable_row_delete() {
::greptime::v1::RowDeleteRequest* _msg = _internal_mutable_row_delete();
// @@protoc_insertion_point(field_mutable:greptime.v1.GreptimeRequest.row_delete)
return _msg;
}
inline bool GreptimeRequest::has_request() const {
return request_case() != REQUEST_NOT_SET;
}
inline void GreptimeRequest::clear_has_request() {
_impl_._oneof_case_[0] = REQUEST_NOT_SET;
}
inline GreptimeRequest::RequestCase GreptimeRequest::request_case() const {
return GreptimeRequest::RequestCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------
// GreptimeResponse
// .greptime.v1.ResponseHeader header = 1;
inline bool GreptimeResponse::_internal_has_header() const {
return this != internal_default_instance() && _impl_.header_ != nullptr;
}
inline bool GreptimeResponse::has_header() const {
return _internal_has_header();
}
inline const ::greptime::v1::ResponseHeader& GreptimeResponse::_internal_header() const {
const ::greptime::v1::ResponseHeader* p = _impl_.header_;
return p != nullptr ? *p : reinterpret_cast<const ::greptime::v1::ResponseHeader&>(
::greptime::v1::_ResponseHeader_default_instance_);
}
inline const ::greptime::v1::ResponseHeader& GreptimeResponse::header() const {
// @@protoc_insertion_point(field_get:greptime.v1.GreptimeResponse.header)
return _internal_header();
}
inline void GreptimeResponse::unsafe_arena_set_allocated_header(
::greptime::v1::ResponseHeader* header) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.header_);
}
_impl_.header_ = header;
if (header) {
} else {
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.GreptimeResponse.header)
}
inline ::greptime::v1::ResponseHeader* GreptimeResponse::release_header() {
::greptime::v1::ResponseHeader* temp = _impl_.header_;
_impl_.header_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::greptime::v1::ResponseHeader* GreptimeResponse::unsafe_arena_release_header() {
// @@protoc_insertion_point(field_release:greptime.v1.GreptimeResponse.header)
::greptime::v1::ResponseHeader* temp = _impl_.header_;
_impl_.header_ = nullptr;
return temp;
}
inline ::greptime::v1::ResponseHeader* GreptimeResponse::_internal_mutable_header() {
if (_impl_.header_ == nullptr) {
auto* p = CreateMaybeMessage<::greptime::v1::ResponseHeader>(GetArenaForAllocation());
_impl_.header_ = p;
}
return _impl_.header_;
}
inline ::greptime::v1::ResponseHeader* GreptimeResponse::mutable_header() {
::greptime::v1::ResponseHeader* _msg = _internal_mutable_header();
// @@protoc_insertion_point(field_mutable:greptime.v1.GreptimeResponse.header)
return _msg;
}
inline void GreptimeResponse::set_allocated_header(::greptime::v1::ResponseHeader* header) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.header_);
}
if (header) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(header));
if (message_arena != submessage_arena) {
header = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, header, submessage_arena);
}
} else {
}
_impl_.header_ = header;
// @@protoc_insertion_point(field_set_allocated:greptime.v1.GreptimeResponse.header)
}
// .greptime.v1.AffectedRows affected_rows = 2;
inline bool GreptimeResponse::_internal_has_affected_rows() const {
return response_case() == kAffectedRows;
}
inline bool GreptimeResponse::has_affected_rows() const {
return _internal_has_affected_rows();
}
inline void GreptimeResponse::set_has_affected_rows() {
_impl_._oneof_case_[0] = kAffectedRows;
}
inline ::greptime::v1::AffectedRows* GreptimeResponse::release_affected_rows() {
// @@protoc_insertion_point(field_release:greptime.v1.GreptimeResponse.affected_rows)
if (_internal_has_affected_rows()) {
clear_has_response();
::greptime::v1::AffectedRows* temp = _impl_.response_.affected_rows_;
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
_impl_.response_.affected_rows_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline const ::greptime::v1::AffectedRows& GreptimeResponse::_internal_affected_rows() const {
return _internal_has_affected_rows()
? *_impl_.response_.affected_rows_
: reinterpret_cast< ::greptime::v1::AffectedRows&>(::greptime::v1::_AffectedRows_default_instance_);
}
inline const ::greptime::v1::AffectedRows& GreptimeResponse::affected_rows() const {
// @@protoc_insertion_point(field_get:greptime.v1.GreptimeResponse.affected_rows)
return _internal_affected_rows();
}
inline ::greptime::v1::AffectedRows* GreptimeResponse::unsafe_arena_release_affected_rows() {
// @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.GreptimeResponse.affected_rows)
if (_internal_has_affected_rows()) {
clear_has_response();
::greptime::v1::AffectedRows* temp = _impl_.response_.affected_rows_;
_impl_.response_.affected_rows_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline void GreptimeResponse::unsafe_arena_set_allocated_affected_rows(::greptime::v1::AffectedRows* affected_rows) {
clear_response();
if (affected_rows) {
set_has_affected_rows();
_impl_.response_.affected_rows_ = affected_rows;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.GreptimeResponse.affected_rows)
}
inline ::greptime::v1::AffectedRows* GreptimeResponse::_internal_mutable_affected_rows() {
if (!_internal_has_affected_rows()) {
clear_response();
set_has_affected_rows();
_impl_.response_.affected_rows_ = CreateMaybeMessage< ::greptime::v1::AffectedRows >(GetArenaForAllocation());
}
return _impl_.response_.affected_rows_;
}
inline ::greptime::v1::AffectedRows* GreptimeResponse::mutable_affected_rows() {
::greptime::v1::AffectedRows* _msg = _internal_mutable_affected_rows();
// @@protoc_insertion_point(field_mutable:greptime.v1.GreptimeResponse.affected_rows)
return _msg;
}
inline bool GreptimeResponse::has_response() const {
return response_case() != RESPONSE_NOT_SET;
}
inline void GreptimeResponse::clear_has_response() {
_impl_._oneof_case_[0] = RESPONSE_NOT_SET;
}
inline GreptimeResponse::ResponseCase GreptimeResponse::response_case() const {
return GreptimeResponse::ResponseCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------
// QueryRequest
// string sql = 1;
inline bool QueryRequest::_internal_has_sql() const {
return query_case() == kSql;
}
inline bool QueryRequest::has_sql() const {
return _internal_has_sql();
}
inline void QueryRequest::set_has_sql() {
_impl_._oneof_case_[0] = kSql;
}
inline void QueryRequest::clear_sql() {
if (_internal_has_sql()) {
_impl_.query_.sql_.Destroy();
clear_has_query();
}
}
inline const std::string& QueryRequest::sql() const {
// @@protoc_insertion_point(field_get:greptime.v1.QueryRequest.sql)
return _internal_sql();
}
template <typename ArgT0, typename... ArgT>
inline void QueryRequest::set_sql(ArgT0&& arg0, ArgT... args) {
if (!_internal_has_sql()) {
clear_query();
set_has_sql();
_impl_.query_.sql_.InitDefault();
}
_impl_.query_.sql_.Set( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:greptime.v1.QueryRequest.sql)
}
inline std::string* QueryRequest::mutable_sql() {
std::string* _s = _internal_mutable_sql();
// @@protoc_insertion_point(field_mutable:greptime.v1.QueryRequest.sql)
return _s;
}
inline const std::string& QueryRequest::_internal_sql() const {
if (_internal_has_sql()) {
return _impl_.query_.sql_.Get();
}
return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
}
inline void QueryRequest::_internal_set_sql(const std::string& value) {
if (!_internal_has_sql()) {
clear_query();
set_has_sql();
_impl_.query_.sql_.InitDefault();
}
_impl_.query_.sql_.Set(value, GetArenaForAllocation());
}
inline std::string* QueryRequest::_internal_mutable_sql() {
if (!_internal_has_sql()) {
clear_query();
set_has_sql();
_impl_.query_.sql_.InitDefault();
}
return _impl_.query_.sql_.Mutable( GetArenaForAllocation());
}
inline std::string* QueryRequest::release_sql() {
// @@protoc_insertion_point(field_release:greptime.v1.QueryRequest.sql)
if (_internal_has_sql()) {
clear_has_query();
return _impl_.query_.sql_.Release();
} else {
return nullptr;
}
}
inline void QueryRequest::set_allocated_sql(std::string* sql) {
if (has_query()) {
clear_query();
}
if (sql != nullptr) {
set_has_sql();
_impl_.query_.sql_.InitAllocated(sql, GetArenaForAllocation());
}
// @@protoc_insertion_point(field_set_allocated:greptime.v1.QueryRequest.sql)
}
// bytes logical_plan = 2;
inline bool QueryRequest::_internal_has_logical_plan() const {
return query_case() == kLogicalPlan;
}
inline bool QueryRequest::has_logical_plan() const {
return _internal_has_logical_plan();
}
inline void QueryRequest::set_has_logical_plan() {
_impl_._oneof_case_[0] = kLogicalPlan;
}
inline void QueryRequest::clear_logical_plan() {
if (_internal_has_logical_plan()) {
_impl_.query_.logical_plan_.Destroy();
clear_has_query();
}
}
inline const std::string& QueryRequest::logical_plan() const {
// @@protoc_insertion_point(field_get:greptime.v1.QueryRequest.logical_plan)
return _internal_logical_plan();
}
template <typename ArgT0, typename... ArgT>
inline void QueryRequest::set_logical_plan(ArgT0&& arg0, ArgT... args) {
if (!_internal_has_logical_plan()) {
clear_query();
set_has_logical_plan();
_impl_.query_.logical_plan_.InitDefault();
}
_impl_.query_.logical_plan_.SetBytes( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:greptime.v1.QueryRequest.logical_plan)
}
inline std::string* QueryRequest::mutable_logical_plan() {
std::string* _s = _internal_mutable_logical_plan();
// @@protoc_insertion_point(field_mutable:greptime.v1.QueryRequest.logical_plan)
return _s;
}
inline const std::string& QueryRequest::_internal_logical_plan() const {
if (_internal_has_logical_plan()) {
return _impl_.query_.logical_plan_.Get();
}
return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
}
inline void QueryRequest::_internal_set_logical_plan(const std::string& value) {
if (!_internal_has_logical_plan()) {
clear_query();
set_has_logical_plan();
_impl_.query_.logical_plan_.InitDefault();
}
_impl_.query_.logical_plan_.Set(value, GetArenaForAllocation());
}
inline std::string* QueryRequest::_internal_mutable_logical_plan() {
if (!_internal_has_logical_plan()) {
clear_query();
set_has_logical_plan();
_impl_.query_.logical_plan_.InitDefault();
}
return _impl_.query_.logical_plan_.Mutable( GetArenaForAllocation());
}
inline std::string* QueryRequest::release_logical_plan() {
// @@protoc_insertion_point(field_release:greptime.v1.QueryRequest.logical_plan)
if (_internal_has_logical_plan()) {
clear_has_query();
return _impl_.query_.logical_plan_.Release();
} else {
return nullptr;
}
}
inline void QueryRequest::set_allocated_logical_plan(std::string* logical_plan) {
if (has_query()) {
clear_query();
}
if (logical_plan != nullptr) {
set_has_logical_plan();
_impl_.query_.logical_plan_.InitAllocated(logical_plan, GetArenaForAllocation());
}
// @@protoc_insertion_point(field_set_allocated:greptime.v1.QueryRequest.logical_plan)
}
// .greptime.v1.PromRangeQuery prom_range_query = 3;
inline bool QueryRequest::_internal_has_prom_range_query() const {
return query_case() == kPromRangeQuery;
}
inline bool QueryRequest::has_prom_range_query() const {
return _internal_has_prom_range_query();
}
inline void QueryRequest::set_has_prom_range_query() {
_impl_._oneof_case_[0] = kPromRangeQuery;
}
inline ::greptime::v1::PromRangeQuery* QueryRequest::release_prom_range_query() {
// @@protoc_insertion_point(field_release:greptime.v1.QueryRequest.prom_range_query)
if (_internal_has_prom_range_query()) {
clear_has_query();
::greptime::v1::PromRangeQuery* temp = _impl_.query_.prom_range_query_;
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
_impl_.query_.prom_range_query_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline const ::greptime::v1::PromRangeQuery& QueryRequest::_internal_prom_range_query() const {
return _internal_has_prom_range_query()
? *_impl_.query_.prom_range_query_
: reinterpret_cast< ::greptime::v1::PromRangeQuery&>(::greptime::v1::_PromRangeQuery_default_instance_);
}
inline const ::greptime::v1::PromRangeQuery& QueryRequest::prom_range_query() const {
// @@protoc_insertion_point(field_get:greptime.v1.QueryRequest.prom_range_query)
return _internal_prom_range_query();
}
inline ::greptime::v1::PromRangeQuery* QueryRequest::unsafe_arena_release_prom_range_query() {
// @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.QueryRequest.prom_range_query)
if (_internal_has_prom_range_query()) {
clear_has_query();
::greptime::v1::PromRangeQuery* temp = _impl_.query_.prom_range_query_;
_impl_.query_.prom_range_query_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline void QueryRequest::unsafe_arena_set_allocated_prom_range_query(::greptime::v1::PromRangeQuery* prom_range_query) {
clear_query();
if (prom_range_query) {
set_has_prom_range_query();
_impl_.query_.prom_range_query_ = prom_range_query;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.QueryRequest.prom_range_query)
}
inline ::greptime::v1::PromRangeQuery* QueryRequest::_internal_mutable_prom_range_query() {
if (!_internal_has_prom_range_query()) {
clear_query();
set_has_prom_range_query();
_impl_.query_.prom_range_query_ = CreateMaybeMessage< ::greptime::v1::PromRangeQuery >(GetArenaForAllocation());
}
return _impl_.query_.prom_range_query_;
}
inline ::greptime::v1::PromRangeQuery* QueryRequest::mutable_prom_range_query() {
::greptime::v1::PromRangeQuery* _msg = _internal_mutable_prom_range_query();
// @@protoc_insertion_point(field_mutable:greptime.v1.QueryRequest.prom_range_query)
return _msg;
}
inline bool QueryRequest::has_query() const {
return query_case() != QUERY_NOT_SET;
}
inline void QueryRequest::clear_has_query() {
_impl_._oneof_case_[0] = QUERY_NOT_SET;
}
inline QueryRequest::QueryCase QueryRequest::query_case() const {
return QueryRequest::QueryCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------
// InsertRequests
// repeated .greptime.v1.InsertRequest inserts = 1;
inline int InsertRequests::_internal_inserts_size() const {
return _impl_.inserts_.size();
}
inline int InsertRequests::inserts_size() const {
return _internal_inserts_size();
}
inline void InsertRequests::clear_inserts() {
_impl_.inserts_.Clear();
}
inline ::greptime::v1::InsertRequest* InsertRequests::mutable_inserts(int index) {
// @@protoc_insertion_point(field_mutable:greptime.v1.InsertRequests.inserts)
return _impl_.inserts_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::InsertRequest >*
InsertRequests::mutable_inserts() {
// @@protoc_insertion_point(field_mutable_list:greptime.v1.InsertRequests.inserts)
return &_impl_.inserts_;
}
inline const ::greptime::v1::InsertRequest& InsertRequests::_internal_inserts(int index) const {
return _impl_.inserts_.Get(index);
}
inline const ::greptime::v1::InsertRequest& InsertRequests::inserts(int index) const {
// @@protoc_insertion_point(field_get:greptime.v1.InsertRequests.inserts)
return _internal_inserts(index);
}
inline ::greptime::v1::InsertRequest* InsertRequests::_internal_add_inserts() {
return _impl_.inserts_.Add();
}
inline ::greptime::v1::InsertRequest* InsertRequests::add_inserts() {
::greptime::v1::InsertRequest* _add = _internal_add_inserts();
// @@protoc_insertion_point(field_add:greptime.v1.InsertRequests.inserts)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::InsertRequest >&
InsertRequests::inserts() const {
// @@protoc_insertion_point(field_list:greptime.v1.InsertRequests.inserts)
return _impl_.inserts_;
}
// -------------------------------------------------------------------
// InsertRequest
// string table_name = 1;
inline void InsertRequest::clear_table_name() {
_impl_.table_name_.ClearToEmpty();
}
inline const std::string& InsertRequest::table_name() const {
// @@protoc_insertion_point(field_get:greptime.v1.InsertRequest.table_name)
return _internal_table_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void InsertRequest::set_table_name(ArgT0&& arg0, ArgT... args) {
_impl_.table_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:greptime.v1.InsertRequest.table_name)
}
inline std::string* InsertRequest::mutable_table_name() {
std::string* _s = _internal_mutable_table_name();
// @@protoc_insertion_point(field_mutable:greptime.v1.InsertRequest.table_name)
return _s;
}
inline const std::string& InsertRequest::_internal_table_name() const {
return _impl_.table_name_.Get();
}
inline void InsertRequest::_internal_set_table_name(const std::string& value) {
_impl_.table_name_.Set(value, GetArenaForAllocation());
}
inline std::string* InsertRequest::_internal_mutable_table_name() {
return _impl_.table_name_.Mutable(GetArenaForAllocation());
}
inline std::string* InsertRequest::release_table_name() {
// @@protoc_insertion_point(field_release:greptime.v1.InsertRequest.table_name)
return _impl_.table_name_.Release();
}
inline void InsertRequest::set_allocated_table_name(std::string* table_name) {
if (table_name != nullptr) {
} else {
}
_impl_.table_name_.SetAllocated(table_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (_impl_.table_name_.IsDefault()) {
_impl_.table_name_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:greptime.v1.InsertRequest.table_name)
}
// repeated .greptime.v1.Column columns = 3;
inline int InsertRequest::_internal_columns_size() const {
return _impl_.columns_.size();
}
inline int InsertRequest::columns_size() const {
return _internal_columns_size();
}
inline ::greptime::v1::Column* InsertRequest::mutable_columns(int index) {
// @@protoc_insertion_point(field_mutable:greptime.v1.InsertRequest.columns)
return _impl_.columns_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Column >*
InsertRequest::mutable_columns() {
// @@protoc_insertion_point(field_mutable_list:greptime.v1.InsertRequest.columns)
return &_impl_.columns_;
}
inline const ::greptime::v1::Column& InsertRequest::_internal_columns(int index) const {
return _impl_.columns_.Get(index);
}
inline const ::greptime::v1::Column& InsertRequest::columns(int index) const {
// @@protoc_insertion_point(field_get:greptime.v1.InsertRequest.columns)
return _internal_columns(index);
}
inline ::greptime::v1::Column* InsertRequest::_internal_add_columns() {
return _impl_.columns_.Add();
}
inline ::greptime::v1::Column* InsertRequest::add_columns() {
::greptime::v1::Column* _add = _internal_add_columns();
// @@protoc_insertion_point(field_add:greptime.v1.InsertRequest.columns)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Column >&
InsertRequest::columns() const {
// @@protoc_insertion_point(field_list:greptime.v1.InsertRequest.columns)
return _impl_.columns_;
}
// uint32 row_count = 4;
inline void InsertRequest::clear_row_count() {
_impl_.row_count_ = 0u;
}
inline uint32_t InsertRequest::_internal_row_count() const {
return _impl_.row_count_;
}
inline uint32_t InsertRequest::row_count() const {
// @@protoc_insertion_point(field_get:greptime.v1.InsertRequest.row_count)
return _internal_row_count();
}
inline void InsertRequest::_internal_set_row_count(uint32_t value) {
_impl_.row_count_ = value;
}
inline void InsertRequest::set_row_count(uint32_t value) {
_internal_set_row_count(value);
// @@protoc_insertion_point(field_set:greptime.v1.InsertRequest.row_count)
}
// uint32 region_number = 5;
inline void InsertRequest::clear_region_number() {
_impl_.region_number_ = 0u;
}
inline uint32_t InsertRequest::_internal_region_number() const {
return _impl_.region_number_;
}
inline uint32_t InsertRequest::region_number() const {
// @@protoc_insertion_point(field_get:greptime.v1.InsertRequest.region_number)
return _internal_region_number();
}
inline void InsertRequest::_internal_set_region_number(uint32_t value) {
_impl_.region_number_ = value;
}
inline void InsertRequest::set_region_number(uint32_t value) {
_internal_set_region_number(value);
// @@protoc_insertion_point(field_set:greptime.v1.InsertRequest.region_number)
}
// -------------------------------------------------------------------
// DeleteRequest
// string table_name = 1;
inline void DeleteRequest::clear_table_name() {
_impl_.table_name_.ClearToEmpty();
}
inline const std::string& DeleteRequest::table_name() const {
// @@protoc_insertion_point(field_get:greptime.v1.DeleteRequest.table_name)
return _internal_table_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DeleteRequest::set_table_name(ArgT0&& arg0, ArgT... args) {
_impl_.table_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:greptime.v1.DeleteRequest.table_name)
}
inline std::string* DeleteRequest::mutable_table_name() {
std::string* _s = _internal_mutable_table_name();
// @@protoc_insertion_point(field_mutable:greptime.v1.DeleteRequest.table_name)
return _s;
}
inline const std::string& DeleteRequest::_internal_table_name() const {
return _impl_.table_name_.Get();
}
inline void DeleteRequest::_internal_set_table_name(const std::string& value) {
_impl_.table_name_.Set(value, GetArenaForAllocation());
}
inline std::string* DeleteRequest::_internal_mutable_table_name() {
return _impl_.table_name_.Mutable(GetArenaForAllocation());
}
inline std::string* DeleteRequest::release_table_name() {
// @@protoc_insertion_point(field_release:greptime.v1.DeleteRequest.table_name)
return _impl_.table_name_.Release();
}
inline void DeleteRequest::set_allocated_table_name(std::string* table_name) {
if (table_name != nullptr) {
} else {
}
_impl_.table_name_.SetAllocated(table_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (_impl_.table_name_.IsDefault()) {
_impl_.table_name_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:greptime.v1.DeleteRequest.table_name)
}
// uint32 region_number = 2;
inline void DeleteRequest::clear_region_number() {
_impl_.region_number_ = 0u;
}
inline uint32_t DeleteRequest::_internal_region_number() const {
return _impl_.region_number_;
}
inline uint32_t DeleteRequest::region_number() const {
// @@protoc_insertion_point(field_get:greptime.v1.DeleteRequest.region_number)
return _internal_region_number();
}
inline void DeleteRequest::_internal_set_region_number(uint32_t value) {
_impl_.region_number_ = value;
}
inline void DeleteRequest::set_region_number(uint32_t value) {
_internal_set_region_number(value);
// @@protoc_insertion_point(field_set:greptime.v1.DeleteRequest.region_number)
}
// repeated .greptime.v1.Column key_columns = 3;
inline int DeleteRequest::_internal_key_columns_size() const {
return _impl_.key_columns_.size();
}
inline int DeleteRequest::key_columns_size() const {
return _internal_key_columns_size();
}
inline ::greptime::v1::Column* DeleteRequest::mutable_key_columns(int index) {
// @@protoc_insertion_point(field_mutable:greptime.v1.DeleteRequest.key_columns)
return _impl_.key_columns_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Column >*
DeleteRequest::mutable_key_columns() {
// @@protoc_insertion_point(field_mutable_list:greptime.v1.DeleteRequest.key_columns)
return &_impl_.key_columns_;
}
inline const ::greptime::v1::Column& DeleteRequest::_internal_key_columns(int index) const {
return _impl_.key_columns_.Get(index);
}
inline const ::greptime::v1::Column& DeleteRequest::key_columns(int index) const {
// @@protoc_insertion_point(field_get:greptime.v1.DeleteRequest.key_columns)
return _internal_key_columns(index);
}
inline ::greptime::v1::Column* DeleteRequest::_internal_add_key_columns() {
return _impl_.key_columns_.Add();
}
inline ::greptime::v1::Column* DeleteRequest::add_key_columns() {
::greptime::v1::Column* _add = _internal_add_key_columns();
// @@protoc_insertion_point(field_add:greptime.v1.DeleteRequest.key_columns)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Column >&
DeleteRequest::key_columns() const {
// @@protoc_insertion_point(field_list:greptime.v1.DeleteRequest.key_columns)
return _impl_.key_columns_;
}
// uint32 row_count = 4;
inline void DeleteRequest::clear_row_count() {
_impl_.row_count_ = 0u;
}
inline uint32_t DeleteRequest::_internal_row_count() const {
return _impl_.row_count_;
}
inline uint32_t DeleteRequest::row_count() const {
// @@protoc_insertion_point(field_get:greptime.v1.DeleteRequest.row_count)
return _internal_row_count();
}
inline void DeleteRequest::_internal_set_row_count(uint32_t value) {
_impl_.row_count_ = value;
}
inline void DeleteRequest::set_row_count(uint32_t value) {
_internal_set_row_count(value);
// @@protoc_insertion_point(field_set:greptime.v1.DeleteRequest.row_count)
}
// -------------------------------------------------------------------
// RowInsertRequests
// repeated .greptime.v1.RowInsertRequest inserts = 1;
inline int RowInsertRequests::_internal_inserts_size() const {
return _impl_.inserts_.size();
}
inline int RowInsertRequests::inserts_size() const {
return _internal_inserts_size();
}
inline void RowInsertRequests::clear_inserts() {
_impl_.inserts_.Clear();
}
inline ::greptime::v1::RowInsertRequest* RowInsertRequests::mutable_inserts(int index) {
// @@protoc_insertion_point(field_mutable:greptime.v1.RowInsertRequests.inserts)
return _impl_.inserts_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::RowInsertRequest >*
RowInsertRequests::mutable_inserts() {
// @@protoc_insertion_point(field_mutable_list:greptime.v1.RowInsertRequests.inserts)
return &_impl_.inserts_;
}
inline const ::greptime::v1::RowInsertRequest& RowInsertRequests::_internal_inserts(int index) const {
return _impl_.inserts_.Get(index);
}
inline const ::greptime::v1::RowInsertRequest& RowInsertRequests::inserts(int index) const {
// @@protoc_insertion_point(field_get:greptime.v1.RowInsertRequests.inserts)
return _internal_inserts(index);
}
inline ::greptime::v1::RowInsertRequest* RowInsertRequests::_internal_add_inserts() {
return _impl_.inserts_.Add();
}
inline ::greptime::v1::RowInsertRequest* RowInsertRequests::add_inserts() {
::greptime::v1::RowInsertRequest* _add = _internal_add_inserts();
// @@protoc_insertion_point(field_add:greptime.v1.RowInsertRequests.inserts)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::RowInsertRequest >&
RowInsertRequests::inserts() const {
// @@protoc_insertion_point(field_list:greptime.v1.RowInsertRequests.inserts)
return _impl_.inserts_;
}
// -------------------------------------------------------------------
// RowInsertRequest
// string table_name = 1;
inline void RowInsertRequest::clear_table_name() {
_impl_.table_name_.ClearToEmpty();
}
inline const std::string& RowInsertRequest::table_name() const {
// @@protoc_insertion_point(field_get:greptime.v1.RowInsertRequest.table_name)
return _internal_table_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RowInsertRequest::set_table_name(ArgT0&& arg0, ArgT... args) {
_impl_.table_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:greptime.v1.RowInsertRequest.table_name)
}
inline std::string* RowInsertRequest::mutable_table_name() {
std::string* _s = _internal_mutable_table_name();
// @@protoc_insertion_point(field_mutable:greptime.v1.RowInsertRequest.table_name)
return _s;
}
inline const std::string& RowInsertRequest::_internal_table_name() const {
return _impl_.table_name_.Get();
}
inline void RowInsertRequest::_internal_set_table_name(const std::string& value) {
_impl_.table_name_.Set(value, GetArenaForAllocation());
}
inline std::string* RowInsertRequest::_internal_mutable_table_name() {
return _impl_.table_name_.Mutable(GetArenaForAllocation());
}
inline std::string* RowInsertRequest::release_table_name() {
// @@protoc_insertion_point(field_release:greptime.v1.RowInsertRequest.table_name)
return _impl_.table_name_.Release();
}
inline void RowInsertRequest::set_allocated_table_name(std::string* table_name) {
if (table_name != nullptr) {
} else {
}
_impl_.table_name_.SetAllocated(table_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (_impl_.table_name_.IsDefault()) {
_impl_.table_name_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:greptime.v1.RowInsertRequest.table_name)
}
// .greptime.v1.Rows rows = 2;
inline bool RowInsertRequest::_internal_has_rows() const {
return this != internal_default_instance() && _impl_.rows_ != nullptr;
}
inline bool RowInsertRequest::has_rows() const {
return _internal_has_rows();
}
inline const ::greptime::v1::Rows& RowInsertRequest::_internal_rows() const {
const ::greptime::v1::Rows* p = _impl_.rows_;
return p != nullptr ? *p : reinterpret_cast<const ::greptime::v1::Rows&>(
::greptime::v1::_Rows_default_instance_);
}
inline const ::greptime::v1::Rows& RowInsertRequest::rows() const {
// @@protoc_insertion_point(field_get:greptime.v1.RowInsertRequest.rows)
return _internal_rows();
}
inline void RowInsertRequest::unsafe_arena_set_allocated_rows(
::greptime::v1::Rows* rows) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.rows_);
}
_impl_.rows_ = rows;
if (rows) {
} else {
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.RowInsertRequest.rows)
}
inline ::greptime::v1::Rows* RowInsertRequest::release_rows() {
::greptime::v1::Rows* temp = _impl_.rows_;
_impl_.rows_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::greptime::v1::Rows* RowInsertRequest::unsafe_arena_release_rows() {
// @@protoc_insertion_point(field_release:greptime.v1.RowInsertRequest.rows)
::greptime::v1::Rows* temp = _impl_.rows_;
_impl_.rows_ = nullptr;
return temp;
}
inline ::greptime::v1::Rows* RowInsertRequest::_internal_mutable_rows() {
if (_impl_.rows_ == nullptr) {
auto* p = CreateMaybeMessage<::greptime::v1::Rows>(GetArenaForAllocation());
_impl_.rows_ = p;
}
return _impl_.rows_;
}
inline ::greptime::v1::Rows* RowInsertRequest::mutable_rows() {
::greptime::v1::Rows* _msg = _internal_mutable_rows();
// @@protoc_insertion_point(field_mutable:greptime.v1.RowInsertRequest.rows)
return _msg;
}
inline void RowInsertRequest::set_allocated_rows(::greptime::v1::Rows* rows) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.rows_);
}
if (rows) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(rows));
if (message_arena != submessage_arena) {
rows = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, rows, submessage_arena);
}
} else {
}
_impl_.rows_ = rows;
// @@protoc_insertion_point(field_set_allocated:greptime.v1.RowInsertRequest.rows)
}
// uint32 region_number = 3;
inline void RowInsertRequest::clear_region_number() {
_impl_.region_number_ = 0u;
}
inline uint32_t RowInsertRequest::_internal_region_number() const {
return _impl_.region_number_;
}
inline uint32_t RowInsertRequest::region_number() const {
// @@protoc_insertion_point(field_get:greptime.v1.RowInsertRequest.region_number)
return _internal_region_number();
}
inline void RowInsertRequest::_internal_set_region_number(uint32_t value) {
_impl_.region_number_ = value;
}
inline void RowInsertRequest::set_region_number(uint32_t value) {
_internal_set_region_number(value);
// @@protoc_insertion_point(field_set:greptime.v1.RowInsertRequest.region_number)
}
// -------------------------------------------------------------------
// RowDeleteRequest
// string table_name = 1;
inline void RowDeleteRequest::clear_table_name() {
_impl_.table_name_.ClearToEmpty();
}
inline const std::string& RowDeleteRequest::table_name() const {
// @@protoc_insertion_point(field_get:greptime.v1.RowDeleteRequest.table_name)
return _internal_table_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RowDeleteRequest::set_table_name(ArgT0&& arg0, ArgT... args) {
_impl_.table_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:greptime.v1.RowDeleteRequest.table_name)
}
inline std::string* RowDeleteRequest::mutable_table_name() {
std::string* _s = _internal_mutable_table_name();
// @@protoc_insertion_point(field_mutable:greptime.v1.RowDeleteRequest.table_name)
return _s;
}
inline const std::string& RowDeleteRequest::_internal_table_name() const {
return _impl_.table_name_.Get();
}
inline void RowDeleteRequest::_internal_set_table_name(const std::string& value) {
_impl_.table_name_.Set(value, GetArenaForAllocation());
}
inline std::string* RowDeleteRequest::_internal_mutable_table_name() {
return _impl_.table_name_.Mutable(GetArenaForAllocation());
}
inline std::string* RowDeleteRequest::release_table_name() {
// @@protoc_insertion_point(field_release:greptime.v1.RowDeleteRequest.table_name)
return _impl_.table_name_.Release();
}
inline void RowDeleteRequest::set_allocated_table_name(std::string* table_name) {
if (table_name != nullptr) {
} else {
}
_impl_.table_name_.SetAllocated(table_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (_impl_.table_name_.IsDefault()) {
_impl_.table_name_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:greptime.v1.RowDeleteRequest.table_name)
}
// .greptime.v1.Rows rows = 2;
inline bool RowDeleteRequest::_internal_has_rows() const {
return this != internal_default_instance() && _impl_.rows_ != nullptr;
}
inline bool RowDeleteRequest::has_rows() const {
return _internal_has_rows();
}
inline const ::greptime::v1::Rows& RowDeleteRequest::_internal_rows() const {
const ::greptime::v1::Rows* p = _impl_.rows_;
return p != nullptr ? *p : reinterpret_cast<const ::greptime::v1::Rows&>(
::greptime::v1::_Rows_default_instance_);
}
inline const ::greptime::v1::Rows& RowDeleteRequest::rows() const {
// @@protoc_insertion_point(field_get:greptime.v1.RowDeleteRequest.rows)
return _internal_rows();
}
inline void RowDeleteRequest::unsafe_arena_set_allocated_rows(
::greptime::v1::Rows* rows) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.rows_);
}
_impl_.rows_ = rows;
if (rows) {
} else {
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.RowDeleteRequest.rows)
}
inline ::greptime::v1::Rows* RowDeleteRequest::release_rows() {
::greptime::v1::Rows* temp = _impl_.rows_;
_impl_.rows_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::greptime::v1::Rows* RowDeleteRequest::unsafe_arena_release_rows() {
// @@protoc_insertion_point(field_release:greptime.v1.RowDeleteRequest.rows)
::greptime::v1::Rows* temp = _impl_.rows_;
_impl_.rows_ = nullptr;
return temp;
}
inline ::greptime::v1::Rows* RowDeleteRequest::_internal_mutable_rows() {
if (_impl_.rows_ == nullptr) {
auto* p = CreateMaybeMessage<::greptime::v1::Rows>(GetArenaForAllocation());
_impl_.rows_ = p;
}
return _impl_.rows_;
}
inline ::greptime::v1::Rows* RowDeleteRequest::mutable_rows() {
::greptime::v1::Rows* _msg = _internal_mutable_rows();
// @@protoc_insertion_point(field_mutable:greptime.v1.RowDeleteRequest.rows)
return _msg;
}
inline void RowDeleteRequest::set_allocated_rows(::greptime::v1::Rows* rows) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.rows_);
}
if (rows) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(rows));
if (message_arena != submessage_arena) {
rows = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, rows, submessage_arena);
}
} else {
}
_impl_.rows_ = rows;
// @@protoc_insertion_point(field_set_allocated:greptime.v1.RowDeleteRequest.rows)
}
// uint32 region_number = 3;
inline void RowDeleteRequest::clear_region_number() {
_impl_.region_number_ = 0u;
}
inline uint32_t RowDeleteRequest::_internal_region_number() const {
return _impl_.region_number_;
}
inline uint32_t RowDeleteRequest::region_number() const {
// @@protoc_insertion_point(field_get:greptime.v1.RowDeleteRequest.region_number)
return _internal_region_number();
}
inline void RowDeleteRequest::_internal_set_region_number(uint32_t value) {
_impl_.region_number_ = value;
}
inline void RowDeleteRequest::set_region_number(uint32_t value) {
_internal_set_region_number(value);
// @@protoc_insertion_point(field_set:greptime.v1.RowDeleteRequest.region_number)
}
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif // __GNUC__
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// @@protoc_insertion_point(namespace_scope)
} // namespace v1
} // namespace greptime
// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>
#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_greptime_2fv1_2fdatabase_2eproto
Reference in New Issue View Git Blame Copy Permalink