JeremyHi
2959 lines
100 KiB
C++
2959 lines
100 KiB
C++
// Generated by the protocol buffer compiler. DO NOT EDIT!
|
|
// source: greptime/v1/row.proto
|
|
|
|
#ifndef GOOGLE_PROTOBUF_INCLUDED_greptime_2fv1_2frow_2eproto
|
|
#define GOOGLE_PROTOBUF_INCLUDED_greptime_2fv1_2frow_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/common.pb.h"
|
|
// @@protoc_insertion_point(includes)
|
|
#include <google/protobuf/port_def.inc>
|
|
#define PROTOBUF_INTERNAL_EXPORT_greptime_2fv1_2frow_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_2frow_2eproto {
|
|
static const uint32_t offsets[];
|
|
};
|
|
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_greptime_2fv1_2frow_2eproto;
|
|
namespace greptime {
|
|
namespace v1 {
|
|
class ColumnSchema;
|
|
struct ColumnSchemaDefaultTypeInternal;
|
|
extern ColumnSchemaDefaultTypeInternal _ColumnSchema_default_instance_;
|
|
class Row;
|
|
struct RowDefaultTypeInternal;
|
|
extern RowDefaultTypeInternal _Row_default_instance_;
|
|
class Rows;
|
|
struct RowsDefaultTypeInternal;
|
|
extern RowsDefaultTypeInternal _Rows_default_instance_;
|
|
class Value;
|
|
struct ValueDefaultTypeInternal;
|
|
extern ValueDefaultTypeInternal _Value_default_instance_;
|
|
} // namespace v1
|
|
} // namespace greptime
|
|
PROTOBUF_NAMESPACE_OPEN
|
|
template<> ::greptime::v1::ColumnSchema* Arena::CreateMaybeMessage<::greptime::v1::ColumnSchema>(Arena*);
|
|
template<> ::greptime::v1::Row* Arena::CreateMaybeMessage<::greptime::v1::Row>(Arena*);
|
|
template<> ::greptime::v1::Rows* Arena::CreateMaybeMessage<::greptime::v1::Rows>(Arena*);
|
|
template<> ::greptime::v1::Value* Arena::CreateMaybeMessage<::greptime::v1::Value>(Arena*);
|
|
PROTOBUF_NAMESPACE_CLOSE
|
|
namespace greptime {
|
|
namespace v1 {
|
|
|
|
// ===================================================================
|
|
|
|
class Rows final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:greptime.v1.Rows) */ {
|
|
public:
|
|
inline Rows() : Rows(nullptr) {}
|
|
~Rows() override;
|
|
explicit PROTOBUF_CONSTEXPR Rows(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
Rows(const Rows& from);
|
|
Rows(Rows&& from) noexcept
|
|
: Rows() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline Rows& operator=(const Rows& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline Rows& operator=(Rows&& 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 Rows& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const Rows* internal_default_instance() {
|
|
return reinterpret_cast<const Rows*>(
|
|
&_Rows_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
0;
|
|
|
|
friend void swap(Rows& a, Rows& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(Rows* 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(Rows* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
Rows* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
|
|
return CreateMaybeMessage<Rows>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const Rows& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom( const Rows& from) {
|
|
Rows::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(Rows* other);
|
|
|
|
private:
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "greptime.v1.Rows";
|
|
}
|
|
protected:
|
|
explicit Rows(::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 {
|
|
kSchemaFieldNumber = 1,
|
|
kRowsFieldNumber = 2,
|
|
};
|
|
// repeated .greptime.v1.ColumnSchema schema = 1;
|
|
int schema_size() const;
|
|
private:
|
|
int _internal_schema_size() const;
|
|
public:
|
|
void clear_schema();
|
|
::greptime::v1::ColumnSchema* mutable_schema(int index);
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::ColumnSchema >*
|
|
mutable_schema();
|
|
private:
|
|
const ::greptime::v1::ColumnSchema& _internal_schema(int index) const;
|
|
::greptime::v1::ColumnSchema* _internal_add_schema();
|
|
public:
|
|
const ::greptime::v1::ColumnSchema& schema(int index) const;
|
|
::greptime::v1::ColumnSchema* add_schema();
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::ColumnSchema >&
|
|
schema() const;
|
|
|
|
// repeated .greptime.v1.Row rows = 2;
|
|
int rows_size() const;
|
|
private:
|
|
int _internal_rows_size() const;
|
|
public:
|
|
void clear_rows();
|
|
::greptime::v1::Row* mutable_rows(int index);
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Row >*
|
|
mutable_rows();
|
|
private:
|
|
const ::greptime::v1::Row& _internal_rows(int index) const;
|
|
::greptime::v1::Row* _internal_add_rows();
|
|
public:
|
|
const ::greptime::v1::Row& rows(int index) const;
|
|
::greptime::v1::Row* add_rows();
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Row >&
|
|
rows() const;
|
|
|
|
// @@protoc_insertion_point(class_scope:greptime.v1.Rows)
|
|
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::ColumnSchema > schema_;
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Row > rows_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
};
|
|
union { Impl_ _impl_; };
|
|
friend struct ::TableStruct_greptime_2fv1_2frow_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class ColumnSchema final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:greptime.v1.ColumnSchema) */ {
|
|
public:
|
|
inline ColumnSchema() : ColumnSchema(nullptr) {}
|
|
~ColumnSchema() override;
|
|
explicit PROTOBUF_CONSTEXPR ColumnSchema(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
ColumnSchema(const ColumnSchema& from);
|
|
ColumnSchema(ColumnSchema&& from) noexcept
|
|
: ColumnSchema() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline ColumnSchema& operator=(const ColumnSchema& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline ColumnSchema& operator=(ColumnSchema&& 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 ColumnSchema& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const ColumnSchema* internal_default_instance() {
|
|
return reinterpret_cast<const ColumnSchema*>(
|
|
&_ColumnSchema_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
1;
|
|
|
|
friend void swap(ColumnSchema& a, ColumnSchema& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(ColumnSchema* 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(ColumnSchema* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
ColumnSchema* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
|
|
return CreateMaybeMessage<ColumnSchema>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const ColumnSchema& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom( const ColumnSchema& from) {
|
|
ColumnSchema::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(ColumnSchema* other);
|
|
|
|
private:
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "greptime.v1.ColumnSchema";
|
|
}
|
|
protected:
|
|
explicit ColumnSchema(::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 {
|
|
kColumnNameFieldNumber = 1,
|
|
kDatatypeExtensionFieldNumber = 4,
|
|
kDatatypeFieldNumber = 2,
|
|
kSemanticTypeFieldNumber = 3,
|
|
};
|
|
// string column_name = 1;
|
|
void clear_column_name();
|
|
const std::string& column_name() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_column_name(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_column_name();
|
|
PROTOBUF_NODISCARD std::string* release_column_name();
|
|
void set_allocated_column_name(std::string* column_name);
|
|
private:
|
|
const std::string& _internal_column_name() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_column_name(const std::string& value);
|
|
std::string* _internal_mutable_column_name();
|
|
public:
|
|
|
|
// .greptime.v1.ColumnDataTypeExtension datatype_extension = 4;
|
|
bool has_datatype_extension() const;
|
|
private:
|
|
bool _internal_has_datatype_extension() const;
|
|
public:
|
|
void clear_datatype_extension();
|
|
const ::greptime::v1::ColumnDataTypeExtension& datatype_extension() const;
|
|
PROTOBUF_NODISCARD ::greptime::v1::ColumnDataTypeExtension* release_datatype_extension();
|
|
::greptime::v1::ColumnDataTypeExtension* mutable_datatype_extension();
|
|
void set_allocated_datatype_extension(::greptime::v1::ColumnDataTypeExtension* datatype_extension);
|
|
private:
|
|
const ::greptime::v1::ColumnDataTypeExtension& _internal_datatype_extension() const;
|
|
::greptime::v1::ColumnDataTypeExtension* _internal_mutable_datatype_extension();
|
|
public:
|
|
void unsafe_arena_set_allocated_datatype_extension(
|
|
::greptime::v1::ColumnDataTypeExtension* datatype_extension);
|
|
::greptime::v1::ColumnDataTypeExtension* unsafe_arena_release_datatype_extension();
|
|
|
|
// .greptime.v1.ColumnDataType datatype = 2;
|
|
void clear_datatype();
|
|
::greptime::v1::ColumnDataType datatype() const;
|
|
void set_datatype(::greptime::v1::ColumnDataType value);
|
|
private:
|
|
::greptime::v1::ColumnDataType _internal_datatype() const;
|
|
void _internal_set_datatype(::greptime::v1::ColumnDataType value);
|
|
public:
|
|
|
|
// .greptime.v1.SemanticType semantic_type = 3;
|
|
void clear_semantic_type();
|
|
::greptime::v1::SemanticType semantic_type() const;
|
|
void set_semantic_type(::greptime::v1::SemanticType value);
|
|
private:
|
|
::greptime::v1::SemanticType _internal_semantic_type() const;
|
|
void _internal_set_semantic_type(::greptime::v1::SemanticType value);
|
|
public:
|
|
|
|
// @@protoc_insertion_point(class_scope:greptime.v1.ColumnSchema)
|
|
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 column_name_;
|
|
::greptime::v1::ColumnDataTypeExtension* datatype_extension_;
|
|
int datatype_;
|
|
int semantic_type_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
};
|
|
union { Impl_ _impl_; };
|
|
friend struct ::TableStruct_greptime_2fv1_2frow_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class Row final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:greptime.v1.Row) */ {
|
|
public:
|
|
inline Row() : Row(nullptr) {}
|
|
~Row() override;
|
|
explicit PROTOBUF_CONSTEXPR Row(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
Row(const Row& from);
|
|
Row(Row&& from) noexcept
|
|
: Row() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline Row& operator=(const Row& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline Row& operator=(Row&& 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 Row& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const Row* internal_default_instance() {
|
|
return reinterpret_cast<const Row*>(
|
|
&_Row_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
2;
|
|
|
|
friend void swap(Row& a, Row& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(Row* 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(Row* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
Row* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
|
|
return CreateMaybeMessage<Row>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const Row& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom( const Row& from) {
|
|
Row::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(Row* other);
|
|
|
|
private:
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "greptime.v1.Row";
|
|
}
|
|
protected:
|
|
explicit Row(::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 {
|
|
kValuesFieldNumber = 1,
|
|
};
|
|
// repeated .greptime.v1.Value values = 1;
|
|
int values_size() const;
|
|
private:
|
|
int _internal_values_size() const;
|
|
public:
|
|
void clear_values();
|
|
::greptime::v1::Value* mutable_values(int index);
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Value >*
|
|
mutable_values();
|
|
private:
|
|
const ::greptime::v1::Value& _internal_values(int index) const;
|
|
::greptime::v1::Value* _internal_add_values();
|
|
public:
|
|
const ::greptime::v1::Value& values(int index) const;
|
|
::greptime::v1::Value* add_values();
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Value >&
|
|
values() const;
|
|
|
|
// @@protoc_insertion_point(class_scope:greptime.v1.Row)
|
|
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::Value > values_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
};
|
|
union { Impl_ _impl_; };
|
|
friend struct ::TableStruct_greptime_2fv1_2frow_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class Value final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:greptime.v1.Value) */ {
|
|
public:
|
|
inline Value() : Value(nullptr) {}
|
|
~Value() override;
|
|
explicit PROTOBUF_CONSTEXPR Value(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
Value(const Value& from);
|
|
Value(Value&& from) noexcept
|
|
: Value() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline Value& operator=(const Value& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline Value& operator=(Value&& 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 Value& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
enum ValueDataCase {
|
|
kI8Value = 1,
|
|
kI16Value = 2,
|
|
kI32Value = 3,
|
|
kI64Value = 4,
|
|
kU8Value = 5,
|
|
kU16Value = 6,
|
|
kU32Value = 7,
|
|
kU64Value = 8,
|
|
kF32Value = 9,
|
|
kF64Value = 10,
|
|
kBoolValue = 11,
|
|
kBinaryValue = 12,
|
|
kStringValue = 13,
|
|
kDateValue = 14,
|
|
kDatetimeValue = 15,
|
|
kTimestampSecondValue = 16,
|
|
kTimestampMillisecondValue = 17,
|
|
kTimestampMicrosecondValue = 18,
|
|
kTimestampNanosecondValue = 19,
|
|
kTimeSecondValue = 20,
|
|
kTimeMillisecondValue = 21,
|
|
kTimeMicrosecondValue = 22,
|
|
kTimeNanosecondValue = 23,
|
|
kIntervalYearMonthValue = 24,
|
|
kIntervalDayTimeValue = 25,
|
|
kIntervalMonthDayNanoValue = 26,
|
|
kDurationSecondValue = 27,
|
|
kDurationMillisecondValue = 28,
|
|
kDurationMicrosecondValue = 29,
|
|
kDurationNanosecondValue = 30,
|
|
kDecimal128Value = 31,
|
|
VALUE_DATA_NOT_SET = 0,
|
|
};
|
|
|
|
static inline const Value* internal_default_instance() {
|
|
return reinterpret_cast<const Value*>(
|
|
&_Value_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
3;
|
|
|
|
friend void swap(Value& a, Value& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(Value* 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(Value* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
Value* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
|
|
return CreateMaybeMessage<Value>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const Value& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom( const Value& from) {
|
|
Value::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(Value* other);
|
|
|
|
private:
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "greptime.v1.Value";
|
|
}
|
|
protected:
|
|
explicit Value(::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 {
|
|
kI8ValueFieldNumber = 1,
|
|
kI16ValueFieldNumber = 2,
|
|
kI32ValueFieldNumber = 3,
|
|
kI64ValueFieldNumber = 4,
|
|
kU8ValueFieldNumber = 5,
|
|
kU16ValueFieldNumber = 6,
|
|
kU32ValueFieldNumber = 7,
|
|
kU64ValueFieldNumber = 8,
|
|
kF32ValueFieldNumber = 9,
|
|
kF64ValueFieldNumber = 10,
|
|
kBoolValueFieldNumber = 11,
|
|
kBinaryValueFieldNumber = 12,
|
|
kStringValueFieldNumber = 13,
|
|
kDateValueFieldNumber = 14,
|
|
kDatetimeValueFieldNumber = 15,
|
|
kTimestampSecondValueFieldNumber = 16,
|
|
kTimestampMillisecondValueFieldNumber = 17,
|
|
kTimestampMicrosecondValueFieldNumber = 18,
|
|
kTimestampNanosecondValueFieldNumber = 19,
|
|
kTimeSecondValueFieldNumber = 20,
|
|
kTimeMillisecondValueFieldNumber = 21,
|
|
kTimeMicrosecondValueFieldNumber = 22,
|
|
kTimeNanosecondValueFieldNumber = 23,
|
|
kIntervalYearMonthValueFieldNumber = 24,
|
|
kIntervalDayTimeValueFieldNumber = 25,
|
|
kIntervalMonthDayNanoValueFieldNumber = 26,
|
|
kDurationSecondValueFieldNumber = 27,
|
|
kDurationMillisecondValueFieldNumber = 28,
|
|
kDurationMicrosecondValueFieldNumber = 29,
|
|
kDurationNanosecondValueFieldNumber = 30,
|
|
kDecimal128ValueFieldNumber = 31,
|
|
};
|
|
// int32 i8_value = 1;
|
|
bool has_i8_value() const;
|
|
private:
|
|
bool _internal_has_i8_value() const;
|
|
public:
|
|
void clear_i8_value();
|
|
int32_t i8_value() const;
|
|
void set_i8_value(int32_t value);
|
|
private:
|
|
int32_t _internal_i8_value() const;
|
|
void _internal_set_i8_value(int32_t value);
|
|
public:
|
|
|
|
// int32 i16_value = 2;
|
|
bool has_i16_value() const;
|
|
private:
|
|
bool _internal_has_i16_value() const;
|
|
public:
|
|
void clear_i16_value();
|
|
int32_t i16_value() const;
|
|
void set_i16_value(int32_t value);
|
|
private:
|
|
int32_t _internal_i16_value() const;
|
|
void _internal_set_i16_value(int32_t value);
|
|
public:
|
|
|
|
// int32 i32_value = 3;
|
|
bool has_i32_value() const;
|
|
private:
|
|
bool _internal_has_i32_value() const;
|
|
public:
|
|
void clear_i32_value();
|
|
int32_t i32_value() const;
|
|
void set_i32_value(int32_t value);
|
|
private:
|
|
int32_t _internal_i32_value() const;
|
|
void _internal_set_i32_value(int32_t value);
|
|
public:
|
|
|
|
// int64 i64_value = 4;
|
|
bool has_i64_value() const;
|
|
private:
|
|
bool _internal_has_i64_value() const;
|
|
public:
|
|
void clear_i64_value();
|
|
int64_t i64_value() const;
|
|
void set_i64_value(int64_t value);
|
|
private:
|
|
int64_t _internal_i64_value() const;
|
|
void _internal_set_i64_value(int64_t value);
|
|
public:
|
|
|
|
// uint32 u8_value = 5;
|
|
bool has_u8_value() const;
|
|
private:
|
|
bool _internal_has_u8_value() const;
|
|
public:
|
|
void clear_u8_value();
|
|
uint32_t u8_value() const;
|
|
void set_u8_value(uint32_t value);
|
|
private:
|
|
uint32_t _internal_u8_value() const;
|
|
void _internal_set_u8_value(uint32_t value);
|
|
public:
|
|
|
|
// uint32 u16_value = 6;
|
|
bool has_u16_value() const;
|
|
private:
|
|
bool _internal_has_u16_value() const;
|
|
public:
|
|
void clear_u16_value();
|
|
uint32_t u16_value() const;
|
|
void set_u16_value(uint32_t value);
|
|
private:
|
|
uint32_t _internal_u16_value() const;
|
|
void _internal_set_u16_value(uint32_t value);
|
|
public:
|
|
|
|
// uint32 u32_value = 7;
|
|
bool has_u32_value() const;
|
|
private:
|
|
bool _internal_has_u32_value() const;
|
|
public:
|
|
void clear_u32_value();
|
|
uint32_t u32_value() const;
|
|
void set_u32_value(uint32_t value);
|
|
private:
|
|
uint32_t _internal_u32_value() const;
|
|
void _internal_set_u32_value(uint32_t value);
|
|
public:
|
|
|
|
// uint64 u64_value = 8;
|
|
bool has_u64_value() const;
|
|
private:
|
|
bool _internal_has_u64_value() const;
|
|
public:
|
|
void clear_u64_value();
|
|
uint64_t u64_value() const;
|
|
void set_u64_value(uint64_t value);
|
|
private:
|
|
uint64_t _internal_u64_value() const;
|
|
void _internal_set_u64_value(uint64_t value);
|
|
public:
|
|
|
|
// float f32_value = 9;
|
|
bool has_f32_value() const;
|
|
private:
|
|
bool _internal_has_f32_value() const;
|
|
public:
|
|
void clear_f32_value();
|
|
float f32_value() const;
|
|
void set_f32_value(float value);
|
|
private:
|
|
float _internal_f32_value() const;
|
|
void _internal_set_f32_value(float value);
|
|
public:
|
|
|
|
// double f64_value = 10;
|
|
bool has_f64_value() const;
|
|
private:
|
|
bool _internal_has_f64_value() const;
|
|
public:
|
|
void clear_f64_value();
|
|
double f64_value() const;
|
|
void set_f64_value(double value);
|
|
private:
|
|
double _internal_f64_value() const;
|
|
void _internal_set_f64_value(double value);
|
|
public:
|
|
|
|
// bool bool_value = 11;
|
|
bool has_bool_value() const;
|
|
private:
|
|
bool _internal_has_bool_value() const;
|
|
public:
|
|
void clear_bool_value();
|
|
bool bool_value() const;
|
|
void set_bool_value(bool value);
|
|
private:
|
|
bool _internal_bool_value() const;
|
|
void _internal_set_bool_value(bool value);
|
|
public:
|
|
|
|
// bytes binary_value = 12;
|
|
bool has_binary_value() const;
|
|
private:
|
|
bool _internal_has_binary_value() const;
|
|
public:
|
|
void clear_binary_value();
|
|
const std::string& binary_value() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_binary_value(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_binary_value();
|
|
PROTOBUF_NODISCARD std::string* release_binary_value();
|
|
void set_allocated_binary_value(std::string* binary_value);
|
|
private:
|
|
const std::string& _internal_binary_value() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_binary_value(const std::string& value);
|
|
std::string* _internal_mutable_binary_value();
|
|
public:
|
|
|
|
// string string_value = 13;
|
|
bool has_string_value() const;
|
|
private:
|
|
bool _internal_has_string_value() const;
|
|
public:
|
|
void clear_string_value();
|
|
const std::string& string_value() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_string_value(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_string_value();
|
|
PROTOBUF_NODISCARD std::string* release_string_value();
|
|
void set_allocated_string_value(std::string* string_value);
|
|
private:
|
|
const std::string& _internal_string_value() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_string_value(const std::string& value);
|
|
std::string* _internal_mutable_string_value();
|
|
public:
|
|
|
|
// int32 date_value = 14;
|
|
bool has_date_value() const;
|
|
private:
|
|
bool _internal_has_date_value() const;
|
|
public:
|
|
void clear_date_value();
|
|
int32_t date_value() const;
|
|
void set_date_value(int32_t value);
|
|
private:
|
|
int32_t _internal_date_value() const;
|
|
void _internal_set_date_value(int32_t value);
|
|
public:
|
|
|
|
// int64 datetime_value = 15;
|
|
bool has_datetime_value() const;
|
|
private:
|
|
bool _internal_has_datetime_value() const;
|
|
public:
|
|
void clear_datetime_value();
|
|
int64_t datetime_value() const;
|
|
void set_datetime_value(int64_t value);
|
|
private:
|
|
int64_t _internal_datetime_value() const;
|
|
void _internal_set_datetime_value(int64_t value);
|
|
public:
|
|
|
|
// int64 timestamp_second_value = 16;
|
|
bool has_timestamp_second_value() const;
|
|
private:
|
|
bool _internal_has_timestamp_second_value() const;
|
|
public:
|
|
void clear_timestamp_second_value();
|
|
int64_t timestamp_second_value() const;
|
|
void set_timestamp_second_value(int64_t value);
|
|
private:
|
|
int64_t _internal_timestamp_second_value() const;
|
|
void _internal_set_timestamp_second_value(int64_t value);
|
|
public:
|
|
|
|
// int64 timestamp_millisecond_value = 17;
|
|
bool has_timestamp_millisecond_value() const;
|
|
private:
|
|
bool _internal_has_timestamp_millisecond_value() const;
|
|
public:
|
|
void clear_timestamp_millisecond_value();
|
|
int64_t timestamp_millisecond_value() const;
|
|
void set_timestamp_millisecond_value(int64_t value);
|
|
private:
|
|
int64_t _internal_timestamp_millisecond_value() const;
|
|
void _internal_set_timestamp_millisecond_value(int64_t value);
|
|
public:
|
|
|
|
// int64 timestamp_microsecond_value = 18;
|
|
bool has_timestamp_microsecond_value() const;
|
|
private:
|
|
bool _internal_has_timestamp_microsecond_value() const;
|
|
public:
|
|
void clear_timestamp_microsecond_value();
|
|
int64_t timestamp_microsecond_value() const;
|
|
void set_timestamp_microsecond_value(int64_t value);
|
|
private:
|
|
int64_t _internal_timestamp_microsecond_value() const;
|
|
void _internal_set_timestamp_microsecond_value(int64_t value);
|
|
public:
|
|
|
|
// int64 timestamp_nanosecond_value = 19;
|
|
bool has_timestamp_nanosecond_value() const;
|
|
private:
|
|
bool _internal_has_timestamp_nanosecond_value() const;
|
|
public:
|
|
void clear_timestamp_nanosecond_value();
|
|
int64_t timestamp_nanosecond_value() const;
|
|
void set_timestamp_nanosecond_value(int64_t value);
|
|
private:
|
|
int64_t _internal_timestamp_nanosecond_value() const;
|
|
void _internal_set_timestamp_nanosecond_value(int64_t value);
|
|
public:
|
|
|
|
// int64 time_second_value = 20;
|
|
bool has_time_second_value() const;
|
|
private:
|
|
bool _internal_has_time_second_value() const;
|
|
public:
|
|
void clear_time_second_value();
|
|
int64_t time_second_value() const;
|
|
void set_time_second_value(int64_t value);
|
|
private:
|
|
int64_t _internal_time_second_value() const;
|
|
void _internal_set_time_second_value(int64_t value);
|
|
public:
|
|
|
|
// int64 time_millisecond_value = 21;
|
|
bool has_time_millisecond_value() const;
|
|
private:
|
|
bool _internal_has_time_millisecond_value() const;
|
|
public:
|
|
void clear_time_millisecond_value();
|
|
int64_t time_millisecond_value() const;
|
|
void set_time_millisecond_value(int64_t value);
|
|
private:
|
|
int64_t _internal_time_millisecond_value() const;
|
|
void _internal_set_time_millisecond_value(int64_t value);
|
|
public:
|
|
|
|
// int64 time_microsecond_value = 22;
|
|
bool has_time_microsecond_value() const;
|
|
private:
|
|
bool _internal_has_time_microsecond_value() const;
|
|
public:
|
|
void clear_time_microsecond_value();
|
|
int64_t time_microsecond_value() const;
|
|
void set_time_microsecond_value(int64_t value);
|
|
private:
|
|
int64_t _internal_time_microsecond_value() const;
|
|
void _internal_set_time_microsecond_value(int64_t value);
|
|
public:
|
|
|
|
// int64 time_nanosecond_value = 23;
|
|
bool has_time_nanosecond_value() const;
|
|
private:
|
|
bool _internal_has_time_nanosecond_value() const;
|
|
public:
|
|
void clear_time_nanosecond_value();
|
|
int64_t time_nanosecond_value() const;
|
|
void set_time_nanosecond_value(int64_t value);
|
|
private:
|
|
int64_t _internal_time_nanosecond_value() const;
|
|
void _internal_set_time_nanosecond_value(int64_t value);
|
|
public:
|
|
|
|
// int32 interval_year_month_value = 24;
|
|
bool has_interval_year_month_value() const;
|
|
private:
|
|
bool _internal_has_interval_year_month_value() const;
|
|
public:
|
|
void clear_interval_year_month_value();
|
|
int32_t interval_year_month_value() const;
|
|
void set_interval_year_month_value(int32_t value);
|
|
private:
|
|
int32_t _internal_interval_year_month_value() const;
|
|
void _internal_set_interval_year_month_value(int32_t value);
|
|
public:
|
|
|
|
// int64 interval_day_time_value = 25;
|
|
bool has_interval_day_time_value() const;
|
|
private:
|
|
bool _internal_has_interval_day_time_value() const;
|
|
public:
|
|
void clear_interval_day_time_value();
|
|
int64_t interval_day_time_value() const;
|
|
void set_interval_day_time_value(int64_t value);
|
|
private:
|
|
int64_t _internal_interval_day_time_value() const;
|
|
void _internal_set_interval_day_time_value(int64_t value);
|
|
public:
|
|
|
|
// .greptime.v1.IntervalMonthDayNano interval_month_day_nano_value = 26;
|
|
bool has_interval_month_day_nano_value() const;
|
|
private:
|
|
bool _internal_has_interval_month_day_nano_value() const;
|
|
public:
|
|
void clear_interval_month_day_nano_value();
|
|
const ::greptime::v1::IntervalMonthDayNano& interval_month_day_nano_value() const;
|
|
PROTOBUF_NODISCARD ::greptime::v1::IntervalMonthDayNano* release_interval_month_day_nano_value();
|
|
::greptime::v1::IntervalMonthDayNano* mutable_interval_month_day_nano_value();
|
|
void set_allocated_interval_month_day_nano_value(::greptime::v1::IntervalMonthDayNano* interval_month_day_nano_value);
|
|
private:
|
|
const ::greptime::v1::IntervalMonthDayNano& _internal_interval_month_day_nano_value() const;
|
|
::greptime::v1::IntervalMonthDayNano* _internal_mutable_interval_month_day_nano_value();
|
|
public:
|
|
void unsafe_arena_set_allocated_interval_month_day_nano_value(
|
|
::greptime::v1::IntervalMonthDayNano* interval_month_day_nano_value);
|
|
::greptime::v1::IntervalMonthDayNano* unsafe_arena_release_interval_month_day_nano_value();
|
|
|
|
// int64 duration_second_value = 27;
|
|
bool has_duration_second_value() const;
|
|
private:
|
|
bool _internal_has_duration_second_value() const;
|
|
public:
|
|
void clear_duration_second_value();
|
|
int64_t duration_second_value() const;
|
|
void set_duration_second_value(int64_t value);
|
|
private:
|
|
int64_t _internal_duration_second_value() const;
|
|
void _internal_set_duration_second_value(int64_t value);
|
|
public:
|
|
|
|
// int64 duration_millisecond_value = 28;
|
|
bool has_duration_millisecond_value() const;
|
|
private:
|
|
bool _internal_has_duration_millisecond_value() const;
|
|
public:
|
|
void clear_duration_millisecond_value();
|
|
int64_t duration_millisecond_value() const;
|
|
void set_duration_millisecond_value(int64_t value);
|
|
private:
|
|
int64_t _internal_duration_millisecond_value() const;
|
|
void _internal_set_duration_millisecond_value(int64_t value);
|
|
public:
|
|
|
|
// int64 duration_microsecond_value = 29;
|
|
bool has_duration_microsecond_value() const;
|
|
private:
|
|
bool _internal_has_duration_microsecond_value() const;
|
|
public:
|
|
void clear_duration_microsecond_value();
|
|
int64_t duration_microsecond_value() const;
|
|
void set_duration_microsecond_value(int64_t value);
|
|
private:
|
|
int64_t _internal_duration_microsecond_value() const;
|
|
void _internal_set_duration_microsecond_value(int64_t value);
|
|
public:
|
|
|
|
// int64 duration_nanosecond_value = 30;
|
|
bool has_duration_nanosecond_value() const;
|
|
private:
|
|
bool _internal_has_duration_nanosecond_value() const;
|
|
public:
|
|
void clear_duration_nanosecond_value();
|
|
int64_t duration_nanosecond_value() const;
|
|
void set_duration_nanosecond_value(int64_t value);
|
|
private:
|
|
int64_t _internal_duration_nanosecond_value() const;
|
|
void _internal_set_duration_nanosecond_value(int64_t value);
|
|
public:
|
|
|
|
// .greptime.v1.Decimal128 decimal128_value = 31;
|
|
bool has_decimal128_value() const;
|
|
private:
|
|
bool _internal_has_decimal128_value() const;
|
|
public:
|
|
void clear_decimal128_value();
|
|
const ::greptime::v1::Decimal128& decimal128_value() const;
|
|
PROTOBUF_NODISCARD ::greptime::v1::Decimal128* release_decimal128_value();
|
|
::greptime::v1::Decimal128* mutable_decimal128_value();
|
|
void set_allocated_decimal128_value(::greptime::v1::Decimal128* decimal128_value);
|
|
private:
|
|
const ::greptime::v1::Decimal128& _internal_decimal128_value() const;
|
|
::greptime::v1::Decimal128* _internal_mutable_decimal128_value();
|
|
public:
|
|
void unsafe_arena_set_allocated_decimal128_value(
|
|
::greptime::v1::Decimal128* decimal128_value);
|
|
::greptime::v1::Decimal128* unsafe_arena_release_decimal128_value();
|
|
|
|
void clear_value_data();
|
|
ValueDataCase value_data_case() const;
|
|
// @@protoc_insertion_point(class_scope:greptime.v1.Value)
|
|
private:
|
|
class _Internal;
|
|
void set_has_i8_value();
|
|
void set_has_i16_value();
|
|
void set_has_i32_value();
|
|
void set_has_i64_value();
|
|
void set_has_u8_value();
|
|
void set_has_u16_value();
|
|
void set_has_u32_value();
|
|
void set_has_u64_value();
|
|
void set_has_f32_value();
|
|
void set_has_f64_value();
|
|
void set_has_bool_value();
|
|
void set_has_binary_value();
|
|
void set_has_string_value();
|
|
void set_has_date_value();
|
|
void set_has_datetime_value();
|
|
void set_has_timestamp_second_value();
|
|
void set_has_timestamp_millisecond_value();
|
|
void set_has_timestamp_microsecond_value();
|
|
void set_has_timestamp_nanosecond_value();
|
|
void set_has_time_second_value();
|
|
void set_has_time_millisecond_value();
|
|
void set_has_time_microsecond_value();
|
|
void set_has_time_nanosecond_value();
|
|
void set_has_interval_year_month_value();
|
|
void set_has_interval_day_time_value();
|
|
void set_has_interval_month_day_nano_value();
|
|
void set_has_duration_second_value();
|
|
void set_has_duration_millisecond_value();
|
|
void set_has_duration_microsecond_value();
|
|
void set_has_duration_nanosecond_value();
|
|
void set_has_decimal128_value();
|
|
|
|
inline bool has_value_data() const;
|
|
inline void clear_has_value_data();
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
struct Impl_ {
|
|
union ValueDataUnion {
|
|
constexpr ValueDataUnion() : _constinit_{} {}
|
|
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
|
|
int32_t i8_value_;
|
|
int32_t i16_value_;
|
|
int32_t i32_value_;
|
|
int64_t i64_value_;
|
|
uint32_t u8_value_;
|
|
uint32_t u16_value_;
|
|
uint32_t u32_value_;
|
|
uint64_t u64_value_;
|
|
float f32_value_;
|
|
double f64_value_;
|
|
bool bool_value_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr binary_value_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_value_;
|
|
int32_t date_value_;
|
|
int64_t datetime_value_;
|
|
int64_t timestamp_second_value_;
|
|
int64_t timestamp_millisecond_value_;
|
|
int64_t timestamp_microsecond_value_;
|
|
int64_t timestamp_nanosecond_value_;
|
|
int64_t time_second_value_;
|
|
int64_t time_millisecond_value_;
|
|
int64_t time_microsecond_value_;
|
|
int64_t time_nanosecond_value_;
|
|
int32_t interval_year_month_value_;
|
|
int64_t interval_day_time_value_;
|
|
::greptime::v1::IntervalMonthDayNano* interval_month_day_nano_value_;
|
|
int64_t duration_second_value_;
|
|
int64_t duration_millisecond_value_;
|
|
int64_t duration_microsecond_value_;
|
|
int64_t duration_nanosecond_value_;
|
|
::greptime::v1::Decimal128* decimal128_value_;
|
|
} value_data_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
uint32_t _oneof_case_[1];
|
|
|
|
};
|
|
union { Impl_ _impl_; };
|
|
friend struct ::TableStruct_greptime_2fv1_2frow_2eproto;
|
|
};
|
|
// ===================================================================
|
|
|
|
|
|
// ===================================================================
|
|
|
|
#ifdef __GNUC__
|
|
#pragma GCC diagnostic push
|
|
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
|
|
#endif // __GNUC__
|
|
// Rows
|
|
|
|
// repeated .greptime.v1.ColumnSchema schema = 1;
|
|
inline int Rows::_internal_schema_size() const {
|
|
return _impl_.schema_.size();
|
|
}
|
|
inline int Rows::schema_size() const {
|
|
return _internal_schema_size();
|
|
}
|
|
inline void Rows::clear_schema() {
|
|
_impl_.schema_.Clear();
|
|
}
|
|
inline ::greptime::v1::ColumnSchema* Rows::mutable_schema(int index) {
|
|
// @@protoc_insertion_point(field_mutable:greptime.v1.Rows.schema)
|
|
return _impl_.schema_.Mutable(index);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::ColumnSchema >*
|
|
Rows::mutable_schema() {
|
|
// @@protoc_insertion_point(field_mutable_list:greptime.v1.Rows.schema)
|
|
return &_impl_.schema_;
|
|
}
|
|
inline const ::greptime::v1::ColumnSchema& Rows::_internal_schema(int index) const {
|
|
return _impl_.schema_.Get(index);
|
|
}
|
|
inline const ::greptime::v1::ColumnSchema& Rows::schema(int index) const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Rows.schema)
|
|
return _internal_schema(index);
|
|
}
|
|
inline ::greptime::v1::ColumnSchema* Rows::_internal_add_schema() {
|
|
return _impl_.schema_.Add();
|
|
}
|
|
inline ::greptime::v1::ColumnSchema* Rows::add_schema() {
|
|
::greptime::v1::ColumnSchema* _add = _internal_add_schema();
|
|
// @@protoc_insertion_point(field_add:greptime.v1.Rows.schema)
|
|
return _add;
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::ColumnSchema >&
|
|
Rows::schema() const {
|
|
// @@protoc_insertion_point(field_list:greptime.v1.Rows.schema)
|
|
return _impl_.schema_;
|
|
}
|
|
|
|
// repeated .greptime.v1.Row rows = 2;
|
|
inline int Rows::_internal_rows_size() const {
|
|
return _impl_.rows_.size();
|
|
}
|
|
inline int Rows::rows_size() const {
|
|
return _internal_rows_size();
|
|
}
|
|
inline void Rows::clear_rows() {
|
|
_impl_.rows_.Clear();
|
|
}
|
|
inline ::greptime::v1::Row* Rows::mutable_rows(int index) {
|
|
// @@protoc_insertion_point(field_mutable:greptime.v1.Rows.rows)
|
|
return _impl_.rows_.Mutable(index);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Row >*
|
|
Rows::mutable_rows() {
|
|
// @@protoc_insertion_point(field_mutable_list:greptime.v1.Rows.rows)
|
|
return &_impl_.rows_;
|
|
}
|
|
inline const ::greptime::v1::Row& Rows::_internal_rows(int index) const {
|
|
return _impl_.rows_.Get(index);
|
|
}
|
|
inline const ::greptime::v1::Row& Rows::rows(int index) const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Rows.rows)
|
|
return _internal_rows(index);
|
|
}
|
|
inline ::greptime::v1::Row* Rows::_internal_add_rows() {
|
|
return _impl_.rows_.Add();
|
|
}
|
|
inline ::greptime::v1::Row* Rows::add_rows() {
|
|
::greptime::v1::Row* _add = _internal_add_rows();
|
|
// @@protoc_insertion_point(field_add:greptime.v1.Rows.rows)
|
|
return _add;
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Row >&
|
|
Rows::rows() const {
|
|
// @@protoc_insertion_point(field_list:greptime.v1.Rows.rows)
|
|
return _impl_.rows_;
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// ColumnSchema
|
|
|
|
// string column_name = 1;
|
|
inline void ColumnSchema::clear_column_name() {
|
|
_impl_.column_name_.ClearToEmpty();
|
|
}
|
|
inline const std::string& ColumnSchema::column_name() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.ColumnSchema.column_name)
|
|
return _internal_column_name();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void ColumnSchema::set_column_name(ArgT0&& arg0, ArgT... args) {
|
|
|
|
_impl_.column_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:greptime.v1.ColumnSchema.column_name)
|
|
}
|
|
inline std::string* ColumnSchema::mutable_column_name() {
|
|
std::string* _s = _internal_mutable_column_name();
|
|
// @@protoc_insertion_point(field_mutable:greptime.v1.ColumnSchema.column_name)
|
|
return _s;
|
|
}
|
|
inline const std::string& ColumnSchema::_internal_column_name() const {
|
|
return _impl_.column_name_.Get();
|
|
}
|
|
inline void ColumnSchema::_internal_set_column_name(const std::string& value) {
|
|
|
|
_impl_.column_name_.Set(value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* ColumnSchema::_internal_mutable_column_name() {
|
|
|
|
return _impl_.column_name_.Mutable(GetArenaForAllocation());
|
|
}
|
|
inline std::string* ColumnSchema::release_column_name() {
|
|
// @@protoc_insertion_point(field_release:greptime.v1.ColumnSchema.column_name)
|
|
return _impl_.column_name_.Release();
|
|
}
|
|
inline void ColumnSchema::set_allocated_column_name(std::string* column_name) {
|
|
if (column_name != nullptr) {
|
|
|
|
} else {
|
|
|
|
}
|
|
_impl_.column_name_.SetAllocated(column_name, GetArenaForAllocation());
|
|
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
if (_impl_.column_name_.IsDefault()) {
|
|
_impl_.column_name_.Set("", GetArenaForAllocation());
|
|
}
|
|
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
// @@protoc_insertion_point(field_set_allocated:greptime.v1.ColumnSchema.column_name)
|
|
}
|
|
|
|
// .greptime.v1.ColumnDataType datatype = 2;
|
|
inline void ColumnSchema::clear_datatype() {
|
|
_impl_.datatype_ = 0;
|
|
}
|
|
inline ::greptime::v1::ColumnDataType ColumnSchema::_internal_datatype() const {
|
|
return static_cast< ::greptime::v1::ColumnDataType >(_impl_.datatype_);
|
|
}
|
|
inline ::greptime::v1::ColumnDataType ColumnSchema::datatype() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.ColumnSchema.datatype)
|
|
return _internal_datatype();
|
|
}
|
|
inline void ColumnSchema::_internal_set_datatype(::greptime::v1::ColumnDataType value) {
|
|
|
|
_impl_.datatype_ = value;
|
|
}
|
|
inline void ColumnSchema::set_datatype(::greptime::v1::ColumnDataType value) {
|
|
_internal_set_datatype(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.ColumnSchema.datatype)
|
|
}
|
|
|
|
// .greptime.v1.SemanticType semantic_type = 3;
|
|
inline void ColumnSchema::clear_semantic_type() {
|
|
_impl_.semantic_type_ = 0;
|
|
}
|
|
inline ::greptime::v1::SemanticType ColumnSchema::_internal_semantic_type() const {
|
|
return static_cast< ::greptime::v1::SemanticType >(_impl_.semantic_type_);
|
|
}
|
|
inline ::greptime::v1::SemanticType ColumnSchema::semantic_type() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.ColumnSchema.semantic_type)
|
|
return _internal_semantic_type();
|
|
}
|
|
inline void ColumnSchema::_internal_set_semantic_type(::greptime::v1::SemanticType value) {
|
|
|
|
_impl_.semantic_type_ = value;
|
|
}
|
|
inline void ColumnSchema::set_semantic_type(::greptime::v1::SemanticType value) {
|
|
_internal_set_semantic_type(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.ColumnSchema.semantic_type)
|
|
}
|
|
|
|
// .greptime.v1.ColumnDataTypeExtension datatype_extension = 4;
|
|
inline bool ColumnSchema::_internal_has_datatype_extension() const {
|
|
return this != internal_default_instance() && _impl_.datatype_extension_ != nullptr;
|
|
}
|
|
inline bool ColumnSchema::has_datatype_extension() const {
|
|
return _internal_has_datatype_extension();
|
|
}
|
|
inline const ::greptime::v1::ColumnDataTypeExtension& ColumnSchema::_internal_datatype_extension() const {
|
|
const ::greptime::v1::ColumnDataTypeExtension* p = _impl_.datatype_extension_;
|
|
return p != nullptr ? *p : reinterpret_cast<const ::greptime::v1::ColumnDataTypeExtension&>(
|
|
::greptime::v1::_ColumnDataTypeExtension_default_instance_);
|
|
}
|
|
inline const ::greptime::v1::ColumnDataTypeExtension& ColumnSchema::datatype_extension() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.ColumnSchema.datatype_extension)
|
|
return _internal_datatype_extension();
|
|
}
|
|
inline void ColumnSchema::unsafe_arena_set_allocated_datatype_extension(
|
|
::greptime::v1::ColumnDataTypeExtension* datatype_extension) {
|
|
if (GetArenaForAllocation() == nullptr) {
|
|
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.datatype_extension_);
|
|
}
|
|
_impl_.datatype_extension_ = datatype_extension;
|
|
if (datatype_extension) {
|
|
|
|
} else {
|
|
|
|
}
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.ColumnSchema.datatype_extension)
|
|
}
|
|
inline ::greptime::v1::ColumnDataTypeExtension* ColumnSchema::release_datatype_extension() {
|
|
|
|
::greptime::v1::ColumnDataTypeExtension* temp = _impl_.datatype_extension_;
|
|
_impl_.datatype_extension_ = 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::ColumnDataTypeExtension* ColumnSchema::unsafe_arena_release_datatype_extension() {
|
|
// @@protoc_insertion_point(field_release:greptime.v1.ColumnSchema.datatype_extension)
|
|
|
|
::greptime::v1::ColumnDataTypeExtension* temp = _impl_.datatype_extension_;
|
|
_impl_.datatype_extension_ = nullptr;
|
|
return temp;
|
|
}
|
|
inline ::greptime::v1::ColumnDataTypeExtension* ColumnSchema::_internal_mutable_datatype_extension() {
|
|
|
|
if (_impl_.datatype_extension_ == nullptr) {
|
|
auto* p = CreateMaybeMessage<::greptime::v1::ColumnDataTypeExtension>(GetArenaForAllocation());
|
|
_impl_.datatype_extension_ = p;
|
|
}
|
|
return _impl_.datatype_extension_;
|
|
}
|
|
inline ::greptime::v1::ColumnDataTypeExtension* ColumnSchema::mutable_datatype_extension() {
|
|
::greptime::v1::ColumnDataTypeExtension* _msg = _internal_mutable_datatype_extension();
|
|
// @@protoc_insertion_point(field_mutable:greptime.v1.ColumnSchema.datatype_extension)
|
|
return _msg;
|
|
}
|
|
inline void ColumnSchema::set_allocated_datatype_extension(::greptime::v1::ColumnDataTypeExtension* datatype_extension) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
|
|
if (message_arena == nullptr) {
|
|
delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.datatype_extension_);
|
|
}
|
|
if (datatype_extension) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
|
|
::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
|
|
reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(datatype_extension));
|
|
if (message_arena != submessage_arena) {
|
|
datatype_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
|
|
message_arena, datatype_extension, submessage_arena);
|
|
}
|
|
|
|
} else {
|
|
|
|
}
|
|
_impl_.datatype_extension_ = datatype_extension;
|
|
// @@protoc_insertion_point(field_set_allocated:greptime.v1.ColumnSchema.datatype_extension)
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// Row
|
|
|
|
// repeated .greptime.v1.Value values = 1;
|
|
inline int Row::_internal_values_size() const {
|
|
return _impl_.values_.size();
|
|
}
|
|
inline int Row::values_size() const {
|
|
return _internal_values_size();
|
|
}
|
|
inline void Row::clear_values() {
|
|
_impl_.values_.Clear();
|
|
}
|
|
inline ::greptime::v1::Value* Row::mutable_values(int index) {
|
|
// @@protoc_insertion_point(field_mutable:greptime.v1.Row.values)
|
|
return _impl_.values_.Mutable(index);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Value >*
|
|
Row::mutable_values() {
|
|
// @@protoc_insertion_point(field_mutable_list:greptime.v1.Row.values)
|
|
return &_impl_.values_;
|
|
}
|
|
inline const ::greptime::v1::Value& Row::_internal_values(int index) const {
|
|
return _impl_.values_.Get(index);
|
|
}
|
|
inline const ::greptime::v1::Value& Row::values(int index) const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Row.values)
|
|
return _internal_values(index);
|
|
}
|
|
inline ::greptime::v1::Value* Row::_internal_add_values() {
|
|
return _impl_.values_.Add();
|
|
}
|
|
inline ::greptime::v1::Value* Row::add_values() {
|
|
::greptime::v1::Value* _add = _internal_add_values();
|
|
// @@protoc_insertion_point(field_add:greptime.v1.Row.values)
|
|
return _add;
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Value >&
|
|
Row::values() const {
|
|
// @@protoc_insertion_point(field_list:greptime.v1.Row.values)
|
|
return _impl_.values_;
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// Value
|
|
|
|
// int32 i8_value = 1;
|
|
inline bool Value::_internal_has_i8_value() const {
|
|
return value_data_case() == kI8Value;
|
|
}
|
|
inline bool Value::has_i8_value() const {
|
|
return _internal_has_i8_value();
|
|
}
|
|
inline void Value::set_has_i8_value() {
|
|
_impl_._oneof_case_[0] = kI8Value;
|
|
}
|
|
inline void Value::clear_i8_value() {
|
|
if (_internal_has_i8_value()) {
|
|
_impl_.value_data_.i8_value_ = 0;
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline int32_t Value::_internal_i8_value() const {
|
|
if (_internal_has_i8_value()) {
|
|
return _impl_.value_data_.i8_value_;
|
|
}
|
|
return 0;
|
|
}
|
|
inline void Value::_internal_set_i8_value(int32_t value) {
|
|
if (!_internal_has_i8_value()) {
|
|
clear_value_data();
|
|
set_has_i8_value();
|
|
}
|
|
_impl_.value_data_.i8_value_ = value;
|
|
}
|
|
inline int32_t Value::i8_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.i8_value)
|
|
return _internal_i8_value();
|
|
}
|
|
inline void Value::set_i8_value(int32_t value) {
|
|
_internal_set_i8_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.i8_value)
|
|
}
|
|
|
|
// int32 i16_value = 2;
|
|
inline bool Value::_internal_has_i16_value() const {
|
|
return value_data_case() == kI16Value;
|
|
}
|
|
inline bool Value::has_i16_value() const {
|
|
return _internal_has_i16_value();
|
|
}
|
|
inline void Value::set_has_i16_value() {
|
|
_impl_._oneof_case_[0] = kI16Value;
|
|
}
|
|
inline void Value::clear_i16_value() {
|
|
if (_internal_has_i16_value()) {
|
|
_impl_.value_data_.i16_value_ = 0;
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline int32_t Value::_internal_i16_value() const {
|
|
if (_internal_has_i16_value()) {
|
|
return _impl_.value_data_.i16_value_;
|
|
}
|
|
return 0;
|
|
}
|
|
inline void Value::_internal_set_i16_value(int32_t value) {
|
|
if (!_internal_has_i16_value()) {
|
|
clear_value_data();
|
|
set_has_i16_value();
|
|
}
|
|
_impl_.value_data_.i16_value_ = value;
|
|
}
|
|
inline int32_t Value::i16_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.i16_value)
|
|
return _internal_i16_value();
|
|
}
|
|
inline void Value::set_i16_value(int32_t value) {
|
|
_internal_set_i16_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.i16_value)
|
|
}
|
|
|
|
// int32 i32_value = 3;
|
|
inline bool Value::_internal_has_i32_value() const {
|
|
return value_data_case() == kI32Value;
|
|
}
|
|
inline bool Value::has_i32_value() const {
|
|
return _internal_has_i32_value();
|
|
}
|
|
inline void Value::set_has_i32_value() {
|
|
_impl_._oneof_case_[0] = kI32Value;
|
|
}
|
|
inline void Value::clear_i32_value() {
|
|
if (_internal_has_i32_value()) {
|
|
_impl_.value_data_.i32_value_ = 0;
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline int32_t Value::_internal_i32_value() const {
|
|
if (_internal_has_i32_value()) {
|
|
return _impl_.value_data_.i32_value_;
|
|
}
|
|
return 0;
|
|
}
|
|
inline void Value::_internal_set_i32_value(int32_t value) {
|
|
if (!_internal_has_i32_value()) {
|
|
clear_value_data();
|
|
set_has_i32_value();
|
|
}
|
|
_impl_.value_data_.i32_value_ = value;
|
|
}
|
|
inline int32_t Value::i32_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.i32_value)
|
|
return _internal_i32_value();
|
|
}
|
|
inline void Value::set_i32_value(int32_t value) {
|
|
_internal_set_i32_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.i32_value)
|
|
}
|
|
|
|
// int64 i64_value = 4;
|
|
inline bool Value::_internal_has_i64_value() const {
|
|
return value_data_case() == kI64Value;
|
|
}
|
|
inline bool Value::has_i64_value() const {
|
|
return _internal_has_i64_value();
|
|
}
|
|
inline void Value::set_has_i64_value() {
|
|
_impl_._oneof_case_[0] = kI64Value;
|
|
}
|
|
inline void Value::clear_i64_value() {
|
|
if (_internal_has_i64_value()) {
|
|
_impl_.value_data_.i64_value_ = int64_t{0};
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline int64_t Value::_internal_i64_value() const {
|
|
if (_internal_has_i64_value()) {
|
|
return _impl_.value_data_.i64_value_;
|
|
}
|
|
return int64_t{0};
|
|
}
|
|
inline void Value::_internal_set_i64_value(int64_t value) {
|
|
if (!_internal_has_i64_value()) {
|
|
clear_value_data();
|
|
set_has_i64_value();
|
|
}
|
|
_impl_.value_data_.i64_value_ = value;
|
|
}
|
|
inline int64_t Value::i64_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.i64_value)
|
|
return _internal_i64_value();
|
|
}
|
|
inline void Value::set_i64_value(int64_t value) {
|
|
_internal_set_i64_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.i64_value)
|
|
}
|
|
|
|
// uint32 u8_value = 5;
|
|
inline bool Value::_internal_has_u8_value() const {
|
|
return value_data_case() == kU8Value;
|
|
}
|
|
inline bool Value::has_u8_value() const {
|
|
return _internal_has_u8_value();
|
|
}
|
|
inline void Value::set_has_u8_value() {
|
|
_impl_._oneof_case_[0] = kU8Value;
|
|
}
|
|
inline void Value::clear_u8_value() {
|
|
if (_internal_has_u8_value()) {
|
|
_impl_.value_data_.u8_value_ = 0u;
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline uint32_t Value::_internal_u8_value() const {
|
|
if (_internal_has_u8_value()) {
|
|
return _impl_.value_data_.u8_value_;
|
|
}
|
|
return 0u;
|
|
}
|
|
inline void Value::_internal_set_u8_value(uint32_t value) {
|
|
if (!_internal_has_u8_value()) {
|
|
clear_value_data();
|
|
set_has_u8_value();
|
|
}
|
|
_impl_.value_data_.u8_value_ = value;
|
|
}
|
|
inline uint32_t Value::u8_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.u8_value)
|
|
return _internal_u8_value();
|
|
}
|
|
inline void Value::set_u8_value(uint32_t value) {
|
|
_internal_set_u8_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.u8_value)
|
|
}
|
|
|
|
// uint32 u16_value = 6;
|
|
inline bool Value::_internal_has_u16_value() const {
|
|
return value_data_case() == kU16Value;
|
|
}
|
|
inline bool Value::has_u16_value() const {
|
|
return _internal_has_u16_value();
|
|
}
|
|
inline void Value::set_has_u16_value() {
|
|
_impl_._oneof_case_[0] = kU16Value;
|
|
}
|
|
inline void Value::clear_u16_value() {
|
|
if (_internal_has_u16_value()) {
|
|
_impl_.value_data_.u16_value_ = 0u;
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline uint32_t Value::_internal_u16_value() const {
|
|
if (_internal_has_u16_value()) {
|
|
return _impl_.value_data_.u16_value_;
|
|
}
|
|
return 0u;
|
|
}
|
|
inline void Value::_internal_set_u16_value(uint32_t value) {
|
|
if (!_internal_has_u16_value()) {
|
|
clear_value_data();
|
|
set_has_u16_value();
|
|
}
|
|
_impl_.value_data_.u16_value_ = value;
|
|
}
|
|
inline uint32_t Value::u16_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.u16_value)
|
|
return _internal_u16_value();
|
|
}
|
|
inline void Value::set_u16_value(uint32_t value) {
|
|
_internal_set_u16_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.u16_value)
|
|
}
|
|
|
|
// uint32 u32_value = 7;
|
|
inline bool Value::_internal_has_u32_value() const {
|
|
return value_data_case() == kU32Value;
|
|
}
|
|
inline bool Value::has_u32_value() const {
|
|
return _internal_has_u32_value();
|
|
}
|
|
inline void Value::set_has_u32_value() {
|
|
_impl_._oneof_case_[0] = kU32Value;
|
|
}
|
|
inline void Value::clear_u32_value() {
|
|
if (_internal_has_u32_value()) {
|
|
_impl_.value_data_.u32_value_ = 0u;
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline uint32_t Value::_internal_u32_value() const {
|
|
if (_internal_has_u32_value()) {
|
|
return _impl_.value_data_.u32_value_;
|
|
}
|
|
return 0u;
|
|
}
|
|
inline void Value::_internal_set_u32_value(uint32_t value) {
|
|
if (!_internal_has_u32_value()) {
|
|
clear_value_data();
|
|
set_has_u32_value();
|
|
}
|
|
_impl_.value_data_.u32_value_ = value;
|
|
}
|
|
inline uint32_t Value::u32_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.u32_value)
|
|
return _internal_u32_value();
|
|
}
|
|
inline void Value::set_u32_value(uint32_t value) {
|
|
_internal_set_u32_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.u32_value)
|
|
}
|
|
|
|
// uint64 u64_value = 8;
|
|
inline bool Value::_internal_has_u64_value() const {
|
|
return value_data_case() == kU64Value;
|
|
}
|
|
inline bool Value::has_u64_value() const {
|
|
return _internal_has_u64_value();
|
|
}
|
|
inline void Value::set_has_u64_value() {
|
|
_impl_._oneof_case_[0] = kU64Value;
|
|
}
|
|
inline void Value::clear_u64_value() {
|
|
if (_internal_has_u64_value()) {
|
|
_impl_.value_data_.u64_value_ = uint64_t{0u};
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline uint64_t Value::_internal_u64_value() const {
|
|
if (_internal_has_u64_value()) {
|
|
return _impl_.value_data_.u64_value_;
|
|
}
|
|
return uint64_t{0u};
|
|
}
|
|
inline void Value::_internal_set_u64_value(uint64_t value) {
|
|
if (!_internal_has_u64_value()) {
|
|
clear_value_data();
|
|
set_has_u64_value();
|
|
}
|
|
_impl_.value_data_.u64_value_ = value;
|
|
}
|
|
inline uint64_t Value::u64_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.u64_value)
|
|
return _internal_u64_value();
|
|
}
|
|
inline void Value::set_u64_value(uint64_t value) {
|
|
_internal_set_u64_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.u64_value)
|
|
}
|
|
|
|
// float f32_value = 9;
|
|
inline bool Value::_internal_has_f32_value() const {
|
|
return value_data_case() == kF32Value;
|
|
}
|
|
inline bool Value::has_f32_value() const {
|
|
return _internal_has_f32_value();
|
|
}
|
|
inline void Value::set_has_f32_value() {
|
|
_impl_._oneof_case_[0] = kF32Value;
|
|
}
|
|
inline void Value::clear_f32_value() {
|
|
if (_internal_has_f32_value()) {
|
|
_impl_.value_data_.f32_value_ = 0;
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline float Value::_internal_f32_value() const {
|
|
if (_internal_has_f32_value()) {
|
|
return _impl_.value_data_.f32_value_;
|
|
}
|
|
return 0;
|
|
}
|
|
inline void Value::_internal_set_f32_value(float value) {
|
|
if (!_internal_has_f32_value()) {
|
|
clear_value_data();
|
|
set_has_f32_value();
|
|
}
|
|
_impl_.value_data_.f32_value_ = value;
|
|
}
|
|
inline float Value::f32_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.f32_value)
|
|
return _internal_f32_value();
|
|
}
|
|
inline void Value::set_f32_value(float value) {
|
|
_internal_set_f32_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.f32_value)
|
|
}
|
|
|
|
// double f64_value = 10;
|
|
inline bool Value::_internal_has_f64_value() const {
|
|
return value_data_case() == kF64Value;
|
|
}
|
|
inline bool Value::has_f64_value() const {
|
|
return _internal_has_f64_value();
|
|
}
|
|
inline void Value::set_has_f64_value() {
|
|
_impl_._oneof_case_[0] = kF64Value;
|
|
}
|
|
inline void Value::clear_f64_value() {
|
|
if (_internal_has_f64_value()) {
|
|
_impl_.value_data_.f64_value_ = 0;
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline double Value::_internal_f64_value() const {
|
|
if (_internal_has_f64_value()) {
|
|
return _impl_.value_data_.f64_value_;
|
|
}
|
|
return 0;
|
|
}
|
|
inline void Value::_internal_set_f64_value(double value) {
|
|
if (!_internal_has_f64_value()) {
|
|
clear_value_data();
|
|
set_has_f64_value();
|
|
}
|
|
_impl_.value_data_.f64_value_ = value;
|
|
}
|
|
inline double Value::f64_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.f64_value)
|
|
return _internal_f64_value();
|
|
}
|
|
inline void Value::set_f64_value(double value) {
|
|
_internal_set_f64_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.f64_value)
|
|
}
|
|
|
|
// bool bool_value = 11;
|
|
inline bool Value::_internal_has_bool_value() const {
|
|
return value_data_case() == kBoolValue;
|
|
}
|
|
inline bool Value::has_bool_value() const {
|
|
return _internal_has_bool_value();
|
|
}
|
|
inline void Value::set_has_bool_value() {
|
|
_impl_._oneof_case_[0] = kBoolValue;
|
|
}
|
|
inline void Value::clear_bool_value() {
|
|
if (_internal_has_bool_value()) {
|
|
_impl_.value_data_.bool_value_ = false;
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline bool Value::_internal_bool_value() const {
|
|
if (_internal_has_bool_value()) {
|
|
return _impl_.value_data_.bool_value_;
|
|
}
|
|
return false;
|
|
}
|
|
inline void Value::_internal_set_bool_value(bool value) {
|
|
if (!_internal_has_bool_value()) {
|
|
clear_value_data();
|
|
set_has_bool_value();
|
|
}
|
|
_impl_.value_data_.bool_value_ = value;
|
|
}
|
|
inline bool Value::bool_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.bool_value)
|
|
return _internal_bool_value();
|
|
}
|
|
inline void Value::set_bool_value(bool value) {
|
|
_internal_set_bool_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.bool_value)
|
|
}
|
|
|
|
// bytes binary_value = 12;
|
|
inline bool Value::_internal_has_binary_value() const {
|
|
return value_data_case() == kBinaryValue;
|
|
}
|
|
inline bool Value::has_binary_value() const {
|
|
return _internal_has_binary_value();
|
|
}
|
|
inline void Value::set_has_binary_value() {
|
|
_impl_._oneof_case_[0] = kBinaryValue;
|
|
}
|
|
inline void Value::clear_binary_value() {
|
|
if (_internal_has_binary_value()) {
|
|
_impl_.value_data_.binary_value_.Destroy();
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline const std::string& Value::binary_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.binary_value)
|
|
return _internal_binary_value();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline void Value::set_binary_value(ArgT0&& arg0, ArgT... args) {
|
|
if (!_internal_has_binary_value()) {
|
|
clear_value_data();
|
|
set_has_binary_value();
|
|
_impl_.value_data_.binary_value_.InitDefault();
|
|
}
|
|
_impl_.value_data_.binary_value_.SetBytes( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.binary_value)
|
|
}
|
|
inline std::string* Value::mutable_binary_value() {
|
|
std::string* _s = _internal_mutable_binary_value();
|
|
// @@protoc_insertion_point(field_mutable:greptime.v1.Value.binary_value)
|
|
return _s;
|
|
}
|
|
inline const std::string& Value::_internal_binary_value() const {
|
|
if (_internal_has_binary_value()) {
|
|
return _impl_.value_data_.binary_value_.Get();
|
|
}
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
|
|
}
|
|
inline void Value::_internal_set_binary_value(const std::string& value) {
|
|
if (!_internal_has_binary_value()) {
|
|
clear_value_data();
|
|
set_has_binary_value();
|
|
_impl_.value_data_.binary_value_.InitDefault();
|
|
}
|
|
_impl_.value_data_.binary_value_.Set(value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* Value::_internal_mutable_binary_value() {
|
|
if (!_internal_has_binary_value()) {
|
|
clear_value_data();
|
|
set_has_binary_value();
|
|
_impl_.value_data_.binary_value_.InitDefault();
|
|
}
|
|
return _impl_.value_data_.binary_value_.Mutable( GetArenaForAllocation());
|
|
}
|
|
inline std::string* Value::release_binary_value() {
|
|
// @@protoc_insertion_point(field_release:greptime.v1.Value.binary_value)
|
|
if (_internal_has_binary_value()) {
|
|
clear_has_value_data();
|
|
return _impl_.value_data_.binary_value_.Release();
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
inline void Value::set_allocated_binary_value(std::string* binary_value) {
|
|
if (has_value_data()) {
|
|
clear_value_data();
|
|
}
|
|
if (binary_value != nullptr) {
|
|
set_has_binary_value();
|
|
_impl_.value_data_.binary_value_.InitAllocated(binary_value, GetArenaForAllocation());
|
|
}
|
|
// @@protoc_insertion_point(field_set_allocated:greptime.v1.Value.binary_value)
|
|
}
|
|
|
|
// string string_value = 13;
|
|
inline bool Value::_internal_has_string_value() const {
|
|
return value_data_case() == kStringValue;
|
|
}
|
|
inline bool Value::has_string_value() const {
|
|
return _internal_has_string_value();
|
|
}
|
|
inline void Value::set_has_string_value() {
|
|
_impl_._oneof_case_[0] = kStringValue;
|
|
}
|
|
inline void Value::clear_string_value() {
|
|
if (_internal_has_string_value()) {
|
|
_impl_.value_data_.string_value_.Destroy();
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline const std::string& Value::string_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.string_value)
|
|
return _internal_string_value();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline void Value::set_string_value(ArgT0&& arg0, ArgT... args) {
|
|
if (!_internal_has_string_value()) {
|
|
clear_value_data();
|
|
set_has_string_value();
|
|
_impl_.value_data_.string_value_.InitDefault();
|
|
}
|
|
_impl_.value_data_.string_value_.Set( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.string_value)
|
|
}
|
|
inline std::string* Value::mutable_string_value() {
|
|
std::string* _s = _internal_mutable_string_value();
|
|
// @@protoc_insertion_point(field_mutable:greptime.v1.Value.string_value)
|
|
return _s;
|
|
}
|
|
inline const std::string& Value::_internal_string_value() const {
|
|
if (_internal_has_string_value()) {
|
|
return _impl_.value_data_.string_value_.Get();
|
|
}
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
|
|
}
|
|
inline void Value::_internal_set_string_value(const std::string& value) {
|
|
if (!_internal_has_string_value()) {
|
|
clear_value_data();
|
|
set_has_string_value();
|
|
_impl_.value_data_.string_value_.InitDefault();
|
|
}
|
|
_impl_.value_data_.string_value_.Set(value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* Value::_internal_mutable_string_value() {
|
|
if (!_internal_has_string_value()) {
|
|
clear_value_data();
|
|
set_has_string_value();
|
|
_impl_.value_data_.string_value_.InitDefault();
|
|
}
|
|
return _impl_.value_data_.string_value_.Mutable( GetArenaForAllocation());
|
|
}
|
|
inline std::string* Value::release_string_value() {
|
|
// @@protoc_insertion_point(field_release:greptime.v1.Value.string_value)
|
|
if (_internal_has_string_value()) {
|
|
clear_has_value_data();
|
|
return _impl_.value_data_.string_value_.Release();
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
inline void Value::set_allocated_string_value(std::string* string_value) {
|
|
if (has_value_data()) {
|
|
clear_value_data();
|
|
}
|
|
if (string_value != nullptr) {
|
|
set_has_string_value();
|
|
_impl_.value_data_.string_value_.InitAllocated(string_value, GetArenaForAllocation());
|
|
}
|
|
// @@protoc_insertion_point(field_set_allocated:greptime.v1.Value.string_value)
|
|
}
|
|
|
|
// int32 date_value = 14;
|
|
inline bool Value::_internal_has_date_value() const {
|
|
return value_data_case() == kDateValue;
|
|
}
|
|
inline bool Value::has_date_value() const {
|
|
return _internal_has_date_value();
|
|
}
|
|
inline void Value::set_has_date_value() {
|
|
_impl_._oneof_case_[0] = kDateValue;
|
|
}
|
|
inline void Value::clear_date_value() {
|
|
if (_internal_has_date_value()) {
|
|
_impl_.value_data_.date_value_ = 0;
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline int32_t Value::_internal_date_value() const {
|
|
if (_internal_has_date_value()) {
|
|
return _impl_.value_data_.date_value_;
|
|
}
|
|
return 0;
|
|
}
|
|
inline void Value::_internal_set_date_value(int32_t value) {
|
|
if (!_internal_has_date_value()) {
|
|
clear_value_data();
|
|
set_has_date_value();
|
|
}
|
|
_impl_.value_data_.date_value_ = value;
|
|
}
|
|
inline int32_t Value::date_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.date_value)
|
|
return _internal_date_value();
|
|
}
|
|
inline void Value::set_date_value(int32_t value) {
|
|
_internal_set_date_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.date_value)
|
|
}
|
|
|
|
// int64 datetime_value = 15;
|
|
inline bool Value::_internal_has_datetime_value() const {
|
|
return value_data_case() == kDatetimeValue;
|
|
}
|
|
inline bool Value::has_datetime_value() const {
|
|
return _internal_has_datetime_value();
|
|
}
|
|
inline void Value::set_has_datetime_value() {
|
|
_impl_._oneof_case_[0] = kDatetimeValue;
|
|
}
|
|
inline void Value::clear_datetime_value() {
|
|
if (_internal_has_datetime_value()) {
|
|
_impl_.value_data_.datetime_value_ = int64_t{0};
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline int64_t Value::_internal_datetime_value() const {
|
|
if (_internal_has_datetime_value()) {
|
|
return _impl_.value_data_.datetime_value_;
|
|
}
|
|
return int64_t{0};
|
|
}
|
|
inline void Value::_internal_set_datetime_value(int64_t value) {
|
|
if (!_internal_has_datetime_value()) {
|
|
clear_value_data();
|
|
set_has_datetime_value();
|
|
}
|
|
_impl_.value_data_.datetime_value_ = value;
|
|
}
|
|
inline int64_t Value::datetime_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.datetime_value)
|
|
return _internal_datetime_value();
|
|
}
|
|
inline void Value::set_datetime_value(int64_t value) {
|
|
_internal_set_datetime_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.datetime_value)
|
|
}
|
|
|
|
// int64 timestamp_second_value = 16;
|
|
inline bool Value::_internal_has_timestamp_second_value() const {
|
|
return value_data_case() == kTimestampSecondValue;
|
|
}
|
|
inline bool Value::has_timestamp_second_value() const {
|
|
return _internal_has_timestamp_second_value();
|
|
}
|
|
inline void Value::set_has_timestamp_second_value() {
|
|
_impl_._oneof_case_[0] = kTimestampSecondValue;
|
|
}
|
|
inline void Value::clear_timestamp_second_value() {
|
|
if (_internal_has_timestamp_second_value()) {
|
|
_impl_.value_data_.timestamp_second_value_ = int64_t{0};
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline int64_t Value::_internal_timestamp_second_value() const {
|
|
if (_internal_has_timestamp_second_value()) {
|
|
return _impl_.value_data_.timestamp_second_value_;
|
|
}
|
|
return int64_t{0};
|
|
}
|
|
inline void Value::_internal_set_timestamp_second_value(int64_t value) {
|
|
if (!_internal_has_timestamp_second_value()) {
|
|
clear_value_data();
|
|
set_has_timestamp_second_value();
|
|
}
|
|
_impl_.value_data_.timestamp_second_value_ = value;
|
|
}
|
|
inline int64_t Value::timestamp_second_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.timestamp_second_value)
|
|
return _internal_timestamp_second_value();
|
|
}
|
|
inline void Value::set_timestamp_second_value(int64_t value) {
|
|
_internal_set_timestamp_second_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.timestamp_second_value)
|
|
}
|
|
|
|
// int64 timestamp_millisecond_value = 17;
|
|
inline bool Value::_internal_has_timestamp_millisecond_value() const {
|
|
return value_data_case() == kTimestampMillisecondValue;
|
|
}
|
|
inline bool Value::has_timestamp_millisecond_value() const {
|
|
return _internal_has_timestamp_millisecond_value();
|
|
}
|
|
inline void Value::set_has_timestamp_millisecond_value() {
|
|
_impl_._oneof_case_[0] = kTimestampMillisecondValue;
|
|
}
|
|
inline void Value::clear_timestamp_millisecond_value() {
|
|
if (_internal_has_timestamp_millisecond_value()) {
|
|
_impl_.value_data_.timestamp_millisecond_value_ = int64_t{0};
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline int64_t Value::_internal_timestamp_millisecond_value() const {
|
|
if (_internal_has_timestamp_millisecond_value()) {
|
|
return _impl_.value_data_.timestamp_millisecond_value_;
|
|
}
|
|
return int64_t{0};
|
|
}
|
|
inline void Value::_internal_set_timestamp_millisecond_value(int64_t value) {
|
|
if (!_internal_has_timestamp_millisecond_value()) {
|
|
clear_value_data();
|
|
set_has_timestamp_millisecond_value();
|
|
}
|
|
_impl_.value_data_.timestamp_millisecond_value_ = value;
|
|
}
|
|
inline int64_t Value::timestamp_millisecond_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.timestamp_millisecond_value)
|
|
return _internal_timestamp_millisecond_value();
|
|
}
|
|
inline void Value::set_timestamp_millisecond_value(int64_t value) {
|
|
_internal_set_timestamp_millisecond_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.timestamp_millisecond_value)
|
|
}
|
|
|
|
// int64 timestamp_microsecond_value = 18;
|
|
inline bool Value::_internal_has_timestamp_microsecond_value() const {
|
|
return value_data_case() == kTimestampMicrosecondValue;
|
|
}
|
|
inline bool Value::has_timestamp_microsecond_value() const {
|
|
return _internal_has_timestamp_microsecond_value();
|
|
}
|
|
inline void Value::set_has_timestamp_microsecond_value() {
|
|
_impl_._oneof_case_[0] = kTimestampMicrosecondValue;
|
|
}
|
|
inline void Value::clear_timestamp_microsecond_value() {
|
|
if (_internal_has_timestamp_microsecond_value()) {
|
|
_impl_.value_data_.timestamp_microsecond_value_ = int64_t{0};
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline int64_t Value::_internal_timestamp_microsecond_value() const {
|
|
if (_internal_has_timestamp_microsecond_value()) {
|
|
return _impl_.value_data_.timestamp_microsecond_value_;
|
|
}
|
|
return int64_t{0};
|
|
}
|
|
inline void Value::_internal_set_timestamp_microsecond_value(int64_t value) {
|
|
if (!_internal_has_timestamp_microsecond_value()) {
|
|
clear_value_data();
|
|
set_has_timestamp_microsecond_value();
|
|
}
|
|
_impl_.value_data_.timestamp_microsecond_value_ = value;
|
|
}
|
|
inline int64_t Value::timestamp_microsecond_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.timestamp_microsecond_value)
|
|
return _internal_timestamp_microsecond_value();
|
|
}
|
|
inline void Value::set_timestamp_microsecond_value(int64_t value) {
|
|
_internal_set_timestamp_microsecond_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.timestamp_microsecond_value)
|
|
}
|
|
|
|
// int64 timestamp_nanosecond_value = 19;
|
|
inline bool Value::_internal_has_timestamp_nanosecond_value() const {
|
|
return value_data_case() == kTimestampNanosecondValue;
|
|
}
|
|
inline bool Value::has_timestamp_nanosecond_value() const {
|
|
return _internal_has_timestamp_nanosecond_value();
|
|
}
|
|
inline void Value::set_has_timestamp_nanosecond_value() {
|
|
_impl_._oneof_case_[0] = kTimestampNanosecondValue;
|
|
}
|
|
inline void Value::clear_timestamp_nanosecond_value() {
|
|
if (_internal_has_timestamp_nanosecond_value()) {
|
|
_impl_.value_data_.timestamp_nanosecond_value_ = int64_t{0};
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline int64_t Value::_internal_timestamp_nanosecond_value() const {
|
|
if (_internal_has_timestamp_nanosecond_value()) {
|
|
return _impl_.value_data_.timestamp_nanosecond_value_;
|
|
}
|
|
return int64_t{0};
|
|
}
|
|
inline void Value::_internal_set_timestamp_nanosecond_value(int64_t value) {
|
|
if (!_internal_has_timestamp_nanosecond_value()) {
|
|
clear_value_data();
|
|
set_has_timestamp_nanosecond_value();
|
|
}
|
|
_impl_.value_data_.timestamp_nanosecond_value_ = value;
|
|
}
|
|
inline int64_t Value::timestamp_nanosecond_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.timestamp_nanosecond_value)
|
|
return _internal_timestamp_nanosecond_value();
|
|
}
|
|
inline void Value::set_timestamp_nanosecond_value(int64_t value) {
|
|
_internal_set_timestamp_nanosecond_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.timestamp_nanosecond_value)
|
|
}
|
|
|
|
// int64 time_second_value = 20;
|
|
inline bool Value::_internal_has_time_second_value() const {
|
|
return value_data_case() == kTimeSecondValue;
|
|
}
|
|
inline bool Value::has_time_second_value() const {
|
|
return _internal_has_time_second_value();
|
|
}
|
|
inline void Value::set_has_time_second_value() {
|
|
_impl_._oneof_case_[0] = kTimeSecondValue;
|
|
}
|
|
inline void Value::clear_time_second_value() {
|
|
if (_internal_has_time_second_value()) {
|
|
_impl_.value_data_.time_second_value_ = int64_t{0};
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline int64_t Value::_internal_time_second_value() const {
|
|
if (_internal_has_time_second_value()) {
|
|
return _impl_.value_data_.time_second_value_;
|
|
}
|
|
return int64_t{0};
|
|
}
|
|
inline void Value::_internal_set_time_second_value(int64_t value) {
|
|
if (!_internal_has_time_second_value()) {
|
|
clear_value_data();
|
|
set_has_time_second_value();
|
|
}
|
|
_impl_.value_data_.time_second_value_ = value;
|
|
}
|
|
inline int64_t Value::time_second_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.time_second_value)
|
|
return _internal_time_second_value();
|
|
}
|
|
inline void Value::set_time_second_value(int64_t value) {
|
|
_internal_set_time_second_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.time_second_value)
|
|
}
|
|
|
|
// int64 time_millisecond_value = 21;
|
|
inline bool Value::_internal_has_time_millisecond_value() const {
|
|
return value_data_case() == kTimeMillisecondValue;
|
|
}
|
|
inline bool Value::has_time_millisecond_value() const {
|
|
return _internal_has_time_millisecond_value();
|
|
}
|
|
inline void Value::set_has_time_millisecond_value() {
|
|
_impl_._oneof_case_[0] = kTimeMillisecondValue;
|
|
}
|
|
inline void Value::clear_time_millisecond_value() {
|
|
if (_internal_has_time_millisecond_value()) {
|
|
_impl_.value_data_.time_millisecond_value_ = int64_t{0};
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline int64_t Value::_internal_time_millisecond_value() const {
|
|
if (_internal_has_time_millisecond_value()) {
|
|
return _impl_.value_data_.time_millisecond_value_;
|
|
}
|
|
return int64_t{0};
|
|
}
|
|
inline void Value::_internal_set_time_millisecond_value(int64_t value) {
|
|
if (!_internal_has_time_millisecond_value()) {
|
|
clear_value_data();
|
|
set_has_time_millisecond_value();
|
|
}
|
|
_impl_.value_data_.time_millisecond_value_ = value;
|
|
}
|
|
inline int64_t Value::time_millisecond_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.time_millisecond_value)
|
|
return _internal_time_millisecond_value();
|
|
}
|
|
inline void Value::set_time_millisecond_value(int64_t value) {
|
|
_internal_set_time_millisecond_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.time_millisecond_value)
|
|
}
|
|
|
|
// int64 time_microsecond_value = 22;
|
|
inline bool Value::_internal_has_time_microsecond_value() const {
|
|
return value_data_case() == kTimeMicrosecondValue;
|
|
}
|
|
inline bool Value::has_time_microsecond_value() const {
|
|
return _internal_has_time_microsecond_value();
|
|
}
|
|
inline void Value::set_has_time_microsecond_value() {
|
|
_impl_._oneof_case_[0] = kTimeMicrosecondValue;
|
|
}
|
|
inline void Value::clear_time_microsecond_value() {
|
|
if (_internal_has_time_microsecond_value()) {
|
|
_impl_.value_data_.time_microsecond_value_ = int64_t{0};
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline int64_t Value::_internal_time_microsecond_value() const {
|
|
if (_internal_has_time_microsecond_value()) {
|
|
return _impl_.value_data_.time_microsecond_value_;
|
|
}
|
|
return int64_t{0};
|
|
}
|
|
inline void Value::_internal_set_time_microsecond_value(int64_t value) {
|
|
if (!_internal_has_time_microsecond_value()) {
|
|
clear_value_data();
|
|
set_has_time_microsecond_value();
|
|
}
|
|
_impl_.value_data_.time_microsecond_value_ = value;
|
|
}
|
|
inline int64_t Value::time_microsecond_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.time_microsecond_value)
|
|
return _internal_time_microsecond_value();
|
|
}
|
|
inline void Value::set_time_microsecond_value(int64_t value) {
|
|
_internal_set_time_microsecond_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.time_microsecond_value)
|
|
}
|
|
|
|
// int64 time_nanosecond_value = 23;
|
|
inline bool Value::_internal_has_time_nanosecond_value() const {
|
|
return value_data_case() == kTimeNanosecondValue;
|
|
}
|
|
inline bool Value::has_time_nanosecond_value() const {
|
|
return _internal_has_time_nanosecond_value();
|
|
}
|
|
inline void Value::set_has_time_nanosecond_value() {
|
|
_impl_._oneof_case_[0] = kTimeNanosecondValue;
|
|
}
|
|
inline void Value::clear_time_nanosecond_value() {
|
|
if (_internal_has_time_nanosecond_value()) {
|
|
_impl_.value_data_.time_nanosecond_value_ = int64_t{0};
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline int64_t Value::_internal_time_nanosecond_value() const {
|
|
if (_internal_has_time_nanosecond_value()) {
|
|
return _impl_.value_data_.time_nanosecond_value_;
|
|
}
|
|
return int64_t{0};
|
|
}
|
|
inline void Value::_internal_set_time_nanosecond_value(int64_t value) {
|
|
if (!_internal_has_time_nanosecond_value()) {
|
|
clear_value_data();
|
|
set_has_time_nanosecond_value();
|
|
}
|
|
_impl_.value_data_.time_nanosecond_value_ = value;
|
|
}
|
|
inline int64_t Value::time_nanosecond_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.time_nanosecond_value)
|
|
return _internal_time_nanosecond_value();
|
|
}
|
|
inline void Value::set_time_nanosecond_value(int64_t value) {
|
|
_internal_set_time_nanosecond_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.time_nanosecond_value)
|
|
}
|
|
|
|
// int32 interval_year_month_value = 24;
|
|
inline bool Value::_internal_has_interval_year_month_value() const {
|
|
return value_data_case() == kIntervalYearMonthValue;
|
|
}
|
|
inline bool Value::has_interval_year_month_value() const {
|
|
return _internal_has_interval_year_month_value();
|
|
}
|
|
inline void Value::set_has_interval_year_month_value() {
|
|
_impl_._oneof_case_[0] = kIntervalYearMonthValue;
|
|
}
|
|
inline void Value::clear_interval_year_month_value() {
|
|
if (_internal_has_interval_year_month_value()) {
|
|
_impl_.value_data_.interval_year_month_value_ = 0;
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline int32_t Value::_internal_interval_year_month_value() const {
|
|
if (_internal_has_interval_year_month_value()) {
|
|
return _impl_.value_data_.interval_year_month_value_;
|
|
}
|
|
return 0;
|
|
}
|
|
inline void Value::_internal_set_interval_year_month_value(int32_t value) {
|
|
if (!_internal_has_interval_year_month_value()) {
|
|
clear_value_data();
|
|
set_has_interval_year_month_value();
|
|
}
|
|
_impl_.value_data_.interval_year_month_value_ = value;
|
|
}
|
|
inline int32_t Value::interval_year_month_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.interval_year_month_value)
|
|
return _internal_interval_year_month_value();
|
|
}
|
|
inline void Value::set_interval_year_month_value(int32_t value) {
|
|
_internal_set_interval_year_month_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.interval_year_month_value)
|
|
}
|
|
|
|
// int64 interval_day_time_value = 25;
|
|
inline bool Value::_internal_has_interval_day_time_value() const {
|
|
return value_data_case() == kIntervalDayTimeValue;
|
|
}
|
|
inline bool Value::has_interval_day_time_value() const {
|
|
return _internal_has_interval_day_time_value();
|
|
}
|
|
inline void Value::set_has_interval_day_time_value() {
|
|
_impl_._oneof_case_[0] = kIntervalDayTimeValue;
|
|
}
|
|
inline void Value::clear_interval_day_time_value() {
|
|
if (_internal_has_interval_day_time_value()) {
|
|
_impl_.value_data_.interval_day_time_value_ = int64_t{0};
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline int64_t Value::_internal_interval_day_time_value() const {
|
|
if (_internal_has_interval_day_time_value()) {
|
|
return _impl_.value_data_.interval_day_time_value_;
|
|
}
|
|
return int64_t{0};
|
|
}
|
|
inline void Value::_internal_set_interval_day_time_value(int64_t value) {
|
|
if (!_internal_has_interval_day_time_value()) {
|
|
clear_value_data();
|
|
set_has_interval_day_time_value();
|
|
}
|
|
_impl_.value_data_.interval_day_time_value_ = value;
|
|
}
|
|
inline int64_t Value::interval_day_time_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.interval_day_time_value)
|
|
return _internal_interval_day_time_value();
|
|
}
|
|
inline void Value::set_interval_day_time_value(int64_t value) {
|
|
_internal_set_interval_day_time_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.interval_day_time_value)
|
|
}
|
|
|
|
// .greptime.v1.IntervalMonthDayNano interval_month_day_nano_value = 26;
|
|
inline bool Value::_internal_has_interval_month_day_nano_value() const {
|
|
return value_data_case() == kIntervalMonthDayNanoValue;
|
|
}
|
|
inline bool Value::has_interval_month_day_nano_value() const {
|
|
return _internal_has_interval_month_day_nano_value();
|
|
}
|
|
inline void Value::set_has_interval_month_day_nano_value() {
|
|
_impl_._oneof_case_[0] = kIntervalMonthDayNanoValue;
|
|
}
|
|
inline ::greptime::v1::IntervalMonthDayNano* Value::release_interval_month_day_nano_value() {
|
|
// @@protoc_insertion_point(field_release:greptime.v1.Value.interval_month_day_nano_value)
|
|
if (_internal_has_interval_month_day_nano_value()) {
|
|
clear_has_value_data();
|
|
::greptime::v1::IntervalMonthDayNano* temp = _impl_.value_data_.interval_month_day_nano_value_;
|
|
if (GetArenaForAllocation() != nullptr) {
|
|
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
|
|
}
|
|
_impl_.value_data_.interval_month_day_nano_value_ = nullptr;
|
|
return temp;
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
inline const ::greptime::v1::IntervalMonthDayNano& Value::_internal_interval_month_day_nano_value() const {
|
|
return _internal_has_interval_month_day_nano_value()
|
|
? *_impl_.value_data_.interval_month_day_nano_value_
|
|
: reinterpret_cast< ::greptime::v1::IntervalMonthDayNano&>(::greptime::v1::_IntervalMonthDayNano_default_instance_);
|
|
}
|
|
inline const ::greptime::v1::IntervalMonthDayNano& Value::interval_month_day_nano_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.interval_month_day_nano_value)
|
|
return _internal_interval_month_day_nano_value();
|
|
}
|
|
inline ::greptime::v1::IntervalMonthDayNano* Value::unsafe_arena_release_interval_month_day_nano_value() {
|
|
// @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.Value.interval_month_day_nano_value)
|
|
if (_internal_has_interval_month_day_nano_value()) {
|
|
clear_has_value_data();
|
|
::greptime::v1::IntervalMonthDayNano* temp = _impl_.value_data_.interval_month_day_nano_value_;
|
|
_impl_.value_data_.interval_month_day_nano_value_ = nullptr;
|
|
return temp;
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
inline void Value::unsafe_arena_set_allocated_interval_month_day_nano_value(::greptime::v1::IntervalMonthDayNano* interval_month_day_nano_value) {
|
|
clear_value_data();
|
|
if (interval_month_day_nano_value) {
|
|
set_has_interval_month_day_nano_value();
|
|
_impl_.value_data_.interval_month_day_nano_value_ = interval_month_day_nano_value;
|
|
}
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.Value.interval_month_day_nano_value)
|
|
}
|
|
inline ::greptime::v1::IntervalMonthDayNano* Value::_internal_mutable_interval_month_day_nano_value() {
|
|
if (!_internal_has_interval_month_day_nano_value()) {
|
|
clear_value_data();
|
|
set_has_interval_month_day_nano_value();
|
|
_impl_.value_data_.interval_month_day_nano_value_ = CreateMaybeMessage< ::greptime::v1::IntervalMonthDayNano >(GetArenaForAllocation());
|
|
}
|
|
return _impl_.value_data_.interval_month_day_nano_value_;
|
|
}
|
|
inline ::greptime::v1::IntervalMonthDayNano* Value::mutable_interval_month_day_nano_value() {
|
|
::greptime::v1::IntervalMonthDayNano* _msg = _internal_mutable_interval_month_day_nano_value();
|
|
// @@protoc_insertion_point(field_mutable:greptime.v1.Value.interval_month_day_nano_value)
|
|
return _msg;
|
|
}
|
|
|
|
// int64 duration_second_value = 27;
|
|
inline bool Value::_internal_has_duration_second_value() const {
|
|
return value_data_case() == kDurationSecondValue;
|
|
}
|
|
inline bool Value::has_duration_second_value() const {
|
|
return _internal_has_duration_second_value();
|
|
}
|
|
inline void Value::set_has_duration_second_value() {
|
|
_impl_._oneof_case_[0] = kDurationSecondValue;
|
|
}
|
|
inline void Value::clear_duration_second_value() {
|
|
if (_internal_has_duration_second_value()) {
|
|
_impl_.value_data_.duration_second_value_ = int64_t{0};
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline int64_t Value::_internal_duration_second_value() const {
|
|
if (_internal_has_duration_second_value()) {
|
|
return _impl_.value_data_.duration_second_value_;
|
|
}
|
|
return int64_t{0};
|
|
}
|
|
inline void Value::_internal_set_duration_second_value(int64_t value) {
|
|
if (!_internal_has_duration_second_value()) {
|
|
clear_value_data();
|
|
set_has_duration_second_value();
|
|
}
|
|
_impl_.value_data_.duration_second_value_ = value;
|
|
}
|
|
inline int64_t Value::duration_second_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.duration_second_value)
|
|
return _internal_duration_second_value();
|
|
}
|
|
inline void Value::set_duration_second_value(int64_t value) {
|
|
_internal_set_duration_second_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.duration_second_value)
|
|
}
|
|
|
|
// int64 duration_millisecond_value = 28;
|
|
inline bool Value::_internal_has_duration_millisecond_value() const {
|
|
return value_data_case() == kDurationMillisecondValue;
|
|
}
|
|
inline bool Value::has_duration_millisecond_value() const {
|
|
return _internal_has_duration_millisecond_value();
|
|
}
|
|
inline void Value::set_has_duration_millisecond_value() {
|
|
_impl_._oneof_case_[0] = kDurationMillisecondValue;
|
|
}
|
|
inline void Value::clear_duration_millisecond_value() {
|
|
if (_internal_has_duration_millisecond_value()) {
|
|
_impl_.value_data_.duration_millisecond_value_ = int64_t{0};
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline int64_t Value::_internal_duration_millisecond_value() const {
|
|
if (_internal_has_duration_millisecond_value()) {
|
|
return _impl_.value_data_.duration_millisecond_value_;
|
|
}
|
|
return int64_t{0};
|
|
}
|
|
inline void Value::_internal_set_duration_millisecond_value(int64_t value) {
|
|
if (!_internal_has_duration_millisecond_value()) {
|
|
clear_value_data();
|
|
set_has_duration_millisecond_value();
|
|
}
|
|
_impl_.value_data_.duration_millisecond_value_ = value;
|
|
}
|
|
inline int64_t Value::duration_millisecond_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.duration_millisecond_value)
|
|
return _internal_duration_millisecond_value();
|
|
}
|
|
inline void Value::set_duration_millisecond_value(int64_t value) {
|
|
_internal_set_duration_millisecond_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.duration_millisecond_value)
|
|
}
|
|
|
|
// int64 duration_microsecond_value = 29;
|
|
inline bool Value::_internal_has_duration_microsecond_value() const {
|
|
return value_data_case() == kDurationMicrosecondValue;
|
|
}
|
|
inline bool Value::has_duration_microsecond_value() const {
|
|
return _internal_has_duration_microsecond_value();
|
|
}
|
|
inline void Value::set_has_duration_microsecond_value() {
|
|
_impl_._oneof_case_[0] = kDurationMicrosecondValue;
|
|
}
|
|
inline void Value::clear_duration_microsecond_value() {
|
|
if (_internal_has_duration_microsecond_value()) {
|
|
_impl_.value_data_.duration_microsecond_value_ = int64_t{0};
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline int64_t Value::_internal_duration_microsecond_value() const {
|
|
if (_internal_has_duration_microsecond_value()) {
|
|
return _impl_.value_data_.duration_microsecond_value_;
|
|
}
|
|
return int64_t{0};
|
|
}
|
|
inline void Value::_internal_set_duration_microsecond_value(int64_t value) {
|
|
if (!_internal_has_duration_microsecond_value()) {
|
|
clear_value_data();
|
|
set_has_duration_microsecond_value();
|
|
}
|
|
_impl_.value_data_.duration_microsecond_value_ = value;
|
|
}
|
|
inline int64_t Value::duration_microsecond_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.duration_microsecond_value)
|
|
return _internal_duration_microsecond_value();
|
|
}
|
|
inline void Value::set_duration_microsecond_value(int64_t value) {
|
|
_internal_set_duration_microsecond_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.duration_microsecond_value)
|
|
}
|
|
|
|
// int64 duration_nanosecond_value = 30;
|
|
inline bool Value::_internal_has_duration_nanosecond_value() const {
|
|
return value_data_case() == kDurationNanosecondValue;
|
|
}
|
|
inline bool Value::has_duration_nanosecond_value() const {
|
|
return _internal_has_duration_nanosecond_value();
|
|
}
|
|
inline void Value::set_has_duration_nanosecond_value() {
|
|
_impl_._oneof_case_[0] = kDurationNanosecondValue;
|
|
}
|
|
inline void Value::clear_duration_nanosecond_value() {
|
|
if (_internal_has_duration_nanosecond_value()) {
|
|
_impl_.value_data_.duration_nanosecond_value_ = int64_t{0};
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline int64_t Value::_internal_duration_nanosecond_value() const {
|
|
if (_internal_has_duration_nanosecond_value()) {
|
|
return _impl_.value_data_.duration_nanosecond_value_;
|
|
}
|
|
return int64_t{0};
|
|
}
|
|
inline void Value::_internal_set_duration_nanosecond_value(int64_t value) {
|
|
if (!_internal_has_duration_nanosecond_value()) {
|
|
clear_value_data();
|
|
set_has_duration_nanosecond_value();
|
|
}
|
|
_impl_.value_data_.duration_nanosecond_value_ = value;
|
|
}
|
|
inline int64_t Value::duration_nanosecond_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.duration_nanosecond_value)
|
|
return _internal_duration_nanosecond_value();
|
|
}
|
|
inline void Value::set_duration_nanosecond_value(int64_t value) {
|
|
_internal_set_duration_nanosecond_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.duration_nanosecond_value)
|
|
}
|
|
|
|
// .greptime.v1.Decimal128 decimal128_value = 31;
|
|
inline bool Value::_internal_has_decimal128_value() const {
|
|
return value_data_case() == kDecimal128Value;
|
|
}
|
|
inline bool Value::has_decimal128_value() const {
|
|
return _internal_has_decimal128_value();
|
|
}
|
|
inline void Value::set_has_decimal128_value() {
|
|
_impl_._oneof_case_[0] = kDecimal128Value;
|
|
}
|
|
inline ::greptime::v1::Decimal128* Value::release_decimal128_value() {
|
|
// @@protoc_insertion_point(field_release:greptime.v1.Value.decimal128_value)
|
|
if (_internal_has_decimal128_value()) {
|
|
clear_has_value_data();
|
|
::greptime::v1::Decimal128* temp = _impl_.value_data_.decimal128_value_;
|
|
if (GetArenaForAllocation() != nullptr) {
|
|
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
|
|
}
|
|
_impl_.value_data_.decimal128_value_ = nullptr;
|
|
return temp;
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
inline const ::greptime::v1::Decimal128& Value::_internal_decimal128_value() const {
|
|
return _internal_has_decimal128_value()
|
|
? *_impl_.value_data_.decimal128_value_
|
|
: reinterpret_cast< ::greptime::v1::Decimal128&>(::greptime::v1::_Decimal128_default_instance_);
|
|
}
|
|
inline const ::greptime::v1::Decimal128& Value::decimal128_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.decimal128_value)
|
|
return _internal_decimal128_value();
|
|
}
|
|
inline ::greptime::v1::Decimal128* Value::unsafe_arena_release_decimal128_value() {
|
|
// @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.Value.decimal128_value)
|
|
if (_internal_has_decimal128_value()) {
|
|
clear_has_value_data();
|
|
::greptime::v1::Decimal128* temp = _impl_.value_data_.decimal128_value_;
|
|
_impl_.value_data_.decimal128_value_ = nullptr;
|
|
return temp;
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
inline void Value::unsafe_arena_set_allocated_decimal128_value(::greptime::v1::Decimal128* decimal128_value) {
|
|
clear_value_data();
|
|
if (decimal128_value) {
|
|
set_has_decimal128_value();
|
|
_impl_.value_data_.decimal128_value_ = decimal128_value;
|
|
}
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.Value.decimal128_value)
|
|
}
|
|
inline ::greptime::v1::Decimal128* Value::_internal_mutable_decimal128_value() {
|
|
if (!_internal_has_decimal128_value()) {
|
|
clear_value_data();
|
|
set_has_decimal128_value();
|
|
_impl_.value_data_.decimal128_value_ = CreateMaybeMessage< ::greptime::v1::Decimal128 >(GetArenaForAllocation());
|
|
}
|
|
return _impl_.value_data_.decimal128_value_;
|
|
}
|
|
inline ::greptime::v1::Decimal128* Value::mutable_decimal128_value() {
|
|
::greptime::v1::Decimal128* _msg = _internal_mutable_decimal128_value();
|
|
// @@protoc_insertion_point(field_mutable:greptime.v1.Value.decimal128_value)
|
|
return _msg;
|
|
}
|
|
|
|
inline bool Value::has_value_data() const {
|
|
return value_data_case() != VALUE_DATA_NOT_SET;
|
|
}
|
|
inline void Value::clear_has_value_data() {
|
|
_impl_._oneof_case_[0] = VALUE_DATA_NOT_SET;
|
|
}
|
|
inline Value::ValueDataCase Value::value_data_case() const {
|
|
return Value::ValueDataCase(_impl_._oneof_case_[0]);
|
|
}
|
|
#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_2frow_2eproto
|